Java Inner Classes Step 1 Page 2/12

Java Inner Classes Step 1: Class Declarations

1.1 Non-Generic
David I. Schwartz modifiers class classname extends-clause implements-clause {

fields
COMS/ENGRD 211 enums
initializers
constructors
methods
classes
interfaces
}

Members:

• fields
• methods
• enums
• classes
• interfaces

Note that members can be static.

1.2 New Concepts

What you need to know:

• Inner classes: classes that you can write inside another class. Common
applications include iterators and GUIs.
• Enums: define named constants (e.g., a type called Color that has values BLUE,
RED, …). We will save enums for another document.

What you don’t really need to know:

• Inner interfaces: Yes, you can really write an interface inside a class. The rules get
complex. Save for a really, really rainy day.
• Initializers: We tend not to cover them, but they’re actually rather useful and help
to hint at anonymous classes. Imagine using a method body without a header. Why
bother? You might wish to set data when creating an object for the first time.
Rather than calling a method, you can use a statement block to set the data.

Page 1
Java Inner Classes Step 1 Page 3/12 Java Inner Classes Step 2 Page 4/12

Initializer example: Step 2: Levels of Classes

public class Initializers {
public static void main(String[] args) {
new Test().print1(); // output: 0123456789 2.1 Top-Level (or Outer) Class
new Test().print2(); // output: 01234
} • You can put a class inside an another class.
} • A class that contains other classes is a TLC.
• The classes you have seen up until now are TLCs.
class Test {
public final int N=10;
private int[] x=new int[N];
2.2 Nested Class
{ for (int i=0; i<N; i++) x[i]=i; }
public static final int L=5; Nested class:
private static int[] y=new int[L];;
static { for (int i=0; i<L; i++) y[i]=i; } • Class declared inside another class.

public void print1() { Two kinds of nested classes:

for (int i=0; i< x.length; i++)
System.out.print(x[i]); • Member class: class declared at the member-level of a TLC.
System.out.println(); • Local class: class declared inside a method, constructor, or initializer block.
}
2.3 Inner Class
public void print2() {
for (int i=0; i< y.length; i++) Inner class (IC) refers to two special kinds of nested class:
System.out.print(y[i]);
System.out.println(); • Non-static member class (member class with no static modifier).
} • Local class inside a non-static member of a TLC.
} Why called inner class?
1.3 Generic Classes and Interfaces • Because an object made from the class will contain a reference to the TLC.
• Use TLC.this.member from inside inner class to access member of TLC.
You can write a class or interface that serves as a template to make other classes.
Restrictions:
Generic class syntax:
• Inner class fields can be static, but then must also be final.
modifiers class classname<Type1, …, TypeN> baseclause {
• No static methods or other inner classes (same for other members?)
classbody
} • See language references for even more details.

We will not deal with generic classes at this point. Handy way to think of inner classes inside a TLC:

• At the member level:

- just like a variable or method.
- called member class.
• At the statement level:
- just like a statement in a method
- called local class
• At the expression level:
- just like an expression
- called anonymous class
Java Inner Classes Step 3 Page 5/12 Java Inner Classes Step 3 Page 6/12

Step 3: Member Class (Member Level) Internal references with this:

• Inside inner class, the this refers to current instance of the inner class.
• To get to current instance of TLC, save the TLC’s this as field in the TLC or
3.1 Rules simply use TLC.this.
Structure: Some inheritance:
public class OuterClass {
tlc_members
• Be careful to distinguish between class and containment hierarchies!
• Inner classes do inherit.
public class InnerClass { • Can use TLC.super.member to access TLC’s member.
mc_members
} 3.2 Example
} public class MemberClass {
public static void main(String[] args) {
When to use?
// one way:
• The inner class generates objects used specifically by TLC. OC a = new OC();
• The inner class is associated with, or “connected to,” the TLC. OC.IC b = a.new IC();
b.print(); // outputs 3
Example:
// another way:
class List { new OC().new IC().print(); // outputs 3

class Node { }
} }

} class OC {

How does visibility work? private int x = 1;

• The inner class can be public, private, protected, or package. public class IC {
• Instances of the inner class type have access to all members of the outer class private int y = 2;
(including private and static members). public void print() {System.out.println(x+y);}
}
Some restrictions:
}
• Cannot have same name as TLC or package (not that you would want to!).
• Cannot contain static members; can have static final fields (constants). 3.3 Example

