上午（2.5h）多态核心 + 向上 / 向下转型

1. 多态的 3 个前提条件（0.5h）

必须同时满足，缺一不可

1. 必须有继承关系（extends）
2. 子类必须重写父类方法（override）
3. 父类引用指向子类对象（向上转型）

一句话记住：多态 = 继承 + 重写 + 父类引用装子类对象

---

2. 向上转型（自动类型转换）（0.7h）

格式

java

运行

父类类型 引用名 = new 子类类型();

核心口诀（面试必考）

编译看左边，运行看右边

• 编译：只能调用父类里有的方法
• 运行：执行子类重写后的方法

特点

• 自动完成，不需要强转
• 不能调用子类独有方法
• 统一管理不同子类，企业代码最常用

---

完整案例代码（Animal & Cat）

java

运行

// 父类
class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}

// 子类继承父类
class Cat extends Animal {
    // 重写方法
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    // 子类独有方法
    public void catchMouse() {
        System.out.println("猫抓老鼠");
    }
}

// 测试类
public class TestUpCast {
    public static void main(String[] args) {
        // 向上转型：父类引用指向子类对象
        Animal a = new Cat();

        // 编译看左（Animal），运行看右（Cat）
        a.eat(); // 输出：猫吃鱼

        // 错误！不能调用子类独有方法
        // a.catchMouse();
    }
}

代码解释

• Animal a = new Cat() 就是向上转型

这一句对初学者是个超难点在这里我来解释一下

new Cat() → 实实在在创建了一只猫（真实对象）

Animal a → 给这只猫贴了一个 “动物” 标签（引用）

完整含义：

用 “动物” 的名字，指向一只真实的 “猫”

• 对象本身：永远是 Cat
• 引用类型：写成了 Animal

它做了什么操作？

1. 在内存里创建了一个 Cat 对象
2. 让父类类型的变量 a 指向这个 Cat 对象
3. 这叫向上转型

本质：猫还是猫，只是你用 “动物” 的眼光看它。

• a.eat() 表面是父类方法，实际运行子类重写的方法
• a 不能调用 catchMouse()，因为编译只看左边 Animal

---

3. 向下转型（强制类型转换）（0.8h）

作用

把向上转型后的对象转回原本子类类型，从而调用子类独有方法。

格式

java

运行

子类类型 引用名 = (子类类型) 父类引用;

风险

如果类型不匹配，会抛 ClassCastException 类型转换异常。

---

完整代码

java

运行

public class TestDownCast {
    public static void main(String[] args) {
        // 向上转型
        Animal a = new Cat();

        // 向下转型（强制转换）
        Cat c = (Cat) a;

        // 可以调用子类独有方法
        c.catchMouse(); // 输出：猫抓老鼠
    }
}

---

4. instanceof 类型判断（0.5h）

作用

判断一个对象真实类型是什么，避免强转报错。

企业必备写法

java

运行

if (对象 instanceof 类型) {
    // 强转一定安全
}

---

完整代码

java

运行

public class TestInstanceof {
    public static void main(String[] args) {
        Animal a = new Cat();

        // 判断 a 是不是 Cat 类型
        if (a instanceof Cat) {
            Cat c = (Cat) a;
            c.catchMouse();
        } else {
            System.out.println("不是猫，不能抓老鼠");
        }
    }
}

这是实习、面试、企业开发最常用的安全强转写法。

---

下午（3h）抽象类 + 多态综合应用

1. 抽象类语法（abstract）（1h）

规则（必须背）

• 用 abstract 修饰类
• 抽象方法只有声明，没有方法体
• 包含抽象方法的类必须是抽象类
• 抽象类不能直接 new 对象
• 子类必须重写所有抽象方法，否则子类也要变成抽象类

抽象方法格式

java

运行

public abstract 返回值 方法名(参数);

---

完整抽象类案例

java

运行

// 抽象类
abstract class Animal {
    // 抽象方法：没有方法体
    public abstract void eat();

