Terms & Definitions

• Checked vs Unchecked Exceptions: What is the difference?
• Access Control Modifiers in Java
• Data Abstraction & Data Encapsulation in Java
• Generics
• Getters (Observers) & Setters (Transformers)
• Instance Variable Vs Class Variable in Java
• Protected Keyword
• Reserved Keywords
• Signed vs Unsigned Data in Java
• toString()
• Two’s Complement

Applet Vs Application

All Java programs can be classified as Applications and Applets. The striking differences are that applications contain main() method where as applets do not. One more is, applications can be executed at DOS prompt and applets in a browser. We can say, an applet is an Internet application. [Source]

Concatenate

Concatenate meas to to link together; unite in a series or chain.

Not to subtract. But to add to the end of something. ie concatenate 1 with 1 = 11

Constructors

A class can contain constructors that, when invoked, make objects according to the class “blueprints”. So a constructor declaration looks like a method declaration, but constructors use the name of their class and have no return type. An example of a constructor (with arguments) is down below:

public Bicycle(int cadenceStart, int speedStart, int GearStart) {
    gear = gearStart;
    cadence = cadenceStart;
    speed = speedStart;
}

To make a new object you invoke the constructor with the new operator:

Bicycle roadBike = new Bicycle(5, 11, 17)

No Args Constructor

No Args constructor mean literally that there are no “arguments” or anything in the constructor itself. Let me show you:

Args Constructor:

public Bicycle(int CadenceStart, int SpeedStart, int GearStart) {
    gear = gearStart;
    cadence = cadenceStart;
    speed = speedStart;
}

Notice that int startCadence, int startSpeed, and startGear are all arguments in the Bicycle constructor.

No Args Constructor:

public Bicycle() {
    gear = 1;
    cadence = 10;
    speed = 0;
}

Notice that there isn’t any arguments in between the parenthesis ().

[Source]

Identifiers

Immutable

What does it mean to be immutable in Java?

Immutable means that once the constructor for an object has completed the execution, that instance of an object can not be altered.

This is useful because it means that you can pass a reference to the object without worrying that something else is going to change it contents. This is especially useful when you are dealing with concurrency, so that there are no locking issues given that immutable objects never change.

For example:

class Foo
{
     private final String myvar;

     public Foo(final String initialValue)
     {
         this.myvar = initialValue;
     }

     public String getValue()
     {
         return this.myvar;
     }
}

Foo doesn’t have to worry that the caller to getValue() might change the text in the string.

If you imagine a similar class to Foo, but with a StringBuilder rather than a String as a member, you can see that a caller to getValue() would be able to alter the StringBuilder attribute of a Foo instance. [Source]

How do you make something Immutable?

Initializing

Reserved Keywords

In Java, keywords have a special meaning and are a part of the syntax. Reserved Keywords that have a unique meaning to the compiler, and so are reserved for specific purposes only; Reserved Keywords cannot be used in other circumstances. An example of a Reserved Keywords is class; if the compiler sees the word class, it understands that what comes after the word class is the name of the class. Other examples of Reserved Keywords include public, static, and void.

Return

Note that a method returns to the code that invoked it when it completes running through all statements in the method, reaches the return statement or throws an exception (?). Which ever one of these 3 that occurs first.

So in the body of the method, you can use the return statement to return a value. [Source]

What does the return keyword do in a void method in Java?

At that point, it makes Java exit the method. Once the return statement is executed, the rest of the code will not be executed.

For example, the youWillGetAnError(); statement will not execute when being placed after the return statement.

.
.
.
if (n == 3) {
    return;
    youWillGetAnError(); //compiler error here
}

[Source]

It’s generally true that no further code is executed after a return statement. However, if the return statement is in a try or catch block, then the corresponding finally-block will still be executed if present. This may fit better into a try-catch-finally part, but I think I should mention it. [Source]

Get() Fetch()

If you have noticed, a lot of java programs have methods that describe them with get or fetch. The purpose of these methods is to get or fetch a value back to somewhere. In other words, these methods return a value.

