int[] arr1 = {1, 2, 3, 4};
	int[] arr2 = {1};
	System.out.println(Arrays.deepToString(arr2)); 	// [1]
	arr2 = arr1;
	System.out.println(Arrays.deepToString(arr2));  // [1, 2, 3, 4]

	Object[][] arr3 = {{1, 2, 3}, {4, 5, 6}};
	String[][] arr4 = {{"a"}, {"b"}};
	System.out.println(Arrays.deepToString(arr3));	// [[1, 2, 3], [4, 5, 6]]
	arr3 = arr4;
	System.out.println(Arrays.deepToString(arr3));	// [[a], [b]]

• In the example above, arr2 has a single value, and arr1 has 4 values; However, you can point arr2 to arr1's values, because they both have the same number of dimensions (1) and the same type (int).
• The same goes for arr3 and arr4 - they both have two dimensions, and they both contain compatible types - an Object or subtype thereof. Remember, String inherits from Object, so they're type compatible.

When determining what types an array variable can point at, use the 'instanceof' test. If the array were a single variable of type 'Car', it could contain an instance of type 'DragRacer', which is a type of car. Therefore, an array of Car can point to an array of DragRacer, since DragRacer is an instanceof car. However, the reverse is not true! Car fails the instanceof test, since it's not a type of DragRacer, therefore an array variable of DragRacer could not point to an array of Car.

class Car {}
class DragRacer extends Car {
	public static void main(String args[]) {
		Car[] cars = new Car[5];
		DragRacer[] racers = new DragRacer[5];
		racers = cars; // Type mismatch: cannot convert from Car[] to DragRacer[]
		cars = racers; // This one works.
		}
	}
}

Here's an example of three different ways of declaring a three dimensional array. All are valid, and all result in the same output.

• In the first example, only the first dimension is specified. Therefore, it is necessary to declare and construct array variables for the other dimensions.
• In the second example, the first two dimensions are specified, but the third is not. Therefore, it is necessary to declare and construct array variables for the third dimension.
• In the third example, all dimensions are specified. Therefore, it is not necessary to declare or construct arrays for any other dimension.

/* 
 Output for ArrayTest1, ArrayTest2, and ArrayTest3 is:
 
[[[ 0,  1,  2,  3], [ 4,  5,  6,  7], [ 8,  9, 10, 11]], 
 [[12, 13, 14, 15], [16, 17, 18, 19], [20, 21, 22, 23]]]
 
 The number of rows is 2, the first dimension.
 The number of groups in each row is 3, the second dimension.
 The number of entries in each group is 4, the third dimension. 
 
 */

public class ArrayTest {
	public static void main(String args[]) {
		ArrayTest1();
		ArrayTest2();
		ArrayTest3();
	}
	public static void ArrayTest1() {
		int dim1 = 2;
		int dim2 = 3;
		int dim3 = 4;
		int ctr = 0;
		int[][][] arr = new int[dim1][][];
		for (int i = 0; i < dim1; i++) {
			arr[i] = new int[dim2][];
			for (int j = 0; j < dim2; j++) {
				arr[i][j] = new int[dim3];
				for (int k = 0; k < dim3; k++)
					arr[i][j][k] = (int) (ctr++);
			}
		}
		System.out.println(java.util.Arrays.deepToString(arr));
	}
	
	public static void ArrayTest2() {
		int dim1 = 2;
		int dim2 = 3;
		int dim3 = 4;
		int ctr = 0;
		int[][][] arr = new int[dim1][dim2][];
		for (int i = 0; i < dim1; i++) {
			// The following line is no longer necessary because dim2
			// was specified when declaring the array variable.
			// arr[i] = new int[dim2][];
			for (int j = 0; j < dim2; j++) {
				arr[i][j] = new int[dim3];
				for (int k = 0; k < dim3; k++)
					arr[i][j][k] = (int) (ctr++);
			}
		}
		System.out.println(java.util.Arrays.deepToString(arr));
	}
	
	public static void ArrayTest3() {
		int dim1 = 2;
		int dim2 = 3;
		int dim3 = 4;
		int ctr = 0;
		int[][][] arr = new int[dim1][dim2][dim3];
		for (int i = 0; i < dim1; i++) {
			// The following line is no longer necessary because dim2
			// was specified when declaring the array variable.
			// arr[i] = new int[dim2][];
			for (int j = 0; j < dim2; j++) {
				// The following line is no longer necessary because dim3
				// was specified when declaring the array variable.
				// arr[i][j] = new int[dim3];
				for (int k = 0; k < dim3; k++)
					arr[i][j][k] = (int) (ctr++);
			}
		}
		System.out.println(java.util.Arrays.deepToString(arr));
	}
	
	
}

