1 / 43

Nested Classes

Nested Classes. Learning Outcome List and distinguish between the different categories of nested classes List and explain four applications/benefits of nested classes Apply nested classes in applications development Introduction

josiah-evans
Download Presentation

Nested Classes

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Nested Classes • Learning Outcome • List and distinguish between the different categories of nested classes • List and explain four applications/benefits of nested classes • Apply nested classes in applications development • Introduction • We start by introducing Nested Classes (NC), highlighting categories of NC and then outline the advantages of NC as they are used in Java • We then briefly discuss and give example of each of the main categories of nested classes, namely • static Member Classes • Self-check Exercise 1 • Non-static Member Classes • Local Classes • Anonymous Classes • Self-check Exercise 2 • Review Exercises • We conclude the session with a set of review exercises Nested Classes

  2. Introduction to Nested Classes • So far, our classes and interfaces were defined at top-level • In our programs so far, we have defined classes and interfaces at the top level, which is the package level • These top-level classes and interfaces are grouped into packages • That is, … • Classes in the same package are accessible to each other • We have also learnt that … • With access modifiers, classes can have inter-package access • Furthermore, we can use access modifiers to make classes access other classes in different packages • Newer versions of Java enable defining classes and interfaces inside other classes • Starting from Java 1.1, classes and interfaces can be nested inside other classes to get additional benefits • Classes and interfaces defined inside other classes are called nested classes or nested interfaces Nested Classes

  3. Introduction to Nested Classes (cont’d) • There are four categories of nested classes in Java (which are): • 1- static member classes and interfaces • 2- Member classes • 3- Local classes • 4- Anonymous classes • Static member classes and interfaces are defined with the static keyword • Static member classes and interfaces are nested classes and interfaces defined with the static keyword • Member, local and anonymous classes are non-static, collectively called inner classes • Member classes are defined inside a class while local and anonymous classes are defined inside a block of Java code • Local classes are typically defined inside methods. • We refer to both static and non-static classes as nested classes • We use the term nested classes to refer to both static and non-static classes • Some authors refer to static member classes as top-level, nested classes (an oxymoron!) Inner classes Nested Classes

  4. Nested Classes at a Glance 1 class OuterClass{ 2 static class StaticMemberClass { 3 // ... 4 } 5 static interface StaticMemberInterface{ 6 void f(); 7 } 8 class MemberClass { 9 // ... 10 } 11 public void myMethod(){ 12 class LocalClass { 13 // ... 14 } 15 } 16 public StaticMemberInterface myMethod2(){ 17 return new StaticMemberInterface(){ 18 public void f(){} 19 }; 20 } 21 } Nested Classes

  5. Nested Classes at a Glance: Transcript • A static member class defined with the static keyword • An interface is always a static member • A member class inside another class. Note that it is not static • A local class defined inside the method myMethod() • A method that returns an object of a class that implements StaticMemberInterface • The above line may be read: return an instance of a class that implements … interface. • The class has no name but its definition follows after closing parenthesis after the interface name • Notice the semi-colon after the closing brace that completes the class’s definition Nested Classes

  6. Why Nested Classes? • Why does Java introduce nested classes? • Now that we have defined nested classes, one may ask, why does Java introduce nested classes? • Nested classes give additional support for: • 1. Object-orientation • Separation of definition from functionality • Because nested classes provide a means of separating definition from functionality. That is, nested classes allow us to take logic out of an enclosing class and place it in a nested class (clearly an OO advantage) • For example, a data structures definition can be separate while its functionality (like methods needing to traverse the data structure) can be factored into a nested class • 2. Code organization • Nested classes are an additional means of providing namespace control and access control. • We can use nested classes to achieve more namespace control since the name of a nested class cannot conflict with the name of an another class in the same package • Furthermore, a private member class is hidden from classes in the same package. This level of access control cannot be achieved without inner classes. Nested Classes

  7. Why Nested Classes? • 3. ‘Multiple inheritance’ (on top of single class and multiple interface inheritance) • Recall that Java supports single class inheritance and multiple interface inheritance. • With inner classes, a Java class can inherit from more than one abstract/concrete class • Because a single outer class can have several inner classes and • Each inner class can independently inherit from an implementation in its own way • Therefore, interfaces and inner classes together provide a complete solution to the multiple (implementation) inheritance problem • 4. Event-driven programming • Recall that good software engineering requires us to make instance variables private • But event handling methods typically need to access variables in another class to carryout event handling properly. • To access private members of a class we can • Define two public methods for each variable (a setter and a getter) or • Define an inner class inside the class containing the private data • The use of inner classes to access private data provides a more concise and better solution Nested Classes

  8. staticMember Classes • A static member class (or interface) is defined as a static member of another class • A static member class is a class (or interface) defined with the static specifier inside another class • A member interface is implicitly static when the static keyword is omitted • static member classes are analogous to other static class members • static member classes are analogous to the class fields and methods that are also declared static inside the class • Like a class method, a static member class is a top-level entity • Like a class method, a static member class is not associated with any instance of the containing class (i.e., there is no this object) • A static member class has access to all static members of its outer class • A static member class has access to all static members of its outer class, including private static members • static members of the outer class can also access static members of the static member class • static member classes can be defined only in top-level classes • static member classes can be defined only inside top-level classes and also inside other static member classes and interfaces Nested Classes

  9. Introducing Our Working Example • Our working example involves a Course class containing students’ grades: class Course{ private double [] grades; // … } • There is an interface, MaxMin, with single method • The bestAndWorst() method computes the best and worst grades in the course interface MaxMin{ void bestAndWorst(); } • The class implementing MaxMin must have access to the grades array • The class that implements the MaxMin interface must have access to the grades array • With a nested class a neat solution is created whereby the grades array is accessed directly • To return the best and worst grades, we may define two methods • … , one for each value • This may require 2 traversals of the array since each method can return only one value • We define a class Pair that holds the best and worst grades • With this class, a single method is required to return an instance of Pair that using a single traversal of the grades array Nested Classes

  10. Example 1: static Member Classes 1 import java.util.*; 2 class Course1{ 3 private static double [] grades; 4 interface MaxMin{ void bestAndWorst();} 5 static class Pair implements MaxMin{ 6 private double best; 7 private double worst; 8 public String toString(){ 9 return "Best grade: "+best+"\nWorst grade: "+worst+"\n"; 10 } 11 public void bestAndWorst(){ 12 if(grades.length > 0){ 13 best = grades[0]; 14 worst = grades[0]; 15 for(int i=1; i<grades.length; i++){ 16 if (best < grades[i]) best = grades[i]; 17 else if (worst > grades[i]) worst = grades[i]; 18 } 19 } 20 } 21 } Nested Classes

  11. Example 1: static Member Classes (cont’d) 22 Course1(int size){ 23 grades = new double[size]; 24 for(int i=0; i<size; i++) 25 grades[i] = 100*Math.random(); 26 } 27 public MaxMin getPair(){ 28 return new Pair(); 29 } 30 } 31 public class Course1Test{ 32 public static void main(String [] args){ 33 Course1 c1 = new Course1(10); 34 Course1.MaxMin cs = new Course1.Pair(); 35 cs.bestAndWorst(); 36 System.out.println(cs); 37 } 38 } Nested Classes

  12. staticMember Classes: Transcript • This is the grades array we introduced earlier • Also this is the MaxMin interface we already introduced • This is the Pair class implementing the MaxMin interface • The class pair has two private fields to hold the best and worst grades • The Pair class overrides the inherited toString() method • The bestAndWorst() method determines the best and worst grades and store them in the two instance variables of the Pair class • It is assumed that the first element in the array is the best and the worst at the same time • These values are updated as he remaining elements in the array are inspected • A constructor of the COurse1 class that initializes the grades array with ten random values • Each value is a number between 0 and 100 • getPair() method is an instance method of the Couse1 class that returns an instance of the Pair class Nested Classes

  13. staticMember Classes: Transcript • Class Course1Test is the driver class used to test the Course1 class • The statement at line xy creates an object of type Pair • Observe this object-creation expression carefully. In particular the name of the class Pair is prefixed with the name of its outer class, Course1 • This is what we mean by saying that the name of the nested class Pair cannot conflict with the name of another class in the same package • The instance of the Pair class is now used to compute the best and worst grades • Finally the program prints the values of the best and worst grades found • MCQ • What is the significance of the line: Course1 c1 = new Course1(10); • not needed • necessary to initialize the array Nested Classes

  14. staticMember Classes: Transcript • Notice the full name of the nested classes and interfaces in the object-creation statement inside the main() method • Notice that when this program is compiled, four .class files will be generated: • Course1.class • MaxMin.class • Course1.Pair.class • Course1Test.class • An object of a static inner class does not have a reference to the outer class object that generated it. • The following example demonstrates • The use of a static member class to hide a class named Pair • A static member class accessing the private static member of its outer class • A static member class implementing an interface Nested Classes

  15. Quiz 1 • Select all correct answers in the following. Top-level classes and interfaces • Are always in the same package • Are always defined at top-level • Where not available before Jva 1.1 • Do not use access modifiers • Which of the following statements about nested classes are correct? • Static member classes can access all other members of the outer class • A static member class must be defined as the first member of its enclosing class • All non-static classes are called inner classes • An outer class of a static member class must also be static • Using the MaxMin interface in Example 1, the statement MaxMin [] pairs = new MaxMin[10] • Is invalid because MaxMin is an interface • Is valid and creates ten objects • Is valid and creates eleven objects • Is valid and creates only one object Nested Classes

  16. Member Classes • A member class is defined as a non-static member of another class • A member class is a class that is defined as a non-static member of another class • A member class is analogous to an instance field or instance method • Like other instance members, a member class can have any access modifier • That is a member class can be public, default, protected or private • Every instance of a member class is linked with an instance of the containing class • This means that the code for a member class has access to all the instance fields and instance methods of the containing class (including private ones) • Instance of a containing class needs not be associated with an instance of the member class • Member classes cannot have static fields, static methods or static classes (except static final fields) • Because static fields, methods and class are top-level constructs not associated with any particular object while • Every member object is associated with an object of its enclosing class Nested Classes

  17. Member Classes (cont’d) • Interfaces cannot be defined as member classes. Why? • Because an interface cannot be instantiated and, therefore, if it is a member class no instance of the interface can be created to associate with an object of the enclosing class • Note that a nested interface is explicitly or implicitly static, making it a static member class • The name of a member class, unlike fields and methods, must be different from that of any containing class or package Nested Classes

  18. Example 2: Member Classes 1 protected class Pair implements MaxMin{ 2 public void bestAndWorst(){ 3 if(grades.length > 0){ 4 best = grades[0]; 5 worst = grades[0]; 6 for(int i=1; i<grades.length; i++){ 7 if (best < grades[i]) best = grades[i]; 8 else if (worst > grades[i]) worst = grades[i]; 9 } 10 } 11 } 12 } 13 public class Course2Test{ 14 public static void main(String [] args){ 15 Course2 c2 = new Course2(10); 16 Course2.MaxMin cs = c2.new Pair(); 17 cs.bestAndWorst(); 18 System.out.println(cs); 19 } 20 } Nested Classes

  19. Example 2: Transcript • This class is the same as in Example 1 except that in this case the class is non-static and has the protected access modifier • Variables and the toString() method hidden for brevity • The test class is also the same as in Example 1 except line 16 which we now discuss • Notice carefully how an object of Pair is created using the the reference of the outer class Course2. • This what we mean by saying that an object of a member class is always created under using a reference of an object of the enclosing class Nested Classes

  20. Example 2: Transcript (cont’d) • Notice how class Pair accesses the private array grades of its enclosing class • Where ever class Pair is used inside Course2, its short name can be used instead of its fully-qualified name • Inside class Course2Test, Pair is known only using its fully-qualified name • Compare the object-creation statements in Course1Test and Course2Test: • An object of static member class does not require an object of its enclosing class (Course1Test), while • An object of member class requires an object of its enclosing class to be created (Course2Test) Nested Classes

  21. Can We Override Member Classes? Transcript • From our discussions, member classes have much in common with instance methods • Since instance methods can be overridden, can we also override member classes? • A good question to investigate is, since instance methods can be overridden, can we also override member classes? • This example attempts to answer this question • This example defines a class Course2 which contains a member class called Pair • The constructor of class Course2 simply displays a message and then creates an object of class Pair • The constructor of class Pair consists of a simple print statement • The test class in this program, OverridingMemberClass, is very similar to class Course2: it extends class Course2 and defines a member class Pair as in its parent class Course2 • When the program is executed, we see that the constructor of class Pair inside Course2 is executed rather than the constructor of class Pair inside the subclass • This shows that extending an outer class and redefining its member class does not amount to overriding the inherited member class • Notice that the same behavior is obtained when you attempt to “override” a static method from a super class Nested Classes

  22. Example 3: Can We Override Member Classes? 1 class Course2{ 2 public Course2(){ 3 System.out.println("Couse2 constructor."); 4 new Pair(); 5 } 6 protected class Pair { 7 public Pair(){ 8 System.out.println("Course2.Pair constructor."); 9 } } 10 } 11 class OverridingMemberClass extends Course2{ 12 public OverridingMemberClass(){ 13 System.out.println("OverridingMemberClass constructor."); 14 } 15 protected class Pair { 16 public Pair(){ 17 System.out.println("OverridingMemberClass.Pair constructor."); } 18 } 19 public static void main(String [] args){ 20 new OverridingMemberClass(); 21 } 22 } Nested Classes

  23. Example 4: Using this in Member Classes • As an object of a member class requires a reference of its enclosing class, the this reference is applicable inside member classes • Notice that this is similar to the fact that the this reference is applicable inside instance methods while it is not applicable inside static methods • From within an instance of a member class we can refer to two objects • Note that from within an instance of a member class we have two objects that we can refer to using the this reference • How do we distinguish the two objects? • That is, how do we distinguish an instance of the member class from that of the enclosing class using the this reference? • The next example demonstrates how this can be done • This is done simply as indicated: • To refer to the outer class object, use the notation OuterClass.this • when the this reference is used without a prefix, it refers to the member class object. • Note that in reality, • The compiler automatically passes the this reference to the member object through the constructor of the member class. Furthermore, the compiler automatically inserts a method that it uses to access each private field inside the enclosing class. Nested Classes

  24. Example 4: Keyword this in Member Classes // code omitted 1 public void bestAndWorst(){ 2 if(Course2.this.grades.length > 0){ 3 this.best = Course2.this.grades[0]; 4 this.worst = Course2.this.grades[0]; 5 for(int i=1; i<grades.length; i++){ 6 if (best < grades[i]) best = grades[i]; 7 else if (worst > grades[i]) worst = grades[i]; 8 } 9 } 10 } // code omitted Nested Classes

  25. Example 5: Extending Member Classes • Example 3 shows that member classes are inherited but cannot be overridden • In Example 3 we show that we can extend an outer class and inherit its member classes but cannot override the inherited member classes • Example 4 shows that a member class receives a reference of an object of the enclosing class implicitly • In Example 4 we show that a reference of an object of an enclosing class is implicitly passed to the object of a member class through the constructor(s) of the member class • We will use this example to answer the questions: • Can a member class be extended alone? • Can we extend a member class without extending its outer class? • Is a member class a subclass of its enclosing class? • How are constructors of subclasses of member classes written? • Constructors of subclasses of member classes must be written to ensure that the member class is correctly initialized and also to ensure that the enclosing classes of the member class are correctly initialized. • The complete example follows on the next page Nested Classes

  26. Example 5: Extending Member Classes 1 class Course2{ 2 public Course2(){ 3 System.out.println("Couse2 constructor."); 4 } 5 protected class Pair { 6 public Pair(){ 7 System.out.println("Pair constructor."); 8 } 9 } 10 } 11 class ExtendingMemberClass extends Course2.Pair{ 12 public ExtendingMemberClass(Course2 c2){ 13 c2.super(); 14 System.out.println("ExtendingMemberClass constructor."); 15 } 16 public static void main(String [] args){ 17 Course2 c2 = new Course2(); 18 //Course2 c2 = new Course2().new Pair(); 19 new ExtendingMemberClass(c2); 20 } 21 } Nested Classes

  27. Example 5: Part Trancript • Class Course2 in this example is very similar to that in Example 3. • It should require no additional explanation. • The class ExtendingMemberClass is extending the member class Pair • … as we can see • Defining a constructor for a subclass of a member class is not straight forward: • Recall that an object of an enclosing class implicitly passes a reference to itself to the object of its member class • The implicit reference received must be made explicit in subclasses • If the member class is extended this implicit reference must be made explicit in the derived class • An explicit reference of the enclosing class must be explicitly passed to the constructor of the class extending the member class • Therefore in the constructor of class ExtendingMemberClass, we pass an explicit reference of an object of Course2 • This makes it possible for correct initializations to take place through the constructor of class ExtendingMemberClass. • Note that although Pair is not a subclass of Course2 • An object of Course2 must be initialized before that of Pair and • as expected, Pair is initialized before its subclass ExtendingMemberClass Nested Classes

  28. Example 5: Transcript (cont’d) • In summary, this example has shown that • member classes can be extended without extending their enclosing class • member classes are not subclasses of their enclosing classes • constructors to subclasses of member classes must receive explicit reference of an object of the enclosing class of the member class as illustrated Nested Classes

  29. JVM View of Member Classes • No changes were made to the JVM to support nested classes • When inner classes were introduced, no changes where made to the JVM and the old JVM supports them automatically • Member classes are compiled to class files just like top-level classes but • Before nested classes, classes (top-level) can have only public or package visibility • With nested classes, member classes can have any access modifier • As we mentioned earlier a member class can have any access modifier: public, default, protected or private • How does the JVM treat member classes with protected and private modifiers? • Since the JVM was not changed how does it treat … • The JVM treats protected and private member classes to have public and package visibility respectively • Note that the JVM cannot enforce these access control modifiers; the compiler does • Although the JVM cannot enforce these access control modifiers, the modifiers are noted in the class file • This allows any conforming Java compiler to enforce the access modifiers and prevent member classes from being accessed in unintended ways Nested Classes

  30. Local Classes • When a class name is used once it can be defined locally • When a class name is known to be used only once, within a single method of its containing class, then it can be defined locally within a method • A local class is defined within a block of Java code • A local class is a class defined within a block of Java code • Like a local variable a local class is visible only within its enclosing block • Furthermore, local classes cannot be declared public, protected, private or static • Local classes share many of the features of member classes • Local classes are not member classes but they share many of the features of member classes since they are defined within an enclosing class • An instance of a local class is associated with an instance of its enclosing class • Like a member class, an instance of a local class is associated with an instance of its containing class • Furthermore, an instance of a local class access final variables in its enclosing block • Local classes can be completely hidden in their containing block • Local classes have the added advantage that they are completely hidden inside their enclosing method or block • Interfaces cannot be defined locally. Why? Nested Classes

  31. Example 6: Local Classes 1 public MaxMin getPair(){ 2 class Pair implements MaxMin{ 3 private double best; 4 private double worst; 5 public String toString(){ 6 return "Best grade: "+best+"\nWorst grade: "+worst+"\n"; 7 } 8 public void bestAndWorst(){ 9 if(grades.length > 0){ 10 best = grades[0]; 11 worst = grades[0]; 12 for(int i=1; i<grades.length; i++){ 13 if (best < grades[i]) best = grades[i]; 14 else if (worst > grades[i]) worst = grades[i]; 15 } 16 } 17 } 18 } 19 return new Pair(); 20 } Nested Classes

  32. Example 6: Local Classes (cont’d) 21 public class Course3Test{ 22 public static void main(String [] args){ 23 Course3 c3 = new Course3(10); 24 Course3.MaxMin cs = c3.getPair(); 25 cs.bestAndWorst(); 26 System.out.println(cs); 27 } 28 } Nested Classes

  33. Example 6: Local Classes: Transcript • This example is almost the same as Example 2. We will only point out the differences with Example 2. • We first notice that the definition of the class Pair is now moved inside the body of the method getPair(). Notice that this is the only place where the class Pair is used inside the enclosing class. • The second difference is that the class Pair is now without the protected modifier • The third difference is in the main() method of the test class. • Since the class Pair is now locally defined inside a method we cannot refer to it from outside that method. • Instead, we call the method getPair() to return an instance of the Pair class. • The remaining part of the code remains the same as in Example 2. Nested Classes

  34. Scope of Local Classes and Local Variables • We have mentioned that local classes are similar to local variables • We have mentioned earlier that local classes are similar to local variables in many respects • We also recall that a function’s activation record has a short lifetime • This means that the information in an activation record (local variables, parameters etc) is destroyed immediately the function returns • Now, are objects of local classes also destroyed when the function returns? • The question now is what happens to objects of a local class when the enclosing function returns? • Do they have the same lifetime as local variables or do they have longer lifetime? • The next example demonstrates two important issues: • 1. Objects of local classes can exist much longer after the function returns • The first issue is that objects of local classes can exist much longer after the enclosing function returns • 2. Local classes can access only final local variables and function parameters • The second issue is to illustrate why local variables/function parameters that a local classes accesses must be declared final Nested Classes

  35. Example 7: Scope of Local Class Objects 1 class LocalVariableAndClassScope{ 2 interface Doubler{int twice();} //implicitly static member 3 public static void main(String [] args){ 4 Doubler [] allEven = new Doubler[10]; 5 for(int i=0; i<allEven.length; i++){ 6 final int value = i; 7 class MyDoubler implements Doubler{ 8 public int twice(){ 9 return 2*value; 10 } 11 } 12 allEven[i] = new MyDoubler(); 13 } 14 for(int i=0; i<allEven.length; i++) 15 System.out.println(allEven[i].twice()); 16 } 17 } Nested Classes

  36. Example 7: Transcript • The example starts with a definition of an implicitly static member interface, Doubler • The interface has a single integer method twice() • Notice the definition of the local variable value and the local class MyDoubler • Note that these definitions are only visible inside the for-statement block • The statement in on line 12 fills up the MyDoubler array with instances of the local class • The statement in on line 12 fills up the MyDoubler array with different instances of the local class, MyDoubler • Notice that value and MyDoubler are not in scope after line xy • After the array has been filled up, both the local variable value and the local class MyDoubler are out of scope in the next for-statement • How does twice() access the value local variable and works correctly? • But how does the twice() method manage to access the value local variable to work correctly? • This is only possible if a copy of that variable has been made before exiting the scope! Nested Classes

  37. Example 7: Transcript • Each instance of a local class makes a private copy of the scope before the scope is exited! • In reality, each instance of a local class has an automatically created private copy of each of the final local variables it uses, so, in effect it has its own private copy of the scope that existed when it was created. • The only way to ensure that the values of the variables in the copied scope remain the same is to declare those variables final: Nested Classes

  38. 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 • That means all what we have said about local classes apply to anonymous classes as well • An anonymous class is defined and instantiated in a single expression • Notice that the definition and instantiation cannot be separated. Why is that? • An anonymous class has no constructors • Because the name of a constructor must be the same as the name of the class and the class has no name in this case • Construction parameters can be given through the superclass constructor • If parameters are needed to construct an anonymous class, then these parameters can be given through the constructors of the superclass. • When an anonymous class implements an interface, it cannot have any construction parameters. Why? • Interfaces cannot be defined anonymously. Why? Nested Classes

  39. Example 8: Anonymous Inner Classes 1 public MaxMin getPair(){ 2 return new MaxMin(){ 3 private double best; 4 private double worst; 5 public String toString(){ 6 return "Best grade: "+best+"\nWorst grade: "+worst+"\n"; 7 } 8 public void bestAndWorst(){ 9 if(grades.length > 0){ 10 best = grades[0]; 11 worst = grades[0]; 12 for(int i=1; i<grades.length; i++){ 13 if (best < grades[i]) best = grades[i]; 14 else if (worst > grades[i]) worst = grades[i]; 15 } 16 } 17 } 18 }; 19 } Nested Classes

  40. Anonymous Classes • Example 8 is almost identical to Example 6. The only thing we need to highlight is the syntax of defining anonymous classes. We present the notes on the next slide • Notice the syntax in this example when an anonymous class implements the interface MaxMin: new MaxMin(){ // body of anonymous class }; • If the anonymous class is named MyClass, the above (syntax) is equivalent to: class MyClass implements MaxMin{ // body of anonymous class } return new MyClass(); • If MaxMin were a class instead of an interface, then the keyword implements will be replaced with extends • Examples of multiple anonymous classes extending classes will be discussed later • We will consider examples of multiple anonymous inner classes extending (different) implementations within the same class later in our discussion on event-driven programming Nested Classes

  41. Quiz 2 • Which of the following statements about member classes are correct? • An instance of a member class object is always attached to an instance of the enclosing class • An instance of an enclosing class object is always attached to an instance of its member class • The fully-qualified name of a member class must be used where ever it is used in the enclosing class • Member classes can be overridden just like instance methods can be overridden • A member class is not a subclass of its outer class • Write down the names of two nested classes that can be defined inside a Java code block • One: • Two: • Which of the following statements are correct? • Top-level classes can only have public as an explicit modifier • Member classes are treated as having the public modifier by the JVM • When inner classes were introduced in Java 1.1, the JVM was modified slightly to support them • The JVM treats all nested classes as top-level classes • A nested class belongs to the same package as its enclosing class • Match the following • Member classes, static classes, local class • Cannot be declared public, protected, private or static, cannot be defined inside member classes, can have any access modifier Nested Classes

  42. Review Exercises • Consider the following program segment: • class Outer { • private int i; • private boolean b; • class Inner{ • private int j; • private float f; • } • } • Give a pictorial representation of the statement • Outer.Inner obj = new Outer().new Inner(); • Explain why Java does not allow declaring a static variable or a static local class within a method • Use appropriate examples to explain how nested classes provide addition support for object orientation, code organization and multiple implementation inheritance • Can an interface be defined inside a member class? Give an example or a counter example. • Compare and contrast static member classes and member classes • Write a complete program to illustrate how to access object of an outer class from an object of the inner class • Let B be a member class inside another class A. Let another class C extend B. Is it possible for class C to have a no-arg constructor? • Mention two similarities and two differences between member classes and anonymous classes Nested Classes

  43. References • Java in a Nutshell, David Flanagan, O’Reilly Inc., Third Edition, 1999. • Core Java, Cay Horstmann, Chapter 6. • Thinking in Java, Bruce Eckel, 2000. Nested Classes

More Related