Java内部类

什么是内部类？

在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类。内部类主要有以下几类：成员内部类、局部内部类、静态内部类、匿名内部类。内部类是编译时的概念，编译成功后，内部类和它的外部类将是两个不同的类（它们之间还是有联系的）。编译成功后会出现这样两个文件：OuterClass.class和OuterClass&InnterClass.class。

内部类的共性

• 外部类不能直接的访问内部类的成员，但可以通过内部类对象访问。
• 内部类可以自由的调用外部类的属性、方法等，包括private修饰的。
• 内部类可以有自己的属性、方法、构造器等。
• 内部类可以声明为final的。
• 除了局部内部类，内部类可以用private、public、protected等来修饰。
• 可以声明为abstract类 ，因此可以被其它的内部类继承。
• 继承一个外部类，并重写其内部类，子类并不会重写父类的内部类，如果想达到重写的效果可以让子类也定义一个内部类并继承父类的内部类，重写父类中内部类的方法

问题：为什么内部类可以自由的调用外部类的全部成员？

因为当某个外围类的对象创建内部类的对象时，此内部类会捕获一个隐式引用，它引用了实例化该内部对象的外围类对象。通过这个指针，可以访问外围类对象的全部状态。

通过反编译内部类的字节码，分析之后主要是通过以下几步做到的： 
1 编译器自动为内部类添加一个成员变量， 这个成员变量的类型和外部类的类型相同， 这个成员变量就是指向外部类对象的引用； 
2 编译器自动为内部类的构造方法添加一个参数， 参数的类型是外部类的类型， 在构造方法内部使用这个参数为1中添加的成员变量赋值； 
3 在调用内部类的构造函数初始化内部类对象时， 会默认传入外部类的引用。

为什么使用内部类？

• 内部类方法可以访问该类定义所在的作用域的数据，包括私有的数据

• 内部类可以对同一个包中的其他类隐藏起来,一般的非内部类，是不允许有 private 与protected权限的，但内部类可以

• 可以实现多重继承

• 当想要定义一个回调函数且不想编写大量代码时，使用匿名内部类比较便捷

  使用内部类最吸引人的原因是：

　　每个内部类都能独立地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。大家都知道Java只能继承一个类，它的多重继承在我们没有学习内部类之前是用接口来实现的。但使用接口有时候有很多不方便的地方。比如我们实现一个接口就必须实现它里面的所有方法。而有了内部类就不一样了。它可以使我们的类继承多个具体类或抽象类。

public class Example1 {    public String name(){       return "liutao";   }}public class Example2 {    public int age(){        return 25;    }}public class MainExample {   private class test1 extends Example1{        public String name(){          return super.name();        }    }    private class test2 extends Example2 {       public int age(){         return super.age();       }    }   public String name(){    return new test1().name();    }   public int age(){       return new test2().age();   }   public static void main(String args[]){       MainExample mi=new MainExample();       System.out.println("姓名:"+mi.name());       System.out.println("年龄:"+mi.age());   }}

成员内部类

即在一个类中直接定义的内部类， 成员内部类与普通的成员没什么区别，可以与普通成员一样进行修饰和限制。成员内部类不能含有static的变量和方法，但可以有static final 修饰的常量。

