Java多态

最新推荐文章于 2025-06-20 14:41:34 发布

SHHW

最新推荐文章于 2025-06-20 14:41:34 发布

阅读量197

点赞数

CC 4.0 BY-SA版权

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_62352664/article/details/131531999

本文介绍了多态在Java中的概念，包括其前提、体现和成员访问特点。通过动物类（包括猫、狗、大象）的例子，展示了如何利用多态调用子类重写的方法，提高代码的复用性和可维护性。文章还探讨了向上和向下转型的概念，并提供了一个实际的代码示例来说明多态的工作原理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.多态的概述

2.多态的前提和体现

3.多态中成员访问特点

4.多态成员访问特点原因

5.理解

使用多态时，能调用的方法是左边类也就是父类的方法，如果子类没有重写父类方法则执行父类方法中的内容，多态的好处在于对于需要传入父类类型参数的方法来说，继承该父类的子类全都符合该方法的参数要求。对于相同方法内容但不同参数的方法而言多态减少了方法重载的次数。

多态通过父类用子类方法，继承通过子类用父类方法

6.多态的作用（个人理解）

提高代码复用性

派生类的功能可以被基类的方法或引用变量所调用，这叫向后兼容，可以提高可扩充性和可维护性

原理

首先我们要了解的一个知识点是一个方法可以用各种类型的参数来做形参，所以用一个对象来当形参也是可行的。其次根据之前所学的继承我们可以知道一般父类中会存放各个子类都会定义的数据，如年龄和姓名等，而子类中存放子类特有的数据和方法并重写父类的方法，所以在方法形参为父类的情况下，我们是否只需要写一个方法就可以实现调用子类中重写过父类的方法，从而达到一个方法调用不同子类中相同方法

举例

父类：动物类

子类：猫，狗，大象

动物类：参数：姓名，年龄，种类，栖息地

方法：无参构造，有参构造，get和set方法，eat-->喂食方法

猫：构造方法（调用父类的构造方法），重写父类喂食方法-->（输出语句“给猫吃鱼”）

狗：构造方法（调用父类的构造方法），重写父类喂食方法-->（输出语句“给狗吃狗粮”）

大象：构造方法（调用父类的构造方法），重写父类喂食方法-->（输出语句“给大象吃香蕉”）

判断用户输入动物类型并返回的api：Public Animal JudgmentType(String animal){

Animal a；

switch（animal）{

case 猫：

a = new cat;//这里用到的是多态的向下转型

}

//其他的类型我就省略了，大差不差的东西就不写了

Return a；

}

测试类：

接收用户输入的数据

定义一个Animal类型的变量a

调用JudgmentType方法并用a接收，即Animal a = JudgmentType()

//也就是 Animal a = a --> a=new cat 这是上面方法赋的值

此时可以理解为Animal a = new Object -->（Object是JudgmentType返回的方法类型）

再定义一个投喂方法形参为Animal

即public void Feeding（Animal a）{

a.eat()

//我们可以再上面知道a=JudgmentType()也就是说a.eat = JudgmentType().eat

那么JudgmentType()到底是什么呢？其实JudgmentType()就是用户输入的种类转换成由你定义的对象，如果用户输入的是猫，那么a.eat()就等价于cat.eat()，如果是狗，那么a.eat()=dog.eat()

}

由此，我们上面希望实现的一个方法调用多个不同子类中的同名方法已经实现，而实现的前提是有继承关系且有同名方法，那么理论成立，实践开始

Animal.java

package edu.hniu.lzh.day02;

/**
 * @projectName: LearnJava
 * @package: edu.hniu.lzh.day02
 * @className: Animal
 * @author: SHHW
 * @description: TODO
 * @date: 2023/7/4 10:39
 * @version: 1.0
 */
public class Animal {
    public Animal() {
    }

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

    private String name;
    private int age;
    private String kinds;
    private String habitat;

    public void eat(){
        System.out.println("动物要吃东西不然就死");
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", kids='" + kinds + '\'' +
                ", habitat='" + habitat + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public String getKinds() {
        return kinds;
    }

    public void setKids(String kids) {
        this.kinds = kids;
    }

    public String getHabitat() {
        return habitat;
    }

    public void setHabitat(String habitat) {
        this.habitat = habitat;
    }
}

Cat.java

package edu.hniu.lzh.day02;

/**
 * @projectName: LearnJava
 * @package: edu.hniu.lzh.day02
 * @className: Cat
 * @author: SHHW
 * @description: TODO
 * @date: 2023/7/4 10:46
 * @version: 1.0
 */
public class Cat extends Animal{
    public Cat() {
        super();
    }

    public Cat(String name, int age, String kids, String habitat) {
        super(name, age, kids, habitat);
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼或者猫粮");
    }
}

Dog.java

package edu.hniu.lzh.day02;

/**
 * @projectName: LearnJava
 * @package: edu.hniu.lzh.day02
 * @className: Dog
 * @author: SHHW
 * @description: TODO
 * @date: 2023/7/4 10:49
 * @version: 1.0
 */
public class Dog extends Animal{
    public Dog() {
        super();
    }

    public Dog(String name, int age, String kids, String habitat) {
        super(name, age, kids, habitat);
    }

    @Override
    public void eat() {
        System.out.println("狗吃肉或者吃狗粮");
    }
}

elephant.java

package edu.hniu.lzh.day02;

/**
 * @projectName: LearnJava
 * @package: edu.hniu.lzh.day02
 * @className: elephant
 * @author: SHHW
 * @description: TODO
 * @date: 2023/7/4 10:50
 * @version: 1.0
 */
public class elephant extends Animal{
    public elephant() {
        super();
    }

    public elephant(String name, int age, String kids, String habitat) {
        super(name, age, kids, habitat);
    }

    @Override
    public void eat() {
        System.out.println("大象吃香蕉和水果");
    }
}

工具类tool.java

package edu.hniu.lzh.day02;

/**
 * @projectName: LearnJava
 * @package: edu.hniu.lzh.day02
 * @className: tool
 * @author: SHHW
 * @description: TODO
 * @date: 2023/7/4 11:00
 * @version: 1.0
 */
public class tool {
    public static Animal JudgmentTypes(String animal){
        Animal a = null;
        switch (animal){
            case "猫":
                a = new Cat();
                break;
            case "狗":
                a = new Dog();
                break;
            case "大象":
                a = new elephant();
                break;
            default:
                System.out.printf("没有这个类型");
        }
        return a;
    }
}

测试类test

package edu.hniu.lzh.day02;

import java.util.Scanner;

/**
 * @projectName: LearnJava
 * @package: edu.hniu.lzh.day02
 * @className: test
 * @author: SHHW
 * @description: TODO
 * @date: 2023/7/4 10:51
 * @version: 1.0
 */
public class test {
    public static void main(String[] args) {
        System.out.println("请输入你的宠物信息");
        Scanner sc = new Scanner(System.in);
        Animal animal = new Animal();
        System.out.printf("请输入姓名：");
        animal.setName(sc.next());
        System.out.printf("请输入年龄：");
        animal.setAge(Integer.parseInt(sc.next()));
        System.out.printf("请输入种类：");
        String kinds = sc.next();
        animal.setKids(kinds);
        System.out.printf("请输入住址：");
        animal.setHabitat(sc.next());
        Animal a = tool.JudgmentTypes(kinds);
        a.eat();
    }
}

7.向上和向下转型