java内部类

１．java内部类的作用：

（１）是自动拥有对外围类的所有成员的访问权（是因为在内部类的设计中获取了外围类的引用。从而可以使用　外围类．ｔｈｉｓ来获取外围类）。

（２）每个内部类都能独立的继承自一个（接口的）实现，所以无论外围类是否继承了某个（接口的）实现。对于内部类都没有影响。所以这里就解决了一个多重继承的问题。

２．java内部类不能有static成员。除非是嵌套类（即static的类）．ｊａｖａ的内部类可以定义在方法或作用域中。

 

3    .java内部类的创建和使用：

使用.．new

ｐｕｂｌｉｃ　ｃｌａｓｓ　Ａ｛
　　　ｐｕｂｌｉｃ　ｃｌａｓｓ　Ｂ｛｝
｝
ｐｕｂｌｉｃ　ｓｔａｔｉｃ　ｖｏｉｄ　ｍａｉｎ（Ｓｔｒｉｎｇ［］　ａｒｇｓ）｛
　　　Ａ　ａ　＝　ｎｅｗ　Ａ（）；
　　　Ａ．Ｂ　ｂ　＝　Ａ．ｎｅｗ　Ｂ（）；
｝

4.  匿名内部类：

ｐｕｂｌｉｃ　ｃｌａｓｓ　Ａ｛
　　　ｐｕｂｌｉｃ　Ｂ　Ｂ（）｛
　　　　ｒｅｔｕｒｎ　ｎｅｗ　Ｂ（）｛
　　　　　　．．．．．．
　　　　｝；／／分号只是标识了表达式的结束；
　　　｝
｝

上述相当于：

      

ｐｕｂｌｉｃ　ｃｌａｓｓ　Ａ｛
　　　ｐｕｂｌｉｃ　ｃｌａｓｓ　ＭｙＢ　ｉｍｐｌｅｍｅｎｔｓ　Ｂ｛
　　　　　．．．．．．
　　　｝
 
　　　ｐｕｂｌｉｃ　Ｂ　ｇｅｔＢ（）｛ｒｅｔｉｒｍ　ＭｙＢ（）；｝
｝

 5.内部类的继承：

不能使用默认的构造器，需要有外围类的参数

	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);
		  }
	}

6.关于内部类的覆盖问题：

class Egg {
  protected class Yolk {
    public Yolk() {
      System.out.println("Egg.Yolk()");
    }
  }
  private Yolk y;
  public Egg() {
    System.out.println("New Egg()");
    y = new Yolk();
  }
}

public class BigEgg extends Egg {
  public class Yolk {
    public Yolk() {
      System.out.println("BigEgg.Yolk()");
    }
  }
  public static void main(String[] args) {
    new BigEgg();
  }
}

这部分的代码打印的结果是New Egg() 和 Egg.Yolk()。这是在void main中创建BigEgg 的时候先调用父类的构造函数，父类构造函数创建了内部类的egg。

这表明：当继承了某个外围类的时候，内部类并没有特别神奇的变化。这两个York内部类只是两个空间里面的实体。如果内部类非要继承，那么

class Egg2 {
  protected class Yolk {
    public Yolk() {
      System.out.println("Egg2.Yolk()");
    }
    public void f() {
      System.out.println("Egg2.Yolk.f()");
    }
  }
  private Yolk y = new Yolk();
  public Egg2() {
    System.out.println("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() {
      System.out.println("BigEgg2.Yolk()");
    }
    public void f() {
      System.out.println("BigEgg2.Yolk.f()");
    }
  }
  public BigEgg2() { insertYolk(new Yolk()); }
  public static void main(String[] args) {
    Egg2 e2 = new BigEgg2();
    e2.g();
  }
}

（1）执行Egg2 e2 = new BigEgg2();

按照先父类后子类，先成员后构造函数的初始化顺序。此处先执行第10行，然后执行yolk构造函数输出egg2.yolk, 然后再执行egg2的构造函数里面的输出new egg2()，最后再回到子类中的构造函数，里面是new了一个yolk，输出egg2.yolk。同样按照先父类后子类，的顺序，先执行子类的构造函数，然后输出egg2.yokl。再子类的newEgg2.yolk。

（2）执行e2.g()  

执行是父类中的 y.f();之前y的引用指向了子类中的Yolk,所以执行的是子类中的f(),故输出bigEgg2.yolk.f()

这里内部类实现了覆盖，和普通类的继承没有什么区别

6.局部内部类：

可以访问外围类的所有成员。在此局部内部类和匿名内部类：在需要有已命名的构造器，或重载构造器的时候用局部内部类，在只是实例初始化的时候用匿名内部类

7.关于匿名内部类的两个重要的应用：

（1）回调：

public class InnearTest {
	private Delegate delegate;
    public interface Delegate {
        public boolean canDisplayBottomControls();
    }
    
    public InnearTest(Delegate delegate){
    	this.delegate =  delegate;
    }
    
    public void f(){
    	delegate.canDisplayBottomControls();
    }
	}

public class A implements InnearTest.Delegate{
	InnearTest inner;
	public A(){
		InnearTest(this);
	}
	
	@Override
	public boolean canDisplayBottomControls() {
		//......
		return false;
	}
	
}

（2）功能控制：这个在android的ui上比较明显