Probability Harry R. Erwin, PhD School of Computing and Technology University of Sunderland.
An Advanced Code Pattern: Inner Classes CSE301 University of Sunderland Harry R. Erwin, PhD Half...
-
Upload
doris-newman -
Category
Documents
-
view
212 -
download
0
Transcript of An Advanced Code Pattern: Inner Classes CSE301 University of Sunderland Harry R. Erwin, PhD Half...
An Advanced Code Pattern:
Inner ClassesCSE301
University of SunderlandHarry R. Erwin, PhD
Half Lecture
Why Bother with Inner Classes?
• Java (like C++) tends to separate class definitions from where they are used.
• Java also tends to produce an exponential explosion in the number of classes in the system. This makes the architecture hard to understand and manage.
• Inner classes hide (encapsulation!) the extra helper classes needed to implement the system.
• Inner classes also localize the definition of these helper classes to exactly where they are used.
• Particularly important in graphical user interfaces, where events are usually handled by inner classes.
Inner Classes
• Static member classes (and interfaces) are defined as static members of another class.
• Member classes are instantiated within another class and have access to the fields of the enclosing class.
• Local classes are defined within a code block for use there.
• Anonymous classes are designed to be used as temporary variables in method calls without being given names.
Static Member Classes and Interfaces
• class or interface defined as a static member of another class.class Foo {
static class Bar {…}}
• Behaves like a top-level class but can access the static members of the containing class, including private members.
• Use like ‘friend’ in C++, frequently serving as a helper class. A static member interface can be defined to document how a class is to be accessed by another class.
Member Classes
• A class (not interface) defined as a member of another class.class Foo {
class Bar {…}}
• Can access the members of the containing class instance.
• Cannot contain static fields, methods, or classes (except static constant fields).
• Use like ‘friend’ in C++, often to implement a static member interface or a standard interface.
• For example, this can be used to define an Iterator for a user-defined Collection class.
Local Classes
• Defined within a block of Java code (in a method or initializer) and visible only there.
• Similar to member classes because the code is in a class. Local variables, arguments, and exception parameters it uses must be declared final so it can keep its own copies and have them be current.
• Often used to define an implementation of an interface:Iterator getIterator() {
class myIterator implements Iterator {define here how myIterator works}return new myIterator();
}
Anonymous Classes
• A local class without a name. Often used as an adaptor or a method argument.
• Combines class definition syntax with object instantiation syntax. No constructor. Use an instance initializer block instead.
• An expression, so it can be part of a larger expression, such as a method invocation.new java.util.Iterator() {class definition that implements an interface or extends a class}new MyIterator(arg list) {another class defn.}
Initialization Blocks
• static {code} is used to initialize static member fields for a class. These are run in order of appearance in the class definition.
• {code} is used to do common initialization of instance fields for all constructors. These are also run in order of appearance before the constructor runs.
• This does imply initialization code may run in an unexpected order!
• Used to support anonymous inner classes, which cannot have constructors (as they have no name).
Example of Initializationpublic class Foo {
public Foo() { bar = 2;}static { baz = 2;}{ bar = 1;}int bar = 0;static int baz = 1;
}
What are the values of bar and baz when theclass instance is finally initialized?
Defining a Static Member Interface
public class LinkedStack {public static interface Linkable {
public Linkable getNext();public void setNext(Linkable node);
}Linkable head;public void push(Linkable node) {…}public Object pop() {…}
}
From Flanagan, Java in a Nutshell, 4th edition, O’Reilly, 2002.
Using that InterfaceClass LinkableInteger implements LinkedStack.Linkable {
int I;public LinkableInteger(int I) {this.I = I;}LinkedStack.Linkable next;public LinkedStack.Linkable getNext()
{ return next;}public void setNext(LinkedStack.Linkable node)
{ next = node;}}
Note the syntax for referring to the interface outside the class.From Flanagan, Java in a Nutshell, 4th edition, O’Reilly, 2002.
A Member Classpublic class LinkedStack {
public static interface Linkable {…} private Linkable head;class members …public java.util.Iterator iterate() {
return new myIterator();}protected class myIterator implements
java.util.Iterator {Linkable current;public myIterator() { current = head;}Iterator definition …
}}
From Flanagan, Java in a Nutshell, 4th edition, O’Reilly, 2002.
A Local Class// returns an Iterator objectPublic java.util.Iterator iterate() {
class myIterator implements java.util.Iterator {Linkable current;public myIterator() { current = head;}provide the member functions requiredto implement an Iterator …
}return new myIterator();
}
This encapsulates an Iterator in the class being iterated.From Flanagan, Java in a Nutshell, 4th edition, O’Reilly, 2002.
An Anonymous Class
Public java.util.Iterator iterate() {return new java.util.Iterator {
Linkable current;{ current = head;} // instance initializer// No constructor!various member functions implementing Iterator…
}; // semicolon terminates the return statement}
From Flanagan, Java in a Nutshell, 4th edition, O’Reilly, 2002.