深入理解内部类_class outter { private string n = "outter"; class -CSDN博客

本文链接：https://blog.csdn.net/jeffleo/article/details/52210336

问题引出

public class Outter{

    private int a = 0;

    private class Inner{
        public int getA(){
            return ++a;
        }
    }

    private Inner getInner(){
        return new Inner();
    }

    public static void main(String[] args){
        Outter out = new Outter();
        System.out.println(out.getInner().getA());
    }
}

打印出的结果是： 1
Outter是外围类，Inner是内部类。打印的结果为1，则说明i确实被++了，而加1操作是在Inner中的，为什么内部类能够访问外围类的成员变量？

内部类和外部类的联系

上面的例子说明，内部类拥有对外部类的所有成员的访问权，这是因为，当某个外部类对象创建一个内部类对象时，此内部类对象必然会秘密得获取到一个指向那个外部类对象的引用。因此，当你在内部类访问外部类的成员时，就是用这个引用来访问的。

但外部类想要访问内部类的成员，则必须要先获得内部类的对象才能访问。

静态内部类

如果你不需要内部类跟外部类有联系，则可以使用静态内部类，将内部类声明为static。区别在于，普通的内部类会自动获得对外部类对象的引用，而静态内部类则不需要外部类对象的引用。

public class Outter{

    private static class Inner{
        private String a = "inner";
    }

    public static void main(String[] args){
        Outter.Inner inner = new Outter.Inner();
        System.out.println(inner.a);
    }
}

创建内部类对象

创建静态内部类对象：外部类类名.内部类类名 xxx = new 外部类类名.内部类类名()
创建普通内部类对象：外部类类名.内部类类名 xxx = 外部类对象名.new 内部类类名()

可见，创建普通内部类对象使用使用外部类对象来使用.new语法，而静态内部类的对象创建则不需要外部类对象。

匿名内部类

匿名内部类是内部中最常使用的，例如在Android的点击事件中，匿名内部类的使用：

button.setOnClickListener(new OnClickListener(){

    @Override
    public void onClick(){

    }

});

使用匿名内部类的原因是因为普通内部类冗长并且难以维护，而匿名内部类维护则容易多了，当我们不需要内部类的对象时，我们应该优先使用匿名内部类。
但是匿名内部类比较受限，因为它只能实现接口或者继承类，两者不可兼得，并且即使实现接口，也只能实现一个接口。因此，匿名内部类多用于事件的回调。
关于两者的选择，完全要看代码的需求！

注意事项：
匿名内部类中使用的外部类的成员一定要声明为final。

值得思考的例子

interface Ball{
    void play();
}

public class Test{

    private Ball getBall(){
        return new Ball(){

            @Override
            public void play() {

            }

        };
    }
}

问题：接口不是不能new的吗？
这里使用的是匿名内部类，new Ball{}，创建一个实现了Ball接口的类，但是因为我们并不需要该类的实例，因此我们无需再写一个类去实现接口，然后在new这个类。这就是匿名内部类的方便之处，在这里它省略了临时定义类实现接口的开销。

为什么需要内部类

我认为内部类存在最重要的意义在于，它完善了Java的多重继承机制
没有内部类的情况下，我么使用多重继承实现只能通过接口，但是接口的局限在于，实现接口，就必须实现它所有的方法，这就是什么在能使用接口和类的情况下，优先使用类。
假如一个人，他想要拥有吃饭和睡觉两种能力，但只能通过继承类来获得这种能力，只能通过内部类。
如这个例子：

abstract class Sleep{
    abstract void sleep();
}

abstract class Eat{
    abstract void eat();
}

class Person extends Eat{

    public void showMyAbility(){
        MySleep sleep = new MySleep();
        this.eat();
        sleep.sleep();
    }

    @Override
    void eat() {
        System.out.println("I has ability of ate");
    }

    class MySleep extends Sleep{

        @Override
        void sleep() {
            System.out.println("I has ability of slpet");
        }

    }

}

public class TestInterface{
    public static void main(String[] args){
         Person person = new Person();
         person.showMyAbility();
    }
}