public class Outer {    private static int i = 1;    private int j = 10;    private int k = 20;    public static void outer_f1() {}    public void outer_f2() {}    // 成员内部类中，不能定义静态成员    // 成员内部类中，可以访问外部类的所有成员    class Inner {        // static int inner_i = 100;//内部类中不允许定义静态变量        int j = 100; // 内部类和外部类的实例变量可以共存        int inner_i = 1;        void inner_f1() {            System.out.println(i);            // 在内部类中访问内部类自己的变量直接用变量名            System.out.println(j);            // 在内部类中访问内部类自己的变量也可以用this.变量名            System.out.println(this.j);            // 在内部类中访问外部类中与内部类同名的实例变量用外部类名.this.变量名            System.out.println(Outer.this.j);            // 如果内部类中没有与外部类同名的变量，则可以直接用变量名访问外部类变量            System.out.println(k);            outer_f1();            outer_f2();        }    }    // 外部类的非静态方法访问成员内部类    public void outer_f3() {        Inner inner = new Inner();        inner.inner_f1();    }    // 外部类的静态方法访问成员内部类，与在外部类外部访问成员内部类一样    public static void outer_f4() {        // step1 建立外部类对象        Outer out = new Outer();        // step2 根据外部类对象建立内部类对象        Inner inner = out.new Inner();        // step3 访问内部类的方法        inner.inner_f1();    }    public static void main(String[] args) {        //outer_f4();//该语句的输出结果和下面三条语句的输出结果一样        // 如果要直接创建内部类的对象，不能想当然地认为只需加上外围类Outer的名字，        // 就可以按照通常的样子生成内部类的对象，而是必须使用此外围类的一个对象来        // 创建其内部类的一个对象：        // Outer.Inner outin = out.new Inner()        // 因此，除非你已经有了外围类的一个对象，否则不可能生成内部类的对象。因为此        // 内部类的对象会悄悄地链接到创建它的外围类的对象。如果你用的是静态的内部类，        // 那就不需要对其外围类对象的引用。        Outer out = new Outer();        Outer.Inner outin = out.new Inner();        outin.inner_f1();    }}

静态内部类

　如果你不需要内部类对象与其外围类对象之间有联系，那你可以将内部类声明为static。这通常称为嵌套类（nested class）。想要理解static应用于内部类时的含义，你就必须记住，普通的内部类对象隐含地保存了一个引用，指向创建它的外围类对象。然而，当内部类是static的时，就不是这样了。嵌套类意味着：

　　1. 要创建嵌套类的对象，并不需要其外围类的对象。

　　2. 不能从嵌套类的对象中访问非静态的外围类对象。

public class Outer {    private static int i = 1;    private int j = 10;    public static void outer_f1() {}    public void outer_f2() {}    // 静态内部类可以用public,protected,private修饰    // 静态内部类中可以定义静态或者非静态的成员    private static class Inner {        static int inner_i = 100;        int inner_j = 200;        static void inner_f1() {            // 静态内部类只能访问外部类的静态成员(包括静态变量和静态方法)            System.out.println("Outer.i" + i);            outer_f1();        }        void inner_f2() {            // 静态内部类不能访问外部类的非静态成员(包括非静态变量和非静态方法)            // System.out.println("Outer.i"+j);            // outer_f2();        }    }    public void outer_f3() {        // 外部类访问内部类的静态成员：内部类.静态成员        System.out.println(Inner.inner_i);        Inner.inner_f1();        // 外部类访问内部类的非静态成员:实例化内部类即可        Inner inner = new Inner();        inner.inner_f2();    }    public static void main(String[] args) {        new Outer().outer_f3();    }}

局部内部类

　在方法中定义的内部类称为局部内部类。与局部变量类似，局部内部类不能有访问说明符，因为它不是外围类的一部分，但是它可以访问当前代码块内的常量，和此外围类所有的成员。

需要注意的是：

　　(1)、局部内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。

　　(2)、局部内部类对象不能使用该内部类所在方法的非final局部变量。

public class Outer {    private int s = 100;    private int out_i = 1;    public void f(final int k) {        final int s = 200;        int i = 1;        final int j = 10;        // 定义在方法内部        class Inner {            int s = 300;// 可以定义与外部类同名的变量            // static int m = 20;//不可以定义静态变量            Inner(int k) {                inner_f(k);            }            int inner_i = 100;            void inner_f(int k) {                // 如果内部类没有与外部类同名的变量，在内部类中可以直接访问外部类的实例变量                System.out.println(out_i);                // 可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的                System.out.println(j);                // System.out.println(i);                // 如果内部类中有与外部类同名的变量，直接用变量名访问的是内部类的变量                System.out.println(s);                // 用this.变量名访问的也是内部类变量                System.out.println(this.s);                // 用外部类名.this.内部类变量名访问的是外部类变量                System.out.println(Outer.this.s);            }        }        new Inner(k);    }    public static void main(String[] args) {        // 访问局部内部类必须先有外部类对象        Outer out = new Outer();        out.f(3);    }}

局部内部类使用场景常见以下两种方式

//方式1//创建一个实现Comparable的局部内部类public Comparable getComparable1(){class MyComparable implements Comparable{@Overridepublic int compareTo(Object o) {return 0;}}//返回实现类的对象return new MyComparable();}//方式2//返回一个实现Comparable接口的匿名内部类对象public Comparable getComparable2(){return new Comparable() {@Overridepublic int compareTo(Object o) {return 0;}};}

匿名内部类

简单地说：匿名内部类就是没有名字的内部类。什么情况下需要使用匿名内部类？如果满足下面的一些条件，使用匿名内部类是比较合适的：

• 只用到类的一个实例。
• 类在定义后马上用到。
• 类非常小（SUN推荐是在4行代码以下）
• 给类命名并不会导致你的代码更容易被理解。

在使用匿名内部类时，要记住以下几个原则：

• 　　匿名内部类不能有构造方法。

• 　　匿名内部类不能定义任何静态成员、方法和类。

• 　　匿名内部类不能是public,protected,private,static。

• 　　只能创建匿名内部类的一个实例。

•    一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。

• 　　因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。

interface  A{public  abstract void fun1();}public class Outer{public static void main(String[] args) {new Outer().callInner(new A(){               //接口是不能new但此处比较特殊是子类对象实现接口，只不过没有为对象取名public void fun1() {System.out.println(“implement for fun1");}});// 两步写成一步了}public void callInner(A a) {a.fun1();}}  

部分内容转载自：点击打开链接