Java Fundamentals Tutorial: Data Types

In contrast to a language like C, in Java the local variables do not have to be declared at the beginning of program blocks (defined by curly braces). They can be declared when they need to be used.

public static void main(String[] args) {
    System.out.print("Number of arguments: ");
    int len = args.length;
    System.out.println(len);
}

Multiple variables can be declared on a singe line: int i, j, k;

Multiple variables can be initialized at the same time: i = j = k = 5;

There is an generally accepted naming convention in the Java community to start variable names with a lower-case letter and use a so-called CamelCase (or CamelHump) notation, where the first letter of each subsequent word is capitalized, but the words are joined together (i.e. no dashes or underscores).

^* The default value for uninitialized class or instance variables of this type.

Even though Java is a fully object oriented language, for performance reasons it defines eight primitive data types. All of these types also have their respective wrapper classes (for true OO) in the default java.lang package (which we will see later).

In addition to the eight primitive types, there is also a concept of a void type, which is only used for a method return type (i.e. to indicate that nothing is returned).

Examples: 

boolean bln = true; // booleans can only be 'true' or 'false'
byte b = 0x20;      // using hexadecimal notation
short s = 500;      // small integer
char c = 'A';       // must use single quotes to denote characters
char tab = '\t';    // other specials: \n, \r, \f, \b, \\, \', \"
int i = 1000000;    // decimal notation
int j = 0x3FA0B3;   // hexadecimal notation
int k = 0777;       // octal notation
float f = 1.5f;     // trailing 'f' distinguishes from double
long l = 2000000L;  // trailing 'L' distinguishes from int
double pi = 3.141592653589793;  // doubles are higher precision
double large = 1.3e100;     // using the exponent notation

Figure 3. Implicit up-casting of primitive types

	Note
	Java has a clear separation between numerical types and booleans. They are not interchangeable. This means that an int cannot be used in place of a boolean expression, for example in an if statement:

int someInteger = 0;

/*
 * This will not compile, because someInteger is not
 * a boolean type (or a boolean expression)
 */

if (someInteger) {
    // Do something
}

// This will compile
if (someInteger != 0) {
    // Do something
}

	Note
	Strings are not converted automatically into integers or other primitive data types they may represent. Strings must be parsed:

int myInt = Integer.parseInt(args[0]);

Examples of array declarations:

String[] args;      // single-dimensional array of String objects
int[] numbers;      // single-dimensional array of ints
byte[] buffer;      // single-dimensional array of bytes
short[][] shorts;   // double-dimensional array of shorts

To get the array length:

int arrayLength = myNums.length;    // 5
int nameLength = name.length;       // 3
int bufLength = buf[2].length;      // 1024

Examples of array initializations:

int[] myNums = { 1, 3, 5, 7, 9 };   // 5 elements
char[] name = new char[3];
name[0] = 'T';
name[1] = 'o';
name[2] = 'm';
short[][] matrix = { {1,4,7}, {5,6,3}, {2,8,9} };
byte[][] bufs = new byte[10][1024];

To access an element of an array:

int myNum = myNums[3];      // 7
char firstLetter = name[0]; // 'T'
matrix[1][2] = 0;       // used to be 3

In the example above, the values and newValues variables do not actually contain the arrays, they refer to the array objects. We’ll examine this concept more in the Object Oriented module.

To get the length of a String do:

String s = "my string";
int len = s.length();

To parse a primitive value from a String, do:

boolean b = Boolean.valueOf(s).booleanValue();
byte b = Byte.parseByte(s);
short s = Short.parseShort(s);
char c = s.charAt(0);
int i = Integer.parseInt(s);
float f = Float.parseFloat(s);
long l = Long.parseLong(s);
double d = Double.parseDouble(s);

We will examine the String API later in class.