InnerClass笔记
http://blog.csdn.net/kittyjie/article/details/4404439
?
interface Selector {
??? boolean end();
??? Object current();
??? void next();
}
public class Sequence {
??? private Object[] items;
??? private int next = 0;
??? public Sequence(int size) {
??????? items = new Object[size];
??? }
??? public void add(Object x) {
??????? if (next < items.length)
??????????? items[next++] = x;
??? }
??? private class SequenceSelector implements Selector {
??????? private int i = 0;
??????? public boolean end() {
??????????? return i == items.length;
??????? }
??????? public Object current() {
??????????? return items[i];
??????? }
??????? public void next() {
??????????? if (i < items.length) i++;
??????? }
??? }
??? public Selector selector() {
??????? return new SequenceSelector();
??? }
//??? public static void main(String[] args) {
//??????? Sequence sequence = new Sequence(10);
//??????? for(int i = 0; i < 10; i++)
//??????? sequence.add(Integer.toString(i));
//??????? Selector selector = sequence.selector();
//??????? while(!selector.end()) {
//??????? System.out.print(selector.current() + " ");
//??????? selector.next();
//??????? }
//??????? }
}
===============================================
??????? 返回父类和新建内部类
public class DotThis {
??? void f() {
??????? System.out.println("DotThis.f()");
??? }
??? public class Inner {
??????? public DotThis outer() {
??????????? return DotThis.this;
// A plain "this" would be Inner’s "this"
??????? }
??? }
??? public Inner inner() {
??????? return new Inner();
??? }
??? public static void main(String[] args) {
??????? DotThis dt = new DotThis();
??????? DotThis.Inner dti = dt.inner();
??????? dti.outer().f();
??? }
}
//=======
public class DotNew {
??? public class Inner {
??? }
??? public static void main(String[] args) {
??????? DotNew dn = new DotNew();
??????? DotNew.Inner dni = dn.new Inner();
??? }
}
==============================================
??????? 可以在if等语句块或者方法体内定义内部类
public class Parcel6 {
??? private void internalTracking(boolean b) {
??????? if (b) {
??????????? class TrackingSlip {
??????????????? private String id;
??????????????? TrackingSlip(String s) {
??????????????????? id = s;
??????????????? }
??????????????? String getSlip() {
??????????????????? return id;
??????????????? }
??????????? }
??????????? TrackingSlip ts = new TrackingSlip("slip");
??????????? String s = ts.getSlip();
??????? }
// Can’t use it here! Out of scope:
//! TrackingSlip ts = new TrackingSlip("x");
??? }
??? public void track() {
??????? internalTracking(true);
??? }
??? public static void main(String[] args) {
??????? Parcel6 p = new Parcel6();
??????? p.track();
??? }
}
===============================================
??????? 匿名内部类
??????? 其实匿名内部类没有传统意义是的继承和实现接口，也就是说通过extends和implements等关键字实现继承和实现接口，但是却可以继承和实现接口，只是方式不一样：
??????? 继承：
class Wrapping {
??? private int i;
??? public Wrapping(int x) {
??????? i = x;
??? }
??? public int value() {
??????? return i;
??? }
}
public class Parcel {
??? public Wrapping wrapping(final int x) {
??????? return new Wrapping(x) {
??????????? public int value() {
??????????????? //注意这里的super关键字
??????????????? return super.value() * x;
??????????? }
??????? };
??? }
??? public static void main(String[] args) {
??????? Parcel8 p = new Parcel8();
??????? Wrapping w = p.wrapping(10);
??????? System.out.println(w.value());
??? }
}
实现接口：
interface PrintText {
??? void printText(String txt);
}
public class Test {
??? //注意这里，是怎么实现PrinterText的，还有要注意的是那个public不能省略。否则编译器报错。
//因为匿名类实现了接口，如果不加public，那么默认的访问优先级是protected，而接口的方法是public，根据不能降低优先级的规则，所以那个public必须写上
??? public PrintText getPrinter() {
??????? return new PrintText() {
??????????? public void printText(String txt) {
??????????????? System.out.println(txt);
??????????? }
??????? };
??? }
??? public static void main(String[] args) {
??????? Test t = new Test();
??????? t.getPrinter().printText("Test");
??? }
}
===============================================
??????? 匿名类的构造函数，这有这种写法。
abstract class Base {
??? public Base(int i) {
??????? print("Base constructor, i = " + i);
??? }
??? public abstract void f();
}
public class AnonymousConstructor {
??? public static Base getBase(int i) {
??????? return new Base(i) {
??????????? {
??????????????? print("Inside instance initializer");
??????????? }
??????????? public void f() {
??????????????? print("In anonymous f()");
??????????? }
??????? };
??? }
??? public static void main(String[] args) {
??????? Base base = getBase(47);
??????? base.f();
??? }
}
============================================
??????? 接口里面使用内部类：
public interface ClassInInterface {
??? void howdy();
??? class Test implements ClassInInterface {
??????? public void howdy() {
??????????? System.out.println("Howdy!");
??????? }
??????? public static void main(String[] args) {
??????????? new Test().howdy();
??????? }
??? }
}
这样运行： ClassInInterface$Test
public class TestBed {
??? public void f() {
??????? System.out.println("f()");
??? }
??? public static class Tester {
??????? public static void main(String[] args) {
??????????? TestBed t = new TestBed();
??????????? t.f();
??????? }
??? }
}
=============================================
??????? 实现多重继承：
class D {
}
abstract class E {
}
class Z extends D {
??? E makeE() {
??????? return new E() {
??????? };
??? }
}
public class MultiImplementation {
??? static void takesD(D d) {
??? }
??? static void takesE(E e) {
??? }
??? public static void main(String[] args) {
??????? Z z = new Z();
??????? takesD(z);
??????? takesE(z.makeE());
??? }
}
===============================================
??????? 从一个内部类继承：
class WithInner {
??? class Inner {
??? }
}
public class InheritInner extends WithInner.Inner {
??? //! InheritInner() {} // Won’t compile
??? InheritInner(WithInner wi) {
//注意这种特殊写法，必须调用父类的构造函数。
??????? wi.super();
??? }
??? public static void main(String[] args) {
??????? WithInner wi = new WithInner();
??????? InheritInner ii = new InheritInner(wi);
??? }
}
================================================
??????? InnerClass 重写：
class Egg {
??? private Yolk y;
??? protected class Yolk {
??????? public Yolk() {
??????????? print("Egg.Yolk()");
??????? }
??? }
??? public Egg() {
??????? print("New Egg()");
??????? y = new Yolk();
??? }
}
public class BigEgg extends Egg {
??? public class Yolk {
??????? public Yolk() {
??????????? print("BigEgg.Yolk()");
??????? }
??? }
??? public static void main(String[] args) {
??????? new BigEgg();
??? }
} /* Output:
New Egg()
Egg.Yolk()
*///:~
可以看出两个类里面的匿名类是不一样的，实现不了重写
??????? 但是下面匿名类可以实现另一种重写：
class Egg2 {
??? protected class Yolk {
??????? public Yolk() {
??????????? print("Egg2.Yolk()");
??????? }
??????? public void f() {
??????????? print("Egg2.Yolk.f()");
??????? }
??? }
??? private Yolk y = new Yolk();
??? public Egg2() {
??????? print("New Egg2()");
??? }
??? public void insertYolk(Yolk yy) {
??????? y = yy;
??? }
??? public void g() {
??????? y.f();
??? }
}
public class BigEgg2 extends Egg2 {
??? public class Yolk extends Egg2.Yolk {
??????? public Yolk() {
??????????? print("BigEgg2.Yolk()");
??????? }
??????? public void f() {
??????????? print("BigEgg2.Yolk.f()");
??????? }
??? }
??? public BigEgg2() {
??????? insertYolk(new Yolk());
??? }
??? public static void main(String[] args) {
??????? Egg2 e2 = new BigEgg2();
??????? e2.g();
??? }
} /* Output:
Egg2.Yolk()
New Egg2()
Egg2.Yolk()
BigEgg2.Yolk()
BigEgg2.Yolk.f()
*///:~
?
