面向对象的梳理（4）面向对象的特征之多态

最新推荐文章于 2024-10-09 11:13:12 发布

是你的杜哥哥呢

最新推荐文章于 2024-10-09 11:13:12 发布

阅读量58

点赞数

文章标签： java

本文链接：https://blog.csdn.net/m0_62491536/article/details/130952965

版权

文章介绍了Java中的抽象类和多态的概念及应用。通过实例展示了如何创建抽象类及其子类，并利用多态特性进行代码编写。多态允许不同类的对象对同一消息作出不同响应，提高代码的复用性、扩展性和灵活性。文章还详细解释了子类到父类的转换以及父类到子类转换的场景，并提供了相关代码示例。

摘要由CSDN通过智能技术生成

1.前言

（1）抽象类

关于抽象类我们在继承的章节中提过其理论，但并没有在代码中应用。现在我们来写一个实例，要求展示学生作业中的加减乘除四种方法。

（2）抽象类的应用

HomeWork类：

public abstract class HomeWork {
    public abstract void jia();
    public  abstract  void jian();
    public abstract void cheng();
    public abstract void chu();
    public void show(){}
}

abstract   class  A extends  HomeWork{
    public void jia(){
        System.out.println("+++9999");
    }

}

class  B  extends  A{
    @Override
    public void jian() {

    }

    @Override
    public void cheng() {

    }

    @Override
    public void chu() {

    }

}

TestH类：

package com.student.school.java1;

public class TestH {
    public static void main(String[] args) {
        HomeWork homeWork=new B();
        homeWork.jia();
        homeWork.jian();
        homeWork.cheng();
        homeWork.chu();
    }
}

是不是对 HomeWork homeWork=new B();这句话很难理解？不用着急，这其实就是多态的应用，下面让我们来进一步的了解多态吧。

2.多态

（1）什么是多态？

Java中的多态是一种特性，它允许不同类的对象对同一消息做出不同的响应。具体地说，多态可以让一个对象表现出多种形态，使得不同的对象能够用相同的方法来处理相同的消息。这种特性可以通过继承、接口实现、方法重载和方法重写等方式实现。

（2）为什么要使用多态？（多态的优点）

多态具有以下特点：

a. 可复用性：多态可以在不同的上下文中使用相同的代码，减少了代码的重复编写，提高了代码的可复用性。

b. 扩展性：通过对父类进行扩展和抽象，可以增加新的子类，从而扩展和改进原有的功能。

c. 灵活性：多态使得程序在运行时能够动态地选择相应的处理方法，从而增加程序的灵活性。

d. 可维护性：多态提高了代码的可读性和可维护性，因为使用多态的代码更容易理解和修改。

e. 可替代性：多态使得不同的对象能够相互替代，从而增加了程序的可扩展性和可维护性。

（3）怎样实现多态？

a.父类作为形参实现多态

b.父类作为方法的返回值实现多态

2.多态的转换

前面的理论知识就算全背下来了可能对我们写代码都没啥用，可以当成面试题背背，没必要太较真。下面开始我们的多态实例。

（1）子类到父类的转换（子类转换为父类）

其实我们刚刚在抽象类的应用中就是这样，对 HomeWork homeWork=new B();这句话是不是有了初步的理解了呢？

现在我们再来写一个实例，写一个主人带宠物去看病并输出治疗方法。

我们写一个宠物父类Pet，两个宠物子类，一个Dog，一个Pig，一个主人类Master以及一个测试类TestMaster。

具体代码如下：

Pet类：

public abstract class Pet {

    private int age;
    private int health;
    private int love;

    public Pet() {

    }

    public Pet(int age, int health, int love) {
        this.age = age;
        this.health = health;
        this.love = love;
    }

    public int getAge() {
        return age;
    }

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

    public int getHealth() {
        return health;
    }

    public void setHealth(int health) {
        this.health = health;
    }

    public int getLove() {
        return love;
    }

    public void setLove(int love) {
        this.love = love;
    }

    @Override
    public String toString() {
        return "Pet{" +
                "age=" + age +
                ", health=" + health +
                ", love=" + love +
                '}';
    }
    /*在父类中创建了带宠物看病的方法，但是每个宠物看病治疗的方式不同，
     * 所以不能在Pet中  的   goHospital ()方法中写具体的看病方式
     * 所以将该方法变成抽象方法  该方法所在的类变成抽象类
     * */
  public  abstract  void  goHospital();
}

Dog类：

public class Dog extends Pet{
    String kind;

    public Dog() {

    }

    public Dog(String kind) {
        this.kind = kind;
    }

    public String getKind() {
        return kind;
    }

    public void setKind(String kind) {
        this.kind = kind;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "kind='" + kind + '\'' +
                '}';
    }
    //狗狗生病需要去医院
    public void goHospital(){
        System.out.println("狗狗看病打针吃药");
        setHealth(getHealth()+5);
    }
}

Pig类：

public class Pig extends Pet {
    private int weight;

    public Pig() {

    }

    public Pig(int weight) {
        this.weight = weight;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    @Override
    public String toString() {
        return "Pig{" +
                "weight=" + weight +
                '}';
    }
    public void goHospital(){
        System.out.println("猪猪看病见狗就跑");
        setHealth(getHealth()-10);
    }
}

Master类：

public class Master {
public void hospital(Pet pet){
    if (pet.getHealth()<80){
        pet.goHospital();
    }else {
        System.out.println("宠物很健康");
    }
}
public void play(Pet pet){
    if (pet instanceof Dog){
        Dog dog=(Dog) pet;
        dog.playDog();
      //((Dog) pet).playDog();
    }else if (pet instanceof Pig){
       ((Pig) pet).playPig();
    }
}
}

TestMaster类：

public class TestMaster {

    public static void main(String[] args) {
        Master master=new Master();
       // Pet pet=new Pet() ;是错误的
        Pet pet=new Pig();
        //父类被abstract声明时，创建对象：父类 xx=new 子类（）
        pet.setHealth(78);
        master.hospital(pet);//这里调用的是子类的toHospital方法
        System.out.println(pet.getHealth());
    }
}