    // 普通方法：可以有实现
    public void sleep() {
        System.out.println("动物睡觉");
    }
}

// 子类必须重写抽象方法
class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

---

2. 抽象类核心特点（0.8h）

• 可以有成员变量
• 可以有构造方法（给子类用）
• 可以有普通方法
• 可以没有抽象方法（只是不让别人 new）
• 设计意义：制定规范，强制子类必须实现某些功能

抽象类 = 模板 + 强制约束

---

3. 多态实战案例（1.2h）

需求（实习面试原题）

• 抽象父类：Person，抽象方法 work()
• 子类：Student、Teacher、Doctor
• 测试：多态创建对象、调用方法、强转、instanceof

---

完整代码（可直接运行）

java

运行

// 抽象父类
abstract class Person {
    public abstract void work();
}

// 子类1
class Student extends Person {
    @Override
    public void work() {
        System.out.println("学生学习");
    }

    // 独有方法
    public void studyJava() {
        System.out.println("学生学 Java");
    }
}

// 子类2
class Teacher extends Person {
    @Override
    public void work() {
        System.out.println("老师讲课");
    }

    // 独有方法
    public void teach() {
        System.out.println("老师教 Java");
    }
}

// 子类3
class Doctor extends Person {
    @Override
    public void work() {
        System.out.println("医生治病");
    }
}

// 测试类（多态+强转+instanceof）
public class TestPerson {
    public static void main(String[] args) {
        // 多态数组（企业最常用！）
        Person[] p = {
                new Student(),
                new Teacher(),
                new Doctor()
        };

        // 遍历批量执行
        for (Person person : p) {
            person.work();

            // 判断类型 + 安全强转
            if (person instanceof Student) {
                Student s = (Student) person;
                s.studyJava();
            } else if (person instanceof Teacher) {
                Teacher t = (Teacher) person;
                t.teach();
            }
        }
    }
}

运行结果

plaintext

学生学习
学生学 Java
老师讲课
老师教 Java
医生治病

---

晚上（1.5h）综合练习 + 今日验收

必做实战：图形面积计算（企业高频）

需求

• 抽象类 Graphic
• 抽象方法 getArea()
• 子类：Circle、Rectangle
• 多态数组遍历，求总面积

---

完整代码（最终大综合）

java

运行

// 抽象类
abstract class Graphic {
    public abstract double getArea();
}

// 圆形
class Circle extends Graphic {
    private double r;
    private final double PI = 3.14;

    public Circle(double r) {
        this.r = r;
    }

    @Override
    public double getArea() {
        return PI * r * r;
    }
}

// 矩形
class Rectangle extends Graphic {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public double getArea() {
        return width * height;
    }
}

// 测试：多态数组 + 总面积
public class TestGraphic {
    public static void main(String[] args) {
        // 多态数组
        Graphic[] g = {
                new Circle(2),
                new Rectangle(3, 4),
                new Circle(5)
        };

        // 求总面积
        double sum = 0;
        for (Graphic graphic : g) {
            sum += graphic.getArea();
        }

        System.out.println("总面积：" + sum);
    }
}

运行结果

plaintext

总面积：94.2

---

今日总结（面试必背）

多态

• 3 前提：继承 + 重写 + 父类引用指向子类
• 口诀：编译看左，运行看右
• 向上自动转，向下强制转
• instanceof 判断类型，避免异常

抽象类

• abstract 修饰
• 抽象方法无方法体
• 不能 new
• 子类必须重写抽象方法
• 作用：制定规范、强制实现

企业最常用技能

• 多态数组
• 遍历批量处理
• 安全强转

---

Day13 硬标准（你必须全部做到才算通关）

✅ 能说出多态 3 前提✅ 会写向上 / 向下转型✅ 会用 instanceof✅ 会写抽象类、抽象方法✅ 会写多态数组（企业核心）

总结一下：多态----直接用父类引用统一装所有子类不仅这样更夸张的是 ——可以放进一个数组！多态数组！然后我们就可以用一个循环全部调用。