Java内部类

内部类

内部类就是定义在一个类里面的类，里面的类可以理解成（寄生），外部类可以理解成（宿主）。

public class People{
	// 内部类
	public class Heart{
	}
}
1
2
3
4
5

内部类的使用场景、作用

1.当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构可以选择使用内部类来设计。
2.内部类通常可以方便访问外部类的成员，包括私有的成员。
3.内部类提供了更好的封装性，内部类本身就可以用private protectecd等修饰，封装性可以做更多控制。

内部类的分类

1.静态内部类

什么是静态内部类？
(1).有static修饰，属于外部类本身。
(2)，它的特点和使用与普通类是完全一样的，类有的成分它都有，只是位置在别人里面而已。

public class Outer{
	// 静态成员内部类
	public static class inner{}
}
1
2
3
4

静态内部类创建对象的格式：

格式：外部类名.内部类名 对象名 = new 外部类名.内部类构造器;
1

静态内部类的访问拓展：
1.静态内部类中是否可以直接访问外部类的静态成员？
可以，外部类的静态成员只有一份可以被共享访问。

2.静态内部类中是否可以直接访问外部类的实例成员？
不可以的，外部类的实例成员必须用外部类对象访问。

由外部类访问：

2.成员内部类

什么是成员内部类？
1.无static修饰，属于外部类的对象。
2.jdk16之前，成员内部类中不能定义静态成员，jdk16开始也可以定义静态成员了。

public class Outer{
	// 成员内部类
	public class Inner{}
}
1
2
3
4

成员内部类创建对象的格式：

格式：外部类名.内部类名 对象名=new 外部类构造器.new 内部类构造器();
1

成员内部类的访问扩展：
1.成员内部类中是否可以直接访问外部类的静态成员？
可以，外部类的静态成员只有一份可以被共享访问。
2.成员内部类的实例方法中是否可以直接访问外部类的实例成员？
可以的，因为必须先有外部类对象，才能有成员内部类对象，所以可以直接访问外部类对象的实例成员。

面试题：写出下列代码对应其注释要求输出的结果。

package snow.d6_innerclass;

public class People {
    private int heartbeat = 150;
    public class Heart{
        private int heartbest = 110;
        public void show(){
            int heartbest = 78;
            System.out.println(heartbest); // 78
            System.out.println(this.heartbest); // 110
            System.out.println(People.this.heartbeat); // 150
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

注意：在成员内部类中访问所在外部类对象，格式：外部类名.this。

3.局部内部类

什么是局部内部类？
1.局部内部类放在方法、代码块、构造器等执行体中。
2.局部内部类的类文件名为：外部类$内部类.class.

4.匿名内部类

什么是匿名内部类？
本质上是一个没有名字得到局部内部类，定义在方法中、代码块中、等。
匿名内部类的作用：方便创建子类对象，最终目的为了简化代码编写。
格式：

new 类|抽象名|或者接口名(){
	重写方法；
};
1
2
3

具体的实现：

package snow.d8_innerclass_anonymous;

public class Test {
    public static void main(String[] args) {
        Animal a = new Tiger();
        a.run();
        // 匿名内部类 相当于子类对象实例化
        Animal a1 = new Animal() {
            @Override
            public void run() {
                System.out.println("老虎跑的快~~");
            }
        };
        a1.run();
    }
}
// 子类
class Tiger extends Animal{
    @Override
    public void run() {
        System.out.println("老虎跑的块~");
    }
}
// 抽象动物类
abstract class Animal{
    public abstract void run();
}
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

特点总结：
1.匿名内部类就是一个没有名字的内部类。
2.匿名内部类写出来就会产生一个匿名内部类的对象。
3.匿名内部类的对象类型相当于是当前new的那个的类型的子类类型。
匿名内部类在开发中的使用形式了解
某个学校需要让老师，学生，运动员一起参加游泳比赛

package snow.d8_innerclass_anonymous;

public class Test2 {
    public static void main(String[] args) {
        Swimming s = new Student();
        go(s);
        // 匿名内部类
        Swimming ss = new Swimming() {
            @Override
            public void swim() {
                System.out.println("老师在游泳");
            }
        };
        go(ss);
    }
    // 学生 老师 运动员可以一起参加比赛
    public static void go(Swimming s){
        System.out.println("开始。。。");
        s.swim();
        System.out.println("结束。。。");
    }
}
// 接口的继承
class Student implements Swimming{
    @Override
    public void swim() {
        System.out.println("学生快乐的自由泳");
    }
}
// 游泳接口
interface Swimming{
    void swim();
}
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

总结：匿名内部类可以作为方法的实际参数进行传输。
匿名内部类真实使用场景：
给按钮绑定点击事件

package snow.d8_innerclass_anonymous;

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class Test3 {
    public static void main(String[] args) {
        // 创建窗口
        JFrame win = new JFrame("登录界面");
        // 创建桌布
        JPanel panel = new JPanel();
        win.add(panel);
        // 创建按钮对象
        JButton btn = new JButton("登录");
        // 匿名内部类
//        btn.addActionListener(new ActionListener() {
//            @Override
//            public void actionPerformed(ActionEvent e) {
//                JOptionPane.showMessageDialog(win, "点我一下说明爱我！");
//            }
//        });
        // 简化
        btn.addActionListener( e ->
                JOptionPane.showMessageDialog(win, "点我爱我！"));
        // 把按钮对象添加到桌布上展示
        panel.add(btn);
        // 展示窗口
        win.setSize(400,300);
        win.setLocationRelativeTo(null);
        win.setVisible(true);
    }
}
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

总结：开发中不是我们主动去定义匿名内部类的，而是别人需要我们写或者我们可以写的时候才会使用。匿名内部类的代码可以实现代码进一步的简化(回扣主题)