Thinking in Java：内部类

内部类

普通内部类：其对象的实例化依赖于一个外部类对象，有指向其外部类对象的引用，可以访问外部类的所有成员变量和方法，普通内部类中不能包含静态成员变量和静态方法。

public class Outer{

private String out = "Outer";

public void out(){

}

class Inner{

public void printOut(){

System.out.println(out);

}

public Outer getOuter(){

return Outer.this;//获取该内部类所指向的外部类

}

public void innerOut(){

out();

}

}

public Inner getInner(){

return new Inner();

}

public static void main(String args[]){

Outer outer = new Outer();

Inner inner1 = outer.getInner();

Inner inner2 = outer.new Inner();

}

}

当外部类中的方法与内部类中的方法重名时，若无特殊指明则访问的是内部类中的方法，例：

public class Outer{

private String out = "Outer";

public void out(){

System.out.println("out");

}

class Inner{

public void out(){

System.out.println("in");

}

public void innerOut(){

out();

}

public void innerOut2(){

Outer.this.out();

}

}

public static void main(String args[]){

Outer outer = new Outer();

Inner inner1 = outer.getInner();

inner1.innerOut();

inner1.innerOut2();

}

}

打印结果：in

    out

局部内部类：在方法中的内部类

interface In{

public void writeIn();

}

public class Outer{

private boolean flag = true;

public In getIn(){

if(flag){

class Inner{

public void out(){

System.out.println("in");

}

public void innerOut(){

out();

}

public void innerOut2(){

Outer.this.out();

}

}

return new Inner();

}

return null;

}

}

匿名内部类：匿名内部类若使用外部类的变量，则该变量是final的。

interface In{

public void out(String out);

public void writeIn();

}

public class Outer{

private final String out = "out";

public In getIn(){

return new In(){

public void out(out){

System.out.println(out);

}

public void writeIn(){

System.out.println("匿名内部类");

}

};

}

}

嵌套类（静态内部类）：内部类的创建不再依赖于外部类，也就没有了指向外部类的引用，嵌套类中不能访问外部类的非静态成员变量和方法

public class Outer{

private String out = "Outer";

public void out(){

}

static class Inner{

public void printOut(){

System.out.println(out);

}

public void innerOut(){

out();

}

}

public static void main(String args[]){

Outer outer = new Outer();

Inner inner2 = new Inner();

}

}

继承普通内部类的问题：因为普通的内部类中持有指向其外部类的引用，该引用必须被初始化，所以不论是普通内部类还是其子类的实例化都要依赖于外部类的实例。

public class Outer{

private String out = "Outer";

public void out(){

}

class Inner{

public void printOut(){

System.out.println(out);

}

public void innerOut(){

out();

}

}

}

class Inn extends Inner{

Inn(Outer out){

out.super();//继承内部类所用特殊语法

}

}

内部类的覆盖问题：

public class Outer{

class Inner{

public void printInner(){

System.out.println("Super Inner");

}

}

public static void main(String args[]){

Outer out = new OuterChild();
out.new Inner().printInner();

}

}

class OuterChild extends Outer{

class Inner{

public void printInner(){

System.out.println("Child Inner");

}

}

}

打印信息：Super Inner

父子类中的内部类相互独立，且由此得知具体调用的内部类与外部类的类型有关（而非具体实现），调用与此类型相关联的内部类

内部类的意义：

1、“多重继承”的另一种实现方式，一个类可以包含多个外部类

2、内部类拥有对外部类的访问权限，可以在一些功能的实现上更加简洁

3、内部类与外部类可以实现相同的接口/继承相同的类，这样外部类相当于对接口/父类提供了多种不同的实现方式