Static and instance initializers can appear between methods of a class, or at the end - they don't have to come at the top, though that is the usual place for them. There can be more than one static and instance initializer, and if there are multiple initializers, they run in the order they appear in the source file.

Take a look at the following:

class A {
	static { System.out.println("A static initializer 1"); }
	{ System.out.println("    A instance initializer 1"); }
	static { System.out.println("A static initializer 2"); }		
	{ System.out.println("    A instance initializer 2"); }
	public A() { System.out.println("        A constructor."); }
}

class B extends A {
	static { System.out.println("B static initializer"); }
	{ System.out.println("    B instance initializer"); }
	public B() { System.out.println("        B constructor."); }
}

class C extends B {
	static { System.out.println("C static initializer"); }
	{ System.out.println("    C instance initializer"); }
	public C() { System.out.println("        C constructor."); }
}

class D {
	static { System.out.println("D static initializer"); }
	{ System.out.println("    D instance initializer"); }
	public D() { System.out.println("        D constructor."); }
}

public class InitializerTesting {
	public static void main(String[] args) {
		
		System.out.println("\nCreating C\n");
		C c = new C();

		System.out.println("\nCreating A\n");
		A a = new A();
		
		System.out.println("\nCreating B\n");
		B b = new B();
		
		System.out.println("\nCreating D\n");
		D d = new D();
		
	}
}

/*

The output is:

Creating C

A static initializer 1
A static initializer 2
B static initializer
C static initializer
    A instance initializer 1
    A instance initializer 2
        A constructor.
    B instance initializer
        B constructor.
    C instance initializer
        C constructor.

Creating A

    A instance initializer 1
    A instance initializer 2
        A constructor.

Creating B

    A instance initializer 1
    A instance initializer 2
        A constructor.
    B instance initializer
        B constructor.

Creating D

D static initializer
    D instance initializer
        D constructor.

*/

When creating object A, all the static initializers for this hierarchy have run already, and they only run once, so those are skipped. So, it runs class A's instance initializer(s), then class A's constructor.

When creating object B, we skip the static initializers because they already ran, and run the instance initializers + constructors for every class down the chain. Thus, class A's instance initializers, class A's constructor, class B's instance initializer's, then class B's constructor.

Finally, we create the last object, D. D is a class that stands alone - it doesn't extend anything but Object. Since we haven't created any instances of D yet, its static initializer hasn't run. Therefore, when we create D, first the static initializer runs, then the instance initializer, then the constructor.

    Integer i = 2;

the 2 is autoboxed into an Integer, and assigned to the variable i. If later you say:

    i = 3;

the 3 is autoboxed into an Integer, and assigned to the variable i. The wrapper with a value of 2 that the variable used to point to, is now discarded, and is eligible for garbage collection. As you can imagine, using wrappers can cause programs to suffer a performance hit. Incrementing an Integer from 1 to 1,000 causes 1000 Integer wrappers to be created, then discarded!

One final thought - it can be difficult to remember which of the static wrapper methods below return a wrapper, versus return a primitive or String. Remember this handy tip: Out of all the static methods you see down there, only the 'valueOf' methods return a wrapper object - all the rest return primitives or strings. See the big 'O' in valueOf? That's a handy mnemonic to remember it returns an object.

• Widening - If an int has an option of entering a method that requires a long or a method that requires an Integer, the long method will win.
• Autoboxing - If an int has an option of entering a method that requires an Integer or a method that requires a var-args int..., the Integer method will win.
• Var-args - A var-args option will always be picked last, only if no other option will work.

You can't expect it to first widen then autobox a variable to call a method - that will result in a compile time error. As an example, calling a function that requires a Long, with a byte argument, will fail.

You CAN autobox then widen, however. Here's an example: If a method requires a Number, you can pass it a byte. The byte will be autoboxed to a Byte, which is an instanceof Number, so the call will succeed.

You can also widen, then call a var-args function - ie, passing several integer, short, and byte values into a function that requires a var-args long (long... args)