Variables

Java is a statically-typed language which means that ALL variables must be DECLARED (given a type and a name) before they can be USED.

While variables exist in all programming languages, they take on different meanings and names in an object-oriented programming language like Java:

• Instance Variables (Non-Static Fields) — are variables (properties) of an object instance that are used to STORE the object STATES. Remember, non-static fields are those without the static keyword. They are called instance variables because their values are unique to EACH instance of a class (that is, an object). For example, the instance variable (e.g., int currentWidth = 100) of one object is INDEPENDENT from another object created from the same class even though they may have the same value. They are sometimes called member variables.
• Class Variables (Static Fields) — are variables that are declared with the static keyword modifier (e.g., static int numberOfWheels) which informs the compiler that there is EXACTLY ONE COPY of this variable that is STORED AND SHARED across all objects created from the same class regardless of the number of objects instantiated. For example, the number of wheels on a Car object (4) is the same regardless of the number of instances of the Car object that is created.  The final keyword can also be added to indicate that the value will never change (e.g., The number of wheels on a car is ALWAYS FOUR). Remember, you access a class variable from the class name (e.g., myClass.myPropertyName) and NOT its instance name (e.g., myObject.myPropertyName).
• Local Variables — are variables that are “local” to a method (a function of a class). The word local implies that the variables are WITHIN the opening and closing curly braces of a method code block. There is no keyword used to identify a local variable. You know it is local if it is INSIDE of a method code block. Local variables are only VISIBILE within the method in which it is declared and are not accessible from other parts of the class.  Like objects which store its states in fields, methods will store its TEMPORARY states in local variables.
• Parameters — like functions, constructors, and handlers that accept parameters, parameters are values that are passed to a method between the opening and closing parenthesis. For example, args in the parameter that is used for the main method: static void main(String[] args). It is important to remember: Parameters OF a method becomes variables IN a method. They should never be called fields.

Naming Conventions

Like variables that exist in all programming languages, so do naming conventions for variables, etc. All variables (e.g., fields, local or parameters) follow the same naming conventions:

• While you can use any legal identifier (e.g., letters, $, _) you want to begin a variable, in Java and many other OOP languages, by convention, it is best to start a variable name with a letter and all subsequent characters may be anything else. Also, you should never use white spaces between characters.
• It is best to use descriptive full word names (e.g., height, width, and color) and not cryptic abbreviations (e.g., h, w, and c) so that code is easier to understand and will make the code self-documenting. However, names cannot be a keyword or reserved word that is used by Java. For example, you cannot use the word “class” as a variable name because it is a reserved word.
• One word variables (e.g., height) should always be in lowercase; whereas, variables that use multiple words variable should use camelCase (e.g., getTotalScore) where the first letter of each word is capitalized except for the first letter.
• If the variable is a constant, it is common practice to capitalize every letter and add underscore between each word if it is a multiple word constant (e.g., NUMBER_OF_WHEELS). By convention, the underscore is not used elsewhere.

Primitive Data Types

Data types are as the name implies “types of data” used by the language.

There are eight primitive data types (byte, short, int, long, float, double, boolean, and char). The ones that you will use the most are int, float, double and boolean.

For a complete listing of the various data types, their definitions and examples go to:

https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

The String class is not a primitive data type but an object; however, it is treated as such. For example, enclosing a character string within double quotes will automatically create a new String object (e.g., String firstName = “Cornelius”). String objects are immutable which means that once created their values cannot be changed.

Default Values

If a field is declared (given a type and a name) but not assigned, the compiler will give it a default value which typically is zero for numeric types and null for a String or an object and false for a boolean.

Data Type	Default Value (for fields)
byte, short, int	0
float	0.0f
double	0.0d
char	‘\u0000’
String, object	null
boolean	false

TIP: However, it is best practice to assign a data type.

However, for local variables in a method, default values are never assigned by the compiler. If a local variable is not initialized when it is declared, it needs to be assigned a value before it can be used otherwise the compiler will throw an error.

Casting into another type

There are times when you need to cast a variable into anohter data type. Below is a common example that you may see:

TextView myText = (TextView)

Reference Data Types

Reference data types are used with strings, arrays and objects.

Array — is a container for an “array” of values of the same type. The array length is determined when the array is created. After it is created, its length becomes fixed.

Declaring a Variable to Refer to an Array

Unlike most programming languages where square brackets denotes an array and are placed AFTER the array name (e.g., var myArray[ ]; in JavaScript), in Java it is common convention to place them BEFORE the array name but AFTER the data type where the data type (int, in this case) specifies what type of data the array will hold:

int[ ] myIntegerArray;
String[ ] myStringArray;

In the example above, the array is empty denoted by the empty brackets. However, the declaration does not actually create an array but simply tells the compiler that this variable will hold an array of a specify type.

While it is discouraged in Java, if you place the brackets after the array's name it will still work:

int myIntegerArray[ ];
String myStringArray[ ];

Creating and Populating An Array

It is best practice to create and populate an array at the same time.  However, unlike other languages, Java uses curly braces instead of square brackets to populate an array in this manner:

Int[] myArray = {10,20,30,40};

The length of the array is determined by the number of elements in the array (in this case, 4).

Multidimensional Array

You can also insert multiple arrays inside of a single array which is called a multidimensional array by using two sets of square brackets where each element has to be accessed by using two index values. While not recommended, you can also have different number of elements in each array.

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

String[][] names = {
{"Cornelius", "Joshua ", "Josiah"},
{"Chopin", "Washington"}	
};

System.out.println(names[0][0] + names[1][0]);	      
System.out.println(names[0][2] + names[1][1]);
	    
}
}

The outputs are Cornelius Chopin and Josiah Washington.

Copying Arrays

You can use the System’s arraycopy() method to copy data from one array into another array using the following syntax where the two Object arguments specify the array to copy FROM and copy TO. The three int arguments specify the starting source and destination starting positions and the number of elements to copy:

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

The following example copies a portion of the first array into the second array:    

class ArrayCopyDemo {

public static void  main(String[] args) {
char[] copyFrom = { 'H', 'e', 'l',  'l', 'o', 'W', 'o','r', 'l', 'd'};
char[] copyTo  = new char[5];
	       
System.arraycopy(copyFrom, 5, copyTo, 0, 4);
System.out.println(new String(copyTo));
}

}

The output is World.

Array Manipulations

Like most programming languages, arrays has a list of methods used to manipulate (e.g., copy, sort, search) an array in the java.util.Arrays class.

However, there a few that are unique to Java:

• binarySearch()—used to search an array for a specific value.
• equals()—used to compare two arrays to determine if they are equal or not.
• fill()—used to fill an array with specific values at each index.
• parallelSort()—used to parallel sort an array. This method is faster than the regular sort method for large arrays on multiprocessor systems. (Introduced in Java SE 8)

Determining which array type to use: (e.g., Array, ArrayList, HashMap):

• an array list is used to manage an ordered set of data. (e.g. List<String> list = new ArrayList<>(); and then use list.add("Louisiana") and list.remove(0) and list.get(1); and list.indexOf("Louisiana");.
  
• a hash map is used to represent an unordered data collection. Just as with an array list, which implements the list interface, a hash map is an implementation of an interface named Map. A map will have key/value pairs. (e.g., Map<String, String> map = HashMap<>(); then use map.put("Louisian", "Baton Rouge") and map.get("Louisiana");.

instanceof Operator

The instanceof operator is used to test if an object in “an instance of” a class, an instance, a subclass or an instance of a class that implements an interface.

See https://docs.oracle.com/javase/tutorial/java/nutsandbolts/op2.html for example.