How do you use a member class? public class MemberClass2 {

public static void main(String[] args) {
• Every member class is associated with instance of TLC.
new OC().new IC().print();
• Valid:
OuterClass oref = new OuterClass();
}
OuterClass.InnerClass iref = oref.new InnerClass()
}
iref.doSomething();
new OuterClass().new InnerClass();
• Not valid:
InnerClass iref = new InnerClass();
iref.doSomething();
Java Inner Classes Step 3 Page 7/12 Java Inner Classes Step 3 Page 8/12

class OC { 3.5 Example

private int x = 1; public class Memberclass4 {
private int y = 2;
public static void main(String[] args) {
public class IC {
private int x = 3; new OC2().new IC().print(); // output: 2
private int y = 4;
}
public void print() {
}
// 3 + 1 -> 4
System.out.println(this.x+OC.this.x); class OC {
// 4 + 4 -> 8
System.out.println(y+this.y); public class IC {

} // method print private int x = 2;

} // class IC public void print() { System.out.println(x); }

} // class OC }

3.4 Example }

public class Memberclass3 { class OC2 extends OC { }

public static void main(String[] args) {
new OC().new IC().print(); // Output: IC, OC

}
}

class OC {

public class IC {
public String toString() { return "IC"; }
public void print() {
System.out.println(this);
System.out.println(OC.this);
}
}

public String toString() { return "OC"; }

}
Java Inner Classes Step 4 Page 9/12 Java Inner Classes Step 4 Page 10/12

Step 4: Local Classes (Statement Level) 4.2 Example

public class LocalClass {
public static void main(String[] args) {
4.1 Rules new OC().print();
}
Local class location: }

• Statement level declaration. class OC {

• Usually written in methods. See also constructors and initializers.
public void print() {
Scope:
final String s = "test: ";
• Local to block.
• Can access all members of the TLC. class Point {
• Actually, things can get confusing here! private int x;
private int y;
- An object of local class might persist after method ends.
public Point(int x,int y) { this.x=x; this.y=y; }
- Java does have rules for dealing with the matter. public String toString() { return s+"("+x+","+y+")"; }
};
Example structure:
System.out.println(new Point(1,2));
public class TLC {
tlc_members
} // method print
methodheader {
} // class OC
statements

public class InnerClass {

ic_members
}

statements
}

moreTLCmethods

More restrictions:

• Cannot be used outside of block.

• No modifiers.
• Enclosing block’s variables must be final for local class to access.
• No static, but can have static final (constants).
• Terminate with a semicolon! The class is effectively an expression statement.
• Cannot have same name of TLC.
Java Inner Classes Step 5 Page 11/12 Java Inner Classes Step 5 Page 12/12

Step 5: Anonymous Class 5.3 Example

In example below, we print a Point again. But, we cannot say new Point, because we
5.1 Rules have not defined a Point class. Instead, I use a placeholder, class Object. You will often
find yourself using interface names instead.
Location and structure:
public class AnonymousClass {
public static void main(String[] args) {
• Defined and created at expression level.
• So, has no name and no modifiers. new OC().print();
• Syntax:
}
new classname ( argumentlist ) { classbody } }
new interfacename ( argumentlist ) { classbody }
class OC {
Adapter class:
public void print() {
• Adapter class defines code that another object invokes.
• Common in GUIs and iterators. final String s = "test: ";

Some restrictions: System.out.println(new Object() {

private int x=1;
• No modifiers. private int y=2;
• No static, but can have static final (constants). public String toString() { return s+"("+x+","+y+")"; }
• No constructors, but can use initializers for same purpose! (See Section 1.2.) } );

When to use? }

• Class has very short body. }

• Only one instance of class needed.
• Class used right after defined; no need to create new class.

5.2 Example
How to create an array “on the spot” with values? Use initializer list:
int[] = { 1 , 2 , 3 } ;

Can you return an initializer list?

int[] doStuff() {
return { 1 , 2 , 3 } ;
}

Looks good, but it won’t work! To “return an array of data” (a reference to a newly created
array with assigned values), use an anonymous array, which is effectively an anonymous
class!
return new int[] { 1 , 2 , 3 };

The pattern is identical: new classname { stuff } ;. Note also that the anonymous
array is the expression of the return statement and is thus expression-level!