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 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();
}}
Top Related