Java开发从入门到精通（二十）：Java的面向对象编程OOP：内部类

（一）Java的内部类

1.1 内部类概述

1.1.1 内部类

• 是类中的五大成分之一(成员变量、方法、构造器、内部类、代码块)，如果一个类定义在另一个类的内部，这个类就是内部类。
• 场景:当一个类的内部，包含了一个完整的事物，且这个事物没有必要单独设计时，就可以把这个事物设计成内部类。

1.1.2 内部类有四种形式

• 成员内部类[了解]
• 静态内部类[了解]
• 局部内部类盯了解]
• 匿名内部类[重点]

1.2 成员内部类|了解]

成员内部类

• 就是类中的一个普通成员，类似前面我们学过的普通的成员变量、成员方法

1.2.1 成员内部类语法格式

创建一个成员内部类

public class Outer {
    private int age = 99;
    public static String a;

    public class Inner {
        private String name;
        private int age = 88;
        public static String schoolName;// JDK 16开始才支持定义静态成员

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public void test() {
            System.out.println(age);
            System.out.println(a);
            int age = 66;
            System.out.println(age);//66
            System.out.println(this.age);//88
            System.out.println(Outer.this.age);// 99
        }

        public void test2() {
            System.out.println(age);
            System.out.println(a);
        }
    }
}
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

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

public class Test {
    public static void main(String[] args) {
        // 目标:了解成员内部类和其特点。
        Outer.Inner in =new Outer().new Inner();
        in.test();
    }
}
1
2
3
4
5
6
7

成员内部类中访问其他成员的特点:

• 1、和前面学过的实例方法一样，成员内部类的实例方法中，同样可以直接访问外部类的实例成员、静态成员。
• 2、可以在成员内部类的实例方法中，拿到当前外部类对象，格式是:外部类名.this。

1.3 静态内部类[了解]

• 有static修饰的内部类，属于外部类自己持有。

1.3.1 静态内部类语法格式

public class Outer {
    private int age;
    public static String schoolName;
    
    //静态内部类
    public static class Inner {
        private String name;
        public static int a;

        public void test() {
            System.out.println(schoolName);
            System.out.println(age);//不能访问
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

    }
    public static void test2(){
        System.out.println(schoolName);
        System.out.println(age);//不能访问
    }
}
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

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

静态内部类中访问外部类成员的特点

• 可以直接访问外部类的静态成员，不可以直接访问外部类的实例成员，

1.4 局部内部类[了解]

• 局部内部类是定义在在方法中、代码块中、构造器等执行体中，

1.4.1 局部内部类语法格式

鸡肋语法，看看就好

1.5 匿名内部类[重点]

匿名内部类
就是一种特殊的局部内部类;所谓匿名:指的是程序员不需要为这个类声明名字。

1.5.1 匿名内部类语法格式

这段代码中创建一个子类的对象还需要单独写一个子类出来

public class Test {
    public static void main(String[] args) {
        // 目标:认识匿名内部类，并掌握其作用
        Animal a = new Cat();
        a.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

使用匿名内部类可以直接得到一个子类对象，而不需要再写一个类

public class Test {
    public static void main(String[] args) {
        // 目标:认识匿名内部类，并掌握其作用
        //这就是匿名内部类，代码执行到这的时候会做两件事
        //1.把这个匿名内部类编译成一个子类
        //2.然后立即创建一个子类对象出来
        Animal a = new Animal(){
            @Override
            public void cry() {
                System.out.println("猫喵喵喵的叫~~~");
            }    
        };
        a.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

1.5.2 匿名内部类创建对象的格式:

• 特点:匿名内部类本质就是一个子类，并会立即创建出一个子类对象
• 作用:用于更方便的创建一个子类对象

1.5.3 匿名内部类的常见使用场景

public class Test {
    public static void main(String[] args) {
        // 目标:掌握匿名内部类的常见使用场景。
        // 创建匿名内部类
        Swimming s1 = new Swimming() {
            @Override
            public void swim() {
                System.out.println("狗玊飞快~~~~");
            }
        };
        go(s1);
    }

    // 设计一个方法，可以接收swimming接口的一切实现类对象进来参加游泳比赛
    public static void go(Swimming s) {
        System.out.println("开始-----------------");
        s.swim();
    }
}

//猫和狗都要参加游泳比赛
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

优化 匿名内部类在开发中通常作为一个参数直接传给方法的

public class Test {
    public static void main(String[] args) {
        // 目标:掌握匿名内部类的常见使用场景。
        // 创建匿名内部类
        Swimming s1 = new Swimming() {
            @Override
            public void swim() {
                System.out.println("狗玊飞快~~~~");
            }
        };
        go(new Swimming() {
            @Override
            public void swim() {
                System.out.println("狗玊飞快~~~~");
            }
        };);
    }

    // 设计一个方法，可以接收swimming接口的一切实现类对象进来参加游泳比赛
    public static void go(Swimming s) {
        System.out.println("开始-----------------");
        s.swim();
    }
}

//猫和狗都要参加游泳比赛
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

匿名内部类在开发中的真实使用场景

package com.qianxin.neibulei;

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

public class Test {
    public static void main(String[] args) {
        // 拓展:搞清楚匿名内部类在开发中的真实使用场景。
        // GUI编程
        // 1、创建窗口
        JFrame win =new JFrame( "登录界面");
        JPanel panel=new JPanel();
        win.add(panel);
        JButton btn =new JButton( "登录");
        panel.add(btn);
        // 给按钮绑定单击事件监听器。
        btn.addActionListener(new ActionListener() {
                                  @Override
                                  public void actionPerformed(ActionEvent e) {
                                      JOptionPane.showMessageDialog(win,"登录一下");

                                  }
                              });

        // 最终的核心目的是:简化代码
        btn.addActionListener(e ->JOptionPane.showMessageDialog(win, "登录一下"));
        
        
        win.setSize(400,400);
        win.setLocationRelativeTo(null);
        win.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        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
34
35

1.16 枚举泛型