多态、内部类

面向对象三大特征之三：多态
二、内部类

面向对象三大特征之三：多态

1.多态的概述

什么是多态？

同类型的对象，执行同一个行为，会表现出不同的行为特征。

多态的常见形式

父类类型 对象名称 = new 子类构造器;
接口	对象名称 = new 实现类构造器;

多态中成员访问特点

方法调用：编译看左边，运行看右边
变量调用：编译看左边，运行也看左边（多态侧重行为多态）

public abstract class Animal {
    public String name = "父类的名字";
    public abstract void run();
}
public class Dog extends Animal {
    public String name = "子类Dog的名字";
    @Override
    public void run() {
        System.out.println("狗在叫、、、");
    }
}
public class Tortoise extends Animal {
    public String name = "子类乌龟的名字";
    @Override
    public void run() {
        System.out.println("乌龟在爬、、、。。");
    }
}
public class Test {
    public static void main(String[] args) {
        //1.多态的形式：  父类类型  对象名称 = new 子类构造器；
        Animal d = new Dog();
        d.run();//编译看左边，运行看右边
        System.out.println(d.name);//对于变量的调用：编译看左，运行也看左边

        Animal t = new Tortoise();
        t.run();//编译看左边，运行看右边
        System.out.println(d.name);
    }
}
output:
狗在叫、、、
父类的名字
乌龟在爬、、、。。
父类的名字

多态的前提

有继承/实现关系；有父类引用指向子类对象；有方法重写

2.多态的好处

优势

在多态的形式下，右边对象可以实现解耦，便于拓展和维护。

Animal a = new Dog();
a.run();//后续业务行为随对象而变，后续代码无需修改

定义方法的时候，使用父类型作为参数，该方法就可以接收这个父类的一切子类对象，体现出多态的拓展性与便利。

多态下会产生的一个问题：

多态下不能使用子类的独有功能

3.多态下引用数据类型的类型转换

自动类型转换（从子到父）：子类对象赋值给父类类型的变量指向。

强制类型转换（从父到子）：

此时必须进行强制类型转换：子类对象变量 = （子类）父类类型的变量
作用：可以解决多态下的劣势，可以实现调用子类独有的功能
注意：如果转型后的类型和对象真是类型不是同一种类型，那么在转换的时候就会出现ClassCastException
有继承关系/实现的2个类型就可以进行强制转换，编译无问题。

Animal t = new Tortoise();
Dog d = (Dog)t;//出现异常 ClassCaseException

Java建议强转转换前使用instanceof判断当前对象的真实类型，在进行强制转换

变量名	instanceof 真实类型
判断关键字左边的变量指向的对象的真实类型，是否是右边的类型或者是其子类类型，是则返回true，反之。

4.多态的综合案例

需求：

使用面向对象编程模拟：设计一个电脑对象，可以安装2个USB设备
鼠标：被安装时可以完成接入、调用点击功能、拔出功能
键盘：被安装时可以完成接入、调用打字功能、拔出功能

分析：

定义一个USB的接口（申明USB设备的规范必须是：可以接入和拔出）。
提供2个USB实现类代表鼠标和键盘，让其实现USB接口，并分别定义独有功能。
创建电脑对象，创建2个USB实现类对象，分别安装到电脑中并触发功能的执行。

//定义一个接口
public interface USB {
    void connect();
    void unconnect();
}
//定义一个鼠标实现类
public class Mouse implements USB {
    private String name;
    public void dbClick(){
        System.out.println(name+"鼠标双击了。。。");
    }
    public Mouse() {
    }
    public Mouse(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public void connect() {
        System.out.println(name+"连接了电脑");
    }
    @Override
    public void unconnect() {
        System.out.println(name+"从电脑拔出了");
    }
}
//定义一个键盘实现类
public class KeyBoard implements USB{
    private String name;
    public void KeyDown(){
        System.out.println("键盘打出了加油两个字");
    }
    public KeyBoard() {
    }
    public KeyBoard(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public void connect() {
        System.out.println(name+"连接了电脑");
    }
    @Override
    public void unconnect() {
        System.out.println(name+"从电脑拔出了");
    }
}
//定义一个电脑类
public class Computer {
    private String name;

    public Computer() {
    }

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