To recap, if you want to design a method that gets/fetches/returns a value, the method should have the return keyword inside the method like this:

...
// Display total payment
   System.out.println("The total payment is " + loan.getTotalPayment());
...
// Find total payment
   public double getTotalPayment() { 
   double totalPayment = getMonthlyPayment() * numberOfYears * 12; 
   return totalPayment;

*The standard/convention is get(), but I use fetch() to remind myself that the return statement is the key for returning a value, not what the method is named.

static

static members (fields and methods) belong to the class instead of an instance of the class.

That means that static members are shared for all of the class, but non-static members are only available for the instance of the class.

It means that only one instance of a static field exists even if you make a million instances of the class or you don’t make any. It will be shared by all instances.

Since static method also don’t belong to a specific instance, they can’t refer to instance members (how would you know which instance Hello class you want to refer to?). static members can only refer to static members. Instance members can access non-static members.

*static members can access instance members through an object reference.

public class Example {
    private static boolean staticField;
    private boolean instanceField;
    public static void main(String[] args) {
        // a static method can access static fields
        staticField = true;

        // a static method can access instance fields through an object reference
        Example instance = new Example();
        instance.instanceField = true;
    }

[1]: Depending on the runtime characteristics, it can be one per ClassLoader or AppDomain or thread, but that is beside the point.

[Source]

this

Version 1: this is a reserved keyword that is used to refer back to the current object.

Version 2: Java’s this keyword is used to refer to other constructors when it’s the first thing that’s called in a constructor.

Each non-static method runs in the context of an object. So if you have a class like this:

public class MyThisTest {
  private int a;

  public MyThisTest() {
    this(42); // calls the other constructor
  }

  public MyThisTest(int a) {
    this.a = a; // assigns the value of the parameter a to the field of the same name
  }

  public void frobnicate() {
    int a = 1;

    System.out.println(a); // refers to the local variable a
    System.out.println(this.a); // refers to the field a
    System.out.println(this); // refers to this entire object
  }

  public String toString() {
    return "MyThisTest a=" + a; // refers to the field a
  }
}

Then calling frobnicate() on new MyThisTest() will print

1
42
MyThisTest a=42

So effectively you use it for multiple things:

• clarify that you are talking about a field, when there’s also something else with the same name as a field
• refer to the current object as a whole
• invoke other constructors of the current class in your constructor [Source]

Let me show you how the “this” keyword passes along what it is referring to:

Super

The super keyword is used to access members of a subclass inherited by the superclass from which the members appear from.

• super allows a subclass to access overridden methods and hidden members of its superclass.
• super allows the subclass constructor to pass to the superclass constructor, including the constructor’s parameters.

Non-Reserved Keywords

These keywords have a special meaning in the right context. But can also be used as identifiers.

append

append: Appends object at end.

x = [1, 2, 3]
x.append([4, 5])
print (x)

gives you: [1, 2, 3, [4, 5]]

extend

extend: Extends list by appending elements from the iterable.

x = [1, 2, 3]
x.extend([4, 5])
print (x)

gives you: [1, 2, 3, 4, 5]

[Source]

Method / Class Relationship

A method is a function that is bound to a class.

So what is a function? A function is a collection of computing statements and so is a procedure. So functions and procedures are the same in most programming languages. But In some languages; a function returns a value, but a procedure does not.

So what is a class? In conventional Object Oriented programming, a class is a collection of data (member variables) bound together with the functions/procedures that act on that data (like member functions or methods).

In conclusion, a method is a collection of computing statements that is bound to a class.

[Source]

Method / Object / Class Relationship

Method = The task

Invoke a Method on Object = ask the object to perform a task

Object = An instance of class. In other words, class is a template for manufacturing objects. Again in alternative text, class is a blueprint that describes methods and variables in each object. One more time, an object is something, while the class is simply the plans for making that something.

Numeric Data Types

Here are 8 primitive data types in Java:

Byte

A byte is composed of 8 bits. And 8 bits can represent up to 256 combinations. In unsigned binary this is 0-255 but in java primitives use signed binary which allows for negative numbers. The downside is that you can’t go as far in either direction because you are using one of the 8 bits to determine if a number is positive or negative you you only have 7 bits to work with. A signed 8 bit number has a range of -128 to 127 [Source].

Boolean

For True/False logic…

Char

For single Characters…

Double & Float

float is represented in 32 bits, with 1 sign bit, 8 bits of exponent, and 23 bits of the mantissa (or what follows from a scientific-notation number: 2.33728*10¹²; 33728 is the mantissa).

double is represented in 64 bits, with 1 sign bit, 11 bits of exponent, and 52 bits of mantissa.

By default, Java uses double to represent its floating-point numerals (so a literal 3.14 is typed double). It’s also the data type that will give you a much larger number range, so I would strongly encourage its use over float.

There may be certain libraries that actually force your usage of float, but in general – unless you can guarantee that your result will be small enough to fit in float‘s prescribed range, then it’s best to opt with double.

If you require accuracy – for instance, you can’t have a decimal value that is inaccurate (like 1/10 + 2/10), or you’re doing anything with currency (for example, representing $10.33 in the system), then use a BigDecimal, which can support an arbitrary amount of precision and handle situations like that elegantly. [Source]

Int

An Integer is composed of 32 bits…

Long

A long is composed of 64 bits….

Short

A short is composed of 16 bits…

Variables

Variables store data values to be used later in the Java program. Variables store values that can be numerical, alphabetical, or an action. Note that Variables are called “variables” because their values can be changed

For example in the code below, the variable radius is initially 1.0. But then is reassigned the value 2.0. You can see a similar reassignment of value for the variable area too.

public class A {
    public static void main(String[] args) {

        // Compute the first area
        double radius = 1.0;
        double area = radius * radius * 3.14;
        System.out.println("The area is " + area + " for radius " + radius);

        //Compute the second area
        radius = 2.0;
        area = radius * radius * 3.14;
        System.out.println("The area is" + area + " for radius " + radius);
    }
}

The output shows the change of variable value:

Variables are for representing data of a certain type. So to use a variable, you need to declare it by telling the compiler its name as well as what type of data it can store. The variable declaration tells the compiler to allocate the appropriate memory space for the variable based on its data type. The syntax for declaring a variable is:

datatype variableName;

Examples:

int count;          //Declare count to be an integer variable
double radius;      //Declare radius to be a double variable
double interestRate;//Declare interestRate to be a double variable

If variables exist of the same type, they can be declared together like this:

datatype variable1, variable2, ..., variablen;

Notice that the variables are separated by commas. For example:

int i, j, k; //Declare i, j , and k as int variables

Variables usually have initial values. You can declare a variable and initialize it in one step. For example:

int count = 1;

This is equivalent to the next two statements:

int count = 1;
count = 1;

Another option you have is at the same time to declare and initialize variables together of the same type on the same line:

int i = 1, j = 2

Assignment & Initialization

Assignment is to throw away an old value of a variable and replace it with a new one.

Initialization is a special kind of assignment. Initialization is the very first assignment for an object. Before initialization objects have null value and primitive types have default values such as 0 or false. Can be done in conjunction with declaration.

Declaration

A declaration states the type of a variable, along with its name. A variable can be declared only once. It is used by the compiler to help programmers avoid mistakes such as assigning string values to integer variables. Before reading or assigning a variable, that variable must have been declared. [Source]

Expression

An expression represents a computation involving values, variables, and operators that, when taking them together, evaluates to a value. And…

A mathematical expression always returns something, but a Java expression doesn’t have to. Another difference is that expressions can, and often do, have side effects in Java. A side effect is pretty much anything that happens other than returning a value. [Source]

Node Vs Element

Concerning the the List Abstract Data Type in Java, the difference between nodes and elements is that an element is the data which is stored in the node. Another feature of the node is that it has a link to the next node. The link itself is not data. Rather, an address is stored as a link, much like a url or web address points to a website from a text link.