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< [Link]; i++)
[Link](x[i]); • Member class: class declared at the member-level of a TLC.
[Link](); • Local class: class declared inside a method, constructor, or initializer block.
}
2.3 Inner Class
public void print2() {
for (int i=0; i< [Link]; i++) Inner class (IC) refers to two special kinds of nested class:
[Link](y[i]);
[Link](); • 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 [Link] 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 [Link].
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 [Link] 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. [Link] b = [Link] IC();
[Link](); // 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() {[Link](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();
}
[Link] iref = [Link] InnerClass()
}
[Link]();
new OuterClass().new InnerClass();
• Not valid:
InnerClass iref = new InnerClass();
[Link]();
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
[Link](this.x+[Link].x); class OC {
// 4 + 4 -> 8
[Link](y+this.y); public class IC {
} // method print private int x = 2;
} // class IC public void print() { [Link](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() {
[Link](this);
[Link]([Link]);
}
}
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:
[Link](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: [Link](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!