Unit 081 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 082 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 083 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 084 Class with an Inner Class

Unit 085 Class with an Inner Class

Unit 086 Class with an Inner Class

Unit 087 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 088 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 this To access the outer class object use OuterClassName.this

Unit 089 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 0810 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 0811 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 0812 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 0813 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 0814 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 0815 Local Classes: Example class 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 0816 Local Classes: Example 2 interface 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 0817 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 0818 Anonymous Classes: Example interface 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 final System.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 0819 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(); }