JavaSE（八）多态&抽象类

最新推荐文章于 2025-12-11 22:46:37 发布

原创最新推荐文章于 2025-12-11 22:46:37 发布 · 117 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #前端 #算法

JavaSE 专栏收录该内容

21 篇文章

订阅专栏

本文通过Java代码示例介绍了抽象类、多态的概念，展示了如何创建父类模板、子类继承以及向上和向下转型的应用，强调了面向对象设计中的开闭原则。

类：一组事物相同的特征（有什么属性成员变量）和行为（功能方法）的抽象类是一个模板

父类：一组子类相同特征和行为的抽象父类是子类的模板

多态

多态的使用是为了解决程序扩展问题
多态概念：在运行过程根据实际对象去调用其所对应的方法
体现多态的条件：继承重写父类引用指向子类对象

1，多态基本使用

动物类

public class Animal {
    private int age;
    private String name;

    public Animal() {
    }

    public Animal(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public void play() {
        System.out.println("动物在表演");
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

子类1

public class Monkey extends Animal {
    public Monkey() {
    }

    public Monkey(int age, String name) {
        super(age, name);
    }

    @Override
    public void play() {
        System.out.println("猴子表演骑单车");
    }
}

子类2

public class Elephant extends Animal {
    public Elephant() {
    }

    public Elephant(int age, String name) {
        super(age, name);
    }

    @Override
    public void play() {
        System.out.println("大象会表演喷水");
    }
}

马戏团

/**
 * 马戏团 Circus 有一批动物表演节目，提供表演功能 performance() 如果上台的是猴子 就让猴子表演他的技能
 * 猴子 表演骑单车  年龄 名称
 * 大象 表演喷水   年龄 名称
 * 狮子 表演跳火圈  年龄 名称
 * <p>
 * 程序扩展问题 功能新增
 * 老虎 表演吃人 年龄 名称
 * 1，新建一个Tiger类 继承Animal play重写
 * 2，改动Circus源码，
 * 七大设计原则：开闭原则 ：对新增开放 对修改关闭
 */
//马戏团
public class Circus {
    public void performance(Animal animal) {
        //多态： 在运行过程 根据实际对象去调用其所对应的方法
        //多态体现的条件：继承 重写 父类引用指向子类对象
        animal.play();
    }
}

测试类

 /**
     * 多态的使用案例
     */
    private static void method1() {
        Circus circus = new Circus();
        Monkey monkey = new Monkey();
        Elephant elephant = new Elephant();
        Lion lion = new Lion();
        Animal tiger = new Tiger();
        //新语法： 父类引用 可以指向子类对象的；
        Animal animal = new Monkey();
        circus.performance(tiger);
//        circus.performance(tiger);
    }

2，向上转型

父类引用指向子类对象（也称之为向上转型）
注意点：父类引用可以指向子类对象但是父类引用不能调用子类中新增的成员

 /**
     * 注意点：父类引用可以指向子类对象 但是父类引用不能调用子类中新增的成员
     */
    private static void method2() {
        //父类引用 指向子类对象 （向上转型）
        Animal animal = new Monkey();
        Object obj = new Monkey();
        //父类引用可以指向子类对象 但是父类引用不能调用子类中新增的成员
//        obj.play();
        animal.play();
//        animal.jump();
    }

3，向上转型结合数组的使用

public static void method3() {
        Animal[] animals = new Animal[3];
        //不能调用null 的任何成员;一旦调用 会报空指针异常
        // System.out.println(animals.length);
        //向上转型
        /*Animal animal1 = new Monkey();
        animals[0] = animal1;*/
        animals[0] = new Monkey();
        animals[1] = new Elephant();
        animals[2] = new Lion();
        for (Animal a : animals) {
            a.play();
        }
        Object[] objects = new Object[3];
        objects[0] = new Monkey();
        objects[1] = new Elephant();
        objects[2] = new Tiger();
    }

private static void method4() {
        Animal[] animals = new Animal[3];
        animals[0] = new Monkey();
        animals[1] = new Elephant();
        animals[2] = new Lion();

        //取数组元素 向上转型
        Animal animal1 = animals[0];
        //实际对象对应的方法
        animal1.play();
    }

4，向下转型

/**
     * 向下转型
     */
    private static void method5() {
        //向上转型   float f = 10L;
        Animal animal = new Monkey();
        animal.play();

        //animal指向的对象是猴子类型的（或者是其子类型的对象）对象结果 为true ；否则为false
        if (animal instanceof Monkey) {
            //向下转型  int i = (int)10L;
            Monkey monkey = (Monkey) animal;
            monkey.jump();
        }
    }

抽象类

abstract关键字修饰类表示这个类就是抽象类
- 抽象类不能有对象抽象类被设计出来就是用来被继承的;
abstract关键字修饰方法表示是抽象方法抽象方法不能有方法体；
- 抽象方法被设计出来就是用来被重写的
注意点：一个包含抽象方法的类必须声明为抽象类；

//父类   只是作为 一组子类 模板
// 不应该有实例（对象） 被设计出来就是用来被继承的
//abstract关键字修饰类 表示这个类就是抽象类，抽象类不能有对象  抽象类被设计出来就是用来被继承的;
//注意点： 一个包含抽象方法的类必须声明为抽象类；
public abstract class Animal {
    private int age;
    private String name;

    public Animal() {
    }

    public Animal(int age, String name) {
        this.age = age;
        this.name = name;
    }

    //抽象方法 不能有方法体；抽象方法被设计出来就是用来被重写的
    public abstract void play();

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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