    /**
     * 提供安装USB的接口
     */
    public void installUSB(USB usb){
        //多态   usb可能是鼠标也可能是键盘
        usb.connect();
        //判断
        if (usb instanceof KeyBoard){
            KeyBoard k = (KeyBoard)usb;
            k.KeyDown();
        }else if (usb instanceof Mouse){
            Mouse m = (Mouse)usb;
            m.dbClick();
        }
        usb.unconnect();
    }
    public void start(){
        System.out.println(name+"开机了");
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
        Computer c = new Computer("外星人");
        c.start();
        USB u = new KeyBoard("键盘");
        c.installUSB(u);
        USB u1 = new Mouse("鼠标");
        c.installUSB(u1);
    }
}
output：
外星人开机了
键盘连接了电脑
键盘打出了加油两个字
键盘从电脑拔出了
鼠标连接了电脑
鼠标鼠标双击了。。。
鼠标从电脑拔出了

二、内部类

2.1内部类概述

内部类：

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

public class People{
    //内部类
    public class Heart{
    }
}

内部类的使用场景、作用

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

内部类的分类

静态内部类
成员内部类（非静态内部类）
局部内部类
匿名内部类

2.2 内部类之一：静态内部类

什么是静态内部类？

有static修饰，属于外部类本身
它的特点和使用与普通类是完全一样的，类有的成分它都有，只是位置在别人里面而已。

public class Outer{
    //静态成员内部类
    public static class Inner{
    }
}

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

格式：外部类名.内部类名 对象名 = new 外部类名.内部构造器;
范例：Outer.Inner in = new Outer.Inner();

静态内部类的访问拓展

静态内部类中是否可以直接访问外部类的静态成员？
- 可以，外部类的静态成员只有一份可以被共享访问。
静态内部类中是否可以直接访问外部类的实例成员？
- 不可以，外部类的实例成员必须要外部类的对象访问。

静态内部类使用场景、特点、访问总结

如果一个类中包含了一个完整部分，如汽车类的发动机类
特点与普通类是一样的，类有的成分它都有，只是位置在别人里面而已。
可以直接访问外部类的静态成员，不可以直接访问外部类的静态成员
注意：开发中，实际上用的比较少

2.3 内部类之二：成员内部类

什么是成员内部类？

无static修饰，属于外部类的对象。
JDK16之前，成员内部类中不能定义静态成员，JDK16之后开始也可以定义静态成员了

public class Outer{
    //成员内部类
    public class Inner{   
    }
}

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

格式：外部类名.内部类名 对象名 = new 外部类构造器.new 内部类构造器;
范例： Outer.Inner in = new Outer().new Inner();

成员内部类访问拓展

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

成员内部类-面试题

请观察以下代码，写出合适的代码对应其注释要求输出的结果。

class People{
    private int heartbeat = 150;
    public class Heart{
        private int heartbeat = 110;
        
        public void show(){
            int heartbeat  = 78;
            System.out.println(heartbeat);//78
            System.out.println(this.heartbeat);//110
            System.out.println(People.this.heartbeat);//150
        }
    }
}

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

2.4 内部类之三：局部内部类

局部内部类（鸡肋语法，了解即可）

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

2.5 内部类之四：匿名内部类概述

匿名内部类

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

格式：

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

Employee a = new Employee(){
    public void work(){
    }
};
a.work();

import java.util.Timer;

public class Test {
    public static void main(String[] args) {
        Animal a = new Animal() {
            @Override
            public void run() {
                System.out.println("老虎跑的快、、、");
            }
        };
        a.run();
//        Tiger t = new Tiger();
//        t.run();

    }
}
//class Tiger extends Animal{
//    @Override
//    public void run(){
//        System.out.println("老虎跑的快····");
//    }
//}
 abstract class Animal{
    public abstract void run();
}
output:
老虎跑的快、、、

特点总结:

匿名内部类是一个没有名字的内部类
匿名内部类写出来就会产生一个匿名内部类的对象。
匿名内部类的对象类型相当于是当前new的那个类型的子类类型。

匿名内部类常见使用形式

匿名内部类在开发中的使用形式了解

某个学习需要让老师，学生，运动员一起参加游泳比赛

public class Test2 {
    public static void main(String[] args) {
        Swimming s = new Swimming() {
            @Override
            public void swim() {
                System.out.println("学生在游泳");
            }
        };
        go(s);
        System.out.println("----------");

        go(new Swimming() {
            @Override
            public void swim() {
                System.out.println("老师在游泳！");
            }
        });
    }
    public static void go(Swimming s){
        System.out.println("开始");
        s.swim();
        System.out.println("结束");
    }
}

interface Swimming{
    void swim();
}
output:
开始
学生在游泳
结束
----------
开始
老师在游泳！
结束

使用总结:

匿名内部类可以作为方法的实际参数进行传输。

匿名内部类真实使用场景演示

给按钮绑定监听事件

//为按钮绑定点击事件监听器
btn.addActionListener(new ActionListener(){
	@Override
	public void actionPerformed(ActionEvent e){
        System.out.println("登录一下！");
    }                      
});

示例：

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

public class Test3 {
    public static void main(String[] args) {
        //1.创建窗口
        JFrame win = new JFrame("登录界面");
        //创建一个桌布对象
        JPanel panel = new JPanel();
        //将桌布对象加入到窗口中
        win.add(panel);

        //2.创建一个按钮对象
        JButton btn = new JButton("登录");

        //注意使用匿名内部类
       /* btn.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
               JOptionPane.showMessageDialog(win,"点我有惊喜！");
            }
        });*/
       //上面代码的更简化写法
       btn.addActionListener(e -> JOptionPane.showMessageDialog(win,"点我更惊喜！"));
        //3.把按钮对象加到桌布上显示
        panel.add(btn);
        //4.展示窗口
        win.setSize(400,300);
        win.setLocationRelativeTo(null);
        win.setVisible(true);
    }
}

使用总结：开发中不是我们主动去定义匿名内部类的，而是别人需要我们写或者我们可以写的时候才会使用。

匿名内部类的代码可以实现进一步的简化

posted @ 2022-01-11 15:43 tryAgainCs 阅读(70) 评论(0) 编辑收藏举报

刷新页面返回顶部

再试一次Again