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()
*///:~