Unit 08 1

Introduction to Nested Classes

• Nested classes are classes defined within other classes

• The class that includes the nested class is called the outer class

• There are four categories of nested classes in Java:

1. Inner classes, also called Non-Static Nested Classes

2. Static nested classes

3. Local classes (defined inside a block of Java code)

4. Anonymous classes (defined inside a block of Java code)

Unit 08 2

Simple Uses of Inner Classes

• An inner class definition is a member of the outer class in the same way that the instance variables and methods of the outer class are members– An inner class is local to the outer class definition

– If the inner class is private, then the inner class cannot be accessed by name outside the definition of the outer class

• Using an inner class as a helping class is one of the most useful applications of inner classes

Unit 08 3

Accessing Private Members

• Within the definition of a method of an inner class:– It is legal to reference a private instance variable of the

outer class– It is legal to invoke a private method of the outer class

• Within the definition of a method of the outer class– It is legal to reference a private instance variable of the

inner class on an object of the inner class– It is legal to invoke a method of the inner class on an object

of the inner class

Unit 08 4

Class with an Inner Class

Unit 08 5

Class with an Inner Class

Unit 08 6

Class with an Inner Class

Unit 08 7

The .class File for an Inner Class

• Compiling any class in Java produces a .class file named ClassName.class

• Compiling a class with an inner classes causes both classes to be compiled, and produces two .class files– Such as ClassName.class and ClassName$InnerClassName.class

Unit 08 8

Using this Keyword in Inner Classes

• The this reference is applicable inside inner classes.

• From within an instance of an inner class we can refer to two

objects, the inner object, and the outer object associated with it.

To access the inner class object use thisTo access the outer class object use OuterClassName.this

Unit 08 9

Keyword this in Inner Classes

1. class InnerClassesAndThis {2. String x = "ICS 201";3. class B {4. int x = 5;5. void f(int x){6. System.out.println(x);7. System.out.println(this.x);8. System.out.println(InnerClassesAndThis .this.x);9. }10. }11. public static void main(String [] s){12. InnerClassesAndThis outer = new InnerClassesAndThis ();13. B b = outer.new B();14. b.f(7);15. }16. }

Unit 08 10

Static Nested Classes

• An inner class (non-static nested class) has a connection between its objects and the outer class object that created the inner class object– This allows an inner class definition to reference

an instance variable, or invoke a method of the outer class

• There are certain situations, however, when a nested class must be static– If an object of the nested class is created within a

static method of the outer class– If the nested class must have static members

Unit 08 11

Static Nested Classes

• Since a static nested class has no connection to an object of the outer class, – Instance variables of the outer class cannot be

referenced– Non-static methods of the outer class cannot be

invoked• To invoke a static method or to use a static

variable of a static nested class within the outer class, preface each with the name of the nested class and a dot

Unit 08 12

Public Nested Classes

• If a nested class is marked public, then it can be used outside of the outer class

• In the case of a non-static nested class, it must be created using an object of the outer class

BankAccount account = new BankAccount();

BankAccount.Money amount = account.new Money("41.99");

– Note that the prefix account. must come before new– The new object amount can now invoke methods from the

inner class, but only from the inner class

Unit 08 13

Public Inner Classes

• In the case of a static nested class, the procedure is simpler

OuterClass.InnerClass innerObject =

new OuterClass.InnerClass();– Note that all of the following are acceptable

innerObject.nonstaticMethod();

innerObject.staticMethod();

OuterClass.InnerClass.staticMethod();

Unit 08 14

Local Classes

• A local class is defined within a block of Java code.

• Local classes are completely hidden in their

containing block.

• When a class name is used only within a block it can

be defined locally.

• A local class can access instance variables of the

outer class and only the final local variables of the

enclosing block.

Unit 08 15

Local Classes: Exampleclass LocalClassExample{

private String name = "KFUPM";

public void method(){ int j = 20; final int k = 30;

class Local{ public void test(){ //System.out.println(j); //Error as j is not final System.out.println(k); //OK k is final

//Like an inner class, instance variables of //the enclosing object can be accessed. System.out.println(name); }

} Local l = new Local(); l.test();

}

public static void main(String[] args){ LocalClassExample obj = new LocalClassExample(); obj.method(); }

}

Unit 08 16

Local Classes: Example 2interface Thing{ public void test();}class LocalClassExample2{ private String name = "KFUPM"; public Thing f(){

int j = 20; final int k = 30; class Local implements Thing{

public void test(){ //System.out.println(j); //Error as j is not final System.out.println(k); //OK k is final

//the enclosing object instance variables can be accessed. System.out.println(name);

} } Local l = new Local(); return l;

} public static void main(String[] args){

LocalClassExample2 obj1 = new LocalClassExample2(); Thing obj2 = obj1.f(); obj2.test();

}}

Unit 08 17

Anonymous Classes

• When a local class is used only once, it can be defined

anonymously.

• An anonymous class is a local class without a name and is

defined and instantiated in a single expression.

• An anonymous class has no constructors.

• Construction parameters can be given through the superclass

constructor.

• When an anonymous class implements an interface, it cannot

have any construction parameters. Why?

Unit 08 18

Anonymous Classes: Exampleinterface Thing{ public void test(); }

class AnonymousClassExample { private String name = "KFUPM"; public Thing f(){

int j = 20;final int k = 30;return new Thing() { // equivalent to Example 4 but using anonymous class

public void test(){//System.out.println(j); //Error as j is not finalSystem.out.println(k); //OK k is final //the enclosing object instance variables can be accessed. System.out.println(name); }

}; } public static void main(String[] args){

AnonymousClassExample obj1 = new AnonymousClassExample(); Thing obj2 = obj1.f(); obj2.test();

}}

Unit 08 19

Anonymous Classes: Example 2 interface Thing{ public void test();}class AnonymousClassExample2{

private String name = "KFUPM";private Thing method1() { Thing obj = new Thing(){ public void test(){

//instance variables of enclosing object can be accessed. System.out.println(name); }

};return obj;

}private Thing method2(){ Thing obj = new Thing(){ public void test(){

System.out.println(name+name+name); } };return obj;

}public static void main(String[] args){

AnonymousClassExample2 obj = new AnonymousClassExample2();Thing t;t = obj.method1(); t.test();t = obj.method2(); t.test();

}}