Java内部类（清晰明了！）

---

内部类

什么是内部类：

一般情况下，类和类之间是相互独立的，内部类就是打破这种独立，让一个类成为另一个类的内部成员，和成员变量、成员方法为同等级别！

为什么需要内部类？我们写两个独立的外部类也能达到一样效果：

采用内部类，可以隐藏细节和内部结构，封装性更好，让程序结构更加合理！

1. 成员（非静态）内部类

非静态（成员）内部类的使用就是将内部类当作一个外类的一个成员变量/方法来使用，所以必须依赖于外部类对象的调用，用法和成员变量/方法的使用是一样的！

/**
 * 成员（非静态）内部类：内部类与外部类的成员变量/方法为同一个等级
 * 创建内部类对象innerClass：外部类对象.new InnnerClass()
 */
public class OuterClass {
    // 成员变量
    private String name;
    private Integer age;
    // 成员方法
    public void display(){
        System.out.println("我是外部类的成员方法");
    }

    // 非静态内部类
    public class InnerClass {
        private String name;
        public void display(){
            System.out.println("我是成员内部类的方法");
        }
        // 内部类构造器
        public InnerClass() {

        }
        public InnerClass(String name) {
            this.name = name;
        }
    }

    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.display();
        // 内部类不能在独立创建对象，必须依赖于外部类对象！
        OuterClass.InnerClass  innerClass = outerClass.new InnerClass();
        innerClass.display();

        OuterClass.InnerClass  innerClass2 = outerClass.new InnerClass("张三");
        System.out.println(innerClass2.name);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

输出结果：

我是外部类的成员方法
我是成员内部类的方法
张三

局部内部类：

public class Outer {
    
    //局部内部类（在方法里面写的类）
    public void method(){
        class Inner{
            
        }
    }
}
1
2
3
4
5
6
7
8
9

2. 静态内部类

就是将上述成员内部类加个static关键字，然后使用方式发生了改变！

回顾一下：

之前我们在学习面向对象的时候，一个类的成员方法/变量的使用是有两种方式的：

• 第一种是通过类（普通外部类）所创建的对象实例来调用：对象.属性
• 第二种是将这个类设置为静态类（static），无所创建对象实例，通过类名就可以直接调用：ClassName.属性

同样的静态内部类也是如此，我们通过将内部类改为静态内部类（给内部类加上static关键字），那么这个内部类就暴露出来了，我们就可以直接通过外部类名来创建内部类对象，而不在需要通过外部类对象的实例来创建内部类对象！

/**
 * 静态内部类：将内部类设置为静态（static）
 * 内部类对象创建：无需依赖与外部类的实例对象，可通过外部类直接创建
 */
public class OuterClass {
    // 成员变量
    private String name;
    private Integer age;
    // 成员方法
    public void display(){
        System.out.println("我是外部类中的方法");
    }

    // 静态内部类
    public static class InnerClass {
        private String name;
        public void display(){
            System.out.println("我是静态内部类中的方法");
        }
        // 内部类构造器
        public InnerClass() {
            name = "张三";
        }
    }

    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.display();

        // 静态内部类对象：无需依赖与外部类对象的实例，通过外部类类名就可以直接创建！
        OuterClass.InnerClass innerClass = new InnerClass();
        innerClass.display();
        System.out.println(innerClass.name);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

输出结果：

我是外部类中的方法
我是静态内部类中的方法
张三

3. 匿名内部类

匿名内部类就是一个没有名字的内部类，主要应用于接口的实现！（后面学了函数式编程后就可以使用Lambda表达式来替换优化）

我们知道接口他是抽象的，我们不能通过接口来new一个具体的实例对象，而是通过它的实现类来new一个实例对象！

让我们来看看通过实现类来实现接口的方式跟通过匿名内部类来实现接口的方式，它们在写法上有什么不同吧！

接口：

public interface MyInterface {
    void test();
}

1
2
3
4

接口实现类：

public class MyInterfaceImpl implements MyInterface{
    @Override
    public void test() {
        System.out.println("test......");
    }
}

1
2
3
4
5
6
7

测试台：

public class Application {
    public static void main(String[] args) {
        // 通过实现类实现接口：
        MyInterface myInterface = new MyInterfaceImpl();
        myInterface.test();

        // 通过匿名内部类实现接口
        // 这里并不是 new 接口 而是 new 接口的实现类（只不过没有显示new的哪个实现类 它是没有名字滴）
        MyInterface myInterface2 = new MyInterface() {
            @Override
            public void test() {
                System.out.println("test......");
            }
        };
        myInterface2.test();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

输出结果：

test…
test…

匿名内部类的好处：

我们定义接口之后，我们没有必要为了实现接口而去单独显性的创建一个它的实现类（例子中的MyInterfaceImpl），然后再通过这个实现类来new对象。直接写到一起就可以，更加的简洁！

匿名内部类的缺点：

全写在一起耦合度高