nested references 2 inner reference data types classes-interfaces
TRANSCRIPT
Nested References
2 inner reference data types
Classes-Interfaces
What are the different Nested Ref. Data Types?
• Nested (inner) classes
• Nested (inner) Interfaces
What is a nested reference?
• A reference contained by another reference
• A reference contained by a method
• A reference with no name ->anonymous
• anonymous class.
Why do I need a nested reference?
• To create a temporary reference
• To isolate the reference name space
• To create a new reference organization
• To make use of new object-oriented designs
• To create a local reference
• Simplify interfaces (façade design pattern).
What are the different types of Nested classes?
• nested static class
• nested dynamic class
Nested static classes
• Can be instanced without instancing the containing class.
• Class Point3d{
• static class Float(){…}
• static class Double(){…}
• }
What kinds of access can I have for a static class?
• public – public ref organization
• default – package ref organization
• private – yes, you can have a private inner class!
• protected – accessible to subclasses of the outer class
A static inner class
public abstract class Point3d {public static class Float extends Point3d {
public Float(float x, float y, float z) { …}public static class Double extends Point3d {
public Double (double x, double y, double z) {...}}Point3d pf = new Point3d.Float(10,20,30);
}
Inner class instead of packages!
class java {
class awt {
class Frame {
}
class Component {
}
}
}
Making an Anonymous Inner class
interface Runnable {
public void run();
}
Thread t = new Thread(
new Runnable() {
public void run() { doStuffHere();
}
});
What can you build an anonymous class from?
• an interface.
• an abstract class.
• non-abstract class.
Example of an anonymous inner class from a non-abstract class.
• class Customer {• private String name = “j doe”;
• public String toString() { return name;}
• }• class Payroll {• Customer c = new Customer(){public
String toString() {return “hello world”;}• }
Example of an named inner class from a non-abstract class.
• class Customer {• private String name = “j doe”;
• public String toString() { return name;}
• }• class Payroll {• class Customer2 extends Customer{
• public String toString() {return “hello world”;}
• }
An anonymous Member class is sometimes called an anonymous
class• class OuterClass {
• class namedMember {
• }
• Runnable r = new Runnable() {• public void run() { // do stuff here
• }
• }
• }
Nomenclature
• All anonymous classes are inner classes.
• Anonymous inner class = anonymous class.
• Convention is to call it an • anonymous inner class
Why not use a named class?
class Job implements Runnable {
public void run() { do Stuff Here...
}
}
Thread t = new Thread(new Job());
Ans: you only needed one new job. Like singleton
Make a 1000 classes....Local anonymous inner class
public static void main(String args[]){
for (int i=0; i < 1000; i++)
new Foo(new Runnable() {
public void run() {
This a unique class.....
}
});
}
Nomenclature
• Few people say: local anonymous inner class.
• Typically call it anonymous inner class
Command Pattern
• A design pattern
• Have commands reside in the instance, so the instance knows how to run itself.
• new Job(2) {• public void doCommand() {...}
• }
PrintFunction
class Print {
public static void printFunction(Fcn fcn) {
for (int x=0; x < 100; x++)
System.out.println(fcn.f(x));
}
}
Fcn, The Interface
public interface Fcn {
double f(double x);
}
print.printFunction(new Fcn() {
double f(double x) {
return x*x;
}
});
RunButton
• new RunButton(“ok”) {• public void run() {
• doesTheOKThing();
• }
• }
Using the Interface...for commands
class Commando {public Runnable getRunnable() { // factory pattern.
return new Runnable() { // anonymous local class
public void run() {
System.out.println(“wow”);
} // Commando c = new Commando();
} // Runnable r = c.getRunnable();
}
}
How do I use Commando?
• Commando c = new Commando();
• Thread t = new Thread(c.getRunnable());
• t.start(); //call back on the run method
Local inner class
• A class defined inside of a method
• Not accessible to outer classes
• Or the other methods in the same class!
Why do I need local inner classes?
• Factory pattern with an anonymous inner class!
• For example, a local anonymous inner class!!
This is pretty commonpublic Runnable getRunnable() {
new Runnable() {
public void run() {
System.out.println(“wow”);
}
Named Local Inner class
class RunnableThings {Runnable getARunThing() {
class Foo extends Job{} class Job implements Runnable {
public void run(){}}
return new Job(); }}
Nested Interface
public class Roach {
interface killable {
boolean isAlive();
}
class Colony implements killable {
boolean isAlive() {return true;}
}
}
Summary
• two kinds of nest ref data types:• interface
• local inner interface not permitted!
• member inner interface
• class• local inner class (named or anonymous)
• member inner class (named or anonymous)