07_面向对象高级_内部类

内部类

1. 认识内部类

• 它是类中的五大成分之一（成员变量、方法、构造器、内部类、代码块）
• 如果一个类定义在另一个类的内部，这个类就是内部类。

public class Test {
    public static void main(String[] args) {
        // 直接输出: 内部类的静态成员变量
        System.out.println(Outer.Inner.gender);  // null

        // 创建内部类的对象，并调用功能
        Outer.Inner obj = new Outer().new Inner();
        // 调用内部类自己的方法
        obj.run();  // 快跑啊~~~
        obj.test();  // 1、10、100
    }
}

class Outer {
    // 成员变量
    private int number = 100;
    public static String info;

    // 成员方法
    public void run() {
        System.out.println("跑");
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    // 成员内部类
    public class Inner {
        // 成员变量
        private int number = 10;
        public static String gender;  // JDK 16才开始支持定义静态成员

        // 成员方法
        public void run() {
            System.out.println("快跑啊~~~");
        }

        public void test() {
            int number = 1;
            System.out.println(number);
            // 调用内部类的成员
            System.out.println(this.number);
            // 调用外部类的成员
            System.out.println(Outer.this.number);  // 通过Outer.this拿到当前的外部对象
        }

        public int getNumber() {
            return number;
        }

        public void setNumber(int number) {
            this.number = number;
        }
    }
}
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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

2. 静态内部类 (了解)

• 有 static 修饰的内部类，就是静态内部类
• 静态内部类可以直接访问外部类的静态成员，但是不能直接访问外部类的实例成员

public class Test {
    public static void main(String[] args) {
        // 创建"静态内部类"的对象
        Outer.Inner obj = new Outer.Inner();
        obj.test();  // null
    }
}

class Outer {
    private int age;
    public static String schoolId;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    // 静态内部类
    public static class Inner {
        private String name;
        public static int id;

        public void test() {
            System.out.println(schoolId);  // 可以直接访问外部类的静态成员变量
//          System.out.println(age);  // 报错，不可以可以直接访问外部类的成员变量(对象的变量)
            // 因为这是静态内部类，如图静态方法一样，不能访问对象的变量
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = 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

3. 局部内部类

• 局部内部类是定义在方法中，代码块中，构造器等执行体中
• 这个语法没啥用，看看就好

public class Test {
    // main方法，程序入口
    public static void main(String[] args) {

    }
	// run方法
    public static void run() {
        class A {

        }
        abstract class B {

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

4. 匿名内部类

• 概念：它是一种特殊的局部内部类，所谓匿名：指的是程序员不需要为这个类声明名字。

• 代码展示：

（要求在"代码二"中，使用"匿名内部类"的知识实现"代码一"的功能）

// 代码一
public class Test {
    public static void main(String[] args) {
        Animal obj = new Cat();
        obj.cry();
    }
}

class Cat extends Animal {
    @Override
    public void cry() {
        System.out.println("喵喵喵~~~");
    }
}

abstract class Animal {
    public abstract void cry();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// 代码二
public class Test {
    public static void main(String[] args) {
        // 计算机遇到代码"  new Animal(){...};  "会做两件事
        // 1.把这个匿名内部类，编译成一个子类
        // 2.然后会立即创建一个子类对象出来
        Animal obj = new Animal() {
            @Override
            public void cry() {
                System.out.println("喵喵喵~~~");
            }
        };  // 千万要注意！这里不要漏了分号;

        obj.cry();  // 喵喵喵~~~
    }
}

abstract class Animal {
    public abstract void cry();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

• 通过上面的演示，你应该很清楚的了解到"匿名内部类"的特点：它的本质就是一个子类，并且会立刻创建出一个子类对象，然后返回出来。
• 应用场景：使用它可以更方便的创建一个子类，返回出来的对象则通常作为参数进行使用。