Inner Classes

An inner class provides a shorthand for creating small classes whose meaning is clearer if kept in the immediate context.

A static inner class is just a class that lives inside another class. For exmaple:

Destroyer.java
1	public class Destroyer {
2	public static class Turret{
3	final String name;
4	Direction dir;
5	public Turret(String n) { name = n; }
6	public String toString() { return name; }
7	}
8
9	Turret fore, aft;
10	public Destroyer() {
11	fore = new Turret("Fore");
12	aft = new Turret("Aft");
13	}
14
15	public static void main(String[] args) {
16	Destroyer b = new Destroyer();
17	System.out.println("fore="+b.fore+" aft="+b.aft);
18	}
19	}
$ javac Destroyer.java
$ java Destroyer fore=Fore aft=Aft

Sometimes you want the inner class to know about the class it is inside of.

Bank.java
1	public class Bank {
2	int balance;
3	public class TellerMachine {
4	double deposit;
5	public void makeDeposit(int a) {
6	// the TellerMachine makes use of the outer class field "balance"
7	balance += a;
8	deposit += a;
9	}
10	public String toString() {
11	// the TellerMachine makes use of the outer class field "balance"
12	return "total="+balance+" this TellerMachine="+deposit;
13	}
14	}
15	// construct in the normal way
16	TellerMachine a1 = new TellerMachine();
17	TellerMachine a2 = new TellerMachine();
18
19	public static void main(String[] args) {
20	Bank acc = new Bank();
21	acc.a1.makeDeposit(1);
22	acc.a2.makeDeposit(2);
23
24	// special constructor for inner classes
25	TellerMachine a3 = acc.new TellerMachine();
26	a3.makeDeposit(3);
27	System.out.println("TellerMachine 1="+acc.a1);
28	System.out.println("TellerMachine 2="+acc.a2);
29	System.out.println("TellerMachine 3="+a3);
30	}
31	}
$ javac Bank.java
$ java Bank TellerMachine 1=total=6 this TellerMachine=1.0 TellerMachine 2=total=6 this TellerMachine=2.0 TellerMachine 3=total=6 this TellerMachine=3.0

Java defines an interface called Runnable, which has a single public method called "void run()". We can create a number of anonymous inner classes that implement it.

Anon.java
1	public class Anon {
2	public static void main(String[] args) {
3	// Creates an anonymous inner class. Note
4	// the () is a call to a constructor.
5	Runnable taskA = new Runnable() {
6	public void run() {
7	System.out.println("task A");
8	}
9	};
10	Runnable taskB = new Runnable() {
11	// instance initializer, similar to a constructor
12	{ letter = 'B'; }
13	char letter;
14	public void run() {
15	System.out.println("task "+letter);
16	}
17	};
18	Runnable taskC = new Runnable() {
19	public void run() {
20	System.out.println("task C");
21	}
22	};
23	Runnable[] toDoList = new Runnable[]{taskA,taskB,taskC};
24	for(Runnable whatsNext : toDoList) {
25	whatsNext.run();
26	}
27	}
28	}
$ javac Anon.java
$ java Anon task A task B task C

In the above code, we implement the Runnable interface three times, but in no case do we give the class a name. It is, therefore, anonymous.