一篇文章搞懂Java中的内部类，什么是内部类，内部类的概念和分类，静态内部类，局部内部类，匿名内部类，以及内部类代码图文演示，Java面试内部类

Java 中的内部类

我们平时写程序，都是由一个个的类这样构成的，这些类之间是互相独立的。内部类，就是打破这种互相独立的关系，让其中的一个类成为另外一个类的内部成员（也就是说：内部类是定义在某个类内部的，就像成员变量和成员方法一样）

1. 非静态内部类

先看个例子：

public class OuterClass {
    //成员变量
    private String outClassName;
    //成员方法
    public void display() {
        System.out.println("OuterClass display");
        System.out.println(outClassName);
    }

    //非静态内部类
    public class InnerClass {
        private String innerClassName;
        public void display(){
            System.out.println("InnerClass display");
            System.out.println(innerClassName);
        }

        public InnerClass(){
            innerClassName = "inner class";
        }
    }

    //main方法测试
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.display();
        // InnerClass innerClass = new InnerClass();   //报错，不能跟之前一样
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        innerClass.display();
    }
}

解析： OutClass 常称为 外部类，InnerClass 就是 OutClass 中的一个内部类，此时的内部类是一个非静态内部类。实例化的时候，外部类创建实例化对象还是一样，而内部类不一样。

由于此时是非静态内部类，所以是属于外部类对象的，而不是属于外部类的；上面又说了，内部类就跟成员变量和成员方法一样，是不是也可以直接调；再加上它是类，肯定跟成员变量和方法有不一样的地方。

综上这几点，创建非静态内部类实例对象示例如下：

外部类名.非静态内部类名 = 外部类对象.new 非静态内部类名();
//外部类名.   可以不写，但为了容易理解，一般都写

2. 静态内部类

当我们把它变为静态内部类，实例化对象的方式也就发生变化了，如下：

注意：以前我们知道，静态的成员变量和方法，可以通过对象调，也可以通过类调。但静态内部类不行。

3. 局部内部类（方法中使用内部类）

内部类还可以在方法体中定义，但此时内部类不能使用 public，而是不写：

4. 匿名内部类

也就是没有名字的内部类。主要应用到 接口的实现。比如：现在有个接口（MyInterface）、对应的实现类（MyImplements）

而匿名内部类就不一样：

public class Test {
    public static void main(String[] args) {
        MyInterface myInterface1 = new MyInterface() {
            @Override
            public void test() {

            }
        }; //注意 分号
    }
}

接口不能被实例化，但这里实际上不是接口的实例化，而是实现类的实例化，只不过实现类没有名字而已（相当于就不要接口的实现类了，因为内容都是一样的）

4.1 静态/非静态内部类实现接口

同样，不用匿名内部类，就采用普通的内部类也可以实现接口：

public class Test {

    public class MyImplements implements MyInterface{

        @Override
        public void test() {
            System.out.println("test");
        }
    }

    public static void main(String[] args) {
        Test test = new Test();
        MyImplements myImplements = test.new MyImplements();
        myImplements.test();
    }
}

5. 为什么采用内部类

我直接再定义一个类不就行了。从程序角度来说，确实是一样。使用内部类可以隐藏细节和内部结构，封装性更好，让程序结构更加合理。

现实生活中，一个事物内部都是由很多部件组成的，同时部件又包含子部件，而这些子部件不需要全部暴露出来。内部类就跟这一样。

注意：

这种方式跟内部类没有任何关系，它就是两个类，只不过写在了一个文件里面（一个文件可以写很多类，但只能有一个 public 类）