java多态

本文详细介绍了Java中的多态性,它是面向对象的三大特性之一。多态允许父类引用指向子类对象,实现方法的重写和接口的实现来达到同一接口不同行为的效果。通过实例代码展示了如何通过继承、抽象类和接口来实现多态,强调了向上转型和向下转型的概念,并解释了多态在实际编程中的应用。

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

面向对象特征:抽象、封装、继承、多态

目录

多态:

实现多态的三种方法:

1.方法的重写

2.继承父类

3.实现抽象类、抽方法


多态:

(英语:polymorphism)指为不同数据类型的实体提供统一的接口。                                                Java作为面向对象的语言,同样可以描述一个事物的多种形态。如Student类继承了Person类,一个Student的对象便既是Student,又是Person。

    多态体现为:父类引用变量可以指向子类对象。

     前提条件:必须有继承关系。

    注意:在使用多态后的父类引用变量调用方法时,会调用子类重写后的方法。

实现多态的三种方法:

1.方法的重写

 

 

2.继承父类

public class Father {
}

public class Son extends Father{
}

public class TestSon {
    public static void main(String[] args) {
//        Father father = new Father();
//        Son son = new Son();
        //下面这行就称为多态(父类的引用指向了子类的对象)
        //通俗记忆小的赋值给大的
//         father = son;
         //下面这行称为强制类型转换
//         son = (Son)father;
        //多态的简写形式
        Father father = new Son();
    }
}


public class Grandma extends Object {

}
public class Mom extends Grandma{

}
public class Daughter extends Mom{

}

public class TestDaughter {
    public static void main(String[] args) {
        //把小的赋值给大的称为向上转型
//        Grandma grandma = new Daughter();
        //把小的赋值给大的称为向上转型
//        Mom mom = new Daughter();
        //把大的赋值给小的就称为向下类型转换
//        Daughter daughter = (Daughter) grandma;
        //把大的赋值给小的就称为向下类型转换
//        Daughter daughter2 = (Daughter) mom;
        //向下类型转换之前必须得先向上类型转换
        //如果不向上类型转换,直接向下类型转换会报错
        //ClassCastException类转换异常
//        Daughter daughter = (Daughter) new Grandma();
        //因为Object是最大的类可以接收一切对象
        Object obj = new Grandma();
        Object obj2 = new Mom();
        Object obj3 = new Daughter();
    }
}

3.实现抽象类、抽方法

//定义抽象类
public abstract class Animal {
    public static final String RACE = "动物";
    private String name;
    private Integer age;
    private String sex;
    /**抽象方法*/
    public abstract void sleep(Integer time);
    public abstract String loveFoods(String foods);
    /**普通方法*/
    public void run(){
        System.out.println("跑");
    }
    public void eat(){
        System.out.println("吃");
    }
    /**构造器*/
    public Animal(String name, Integer age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public static String getRACE() {
        return RACE;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}
//定义抽象类子类
public class AnimalImpl extends Animal {
    private String color;
    @Override
    public void sleep(Integer time) {
        System.out.println("睡眠"+time+"小时");
    }

    @Override
    public String loveFoods(String foods) {
        return "喜欢吃"+foods;
    }

    /**
     * 构造器
     *
     * @param name
     * @param age
     * @param sex
     */
    public AnimalImpl(String name, Integer age, String sex,String color) {
        super(name, age, sex);
        this.color=color;
    }
}
//抽类、抽象方法实现多态
public class AnimalImplTest {
    public static void main(String[] args) {
//        匿名对象类
        Animal animal = new Animal("狗",2,"nan") {
            @Override
            public void sleep(Integer time) {

            }

            @Override
            public String loveFoods(String foods) {
                return null;
            }
        };
        Animal animal1 = new AnimalImpl("猫",2,"女", "橘黄色");
        animal.eat();
        animal.run();
        animal1.run();
        animal1.eat();
        animal1.loveFoods("鱼");
        animal.loveFoods("肉");
        String race = Animal.RACE;
        System.out.println(race);
    }

### Java 多态的概念 Java 中的多态是指同一个接口或类可以有多种不同的实现方式。它允许程序在运行时决定调用哪个方法,从而提高代码的灵活性和可扩展性。多态的核心机制依赖于继承、重写以及动态绑定。 #### 动态绑定 当子类覆盖父类的方法时,在运行期间会根据对象的实际类型来决定执行哪一个版本的方法[^1]。这是多态的关键特性之一。 ### 实现多态的方式 Java多态可以通过以下两种主要形式实现: 1. **方法重写(Override)** 2. **接口实现** 以下是具体示例说明如何利用 `instanceof` 运算符避免潜在异常并展示多态的应用场景。 --- ### 示例代码:Java 多态的具体应用 下面是一个完整的例子,展示了如何通过多态性和 `instanceof` 来处理不同类型的对象实例。 ```java // 定义一个基类 Animal class Animal { void makeSound() { System.out.println("Some generic sound"); } } // 子类 Dog 继承自 Animal 并重写了 makeSound 方法 class Dog extends Animal { @Override void makeSound() { System.out.println("Bark"); } // 额外的功能只属于狗 void fetchStick() { System.out.println("Fetching stick..."); } } // 子类 Cat 继承自 Animal 并重写了 makeSound 方法 class Cat extends Animal { @Override void makeSound() { System.out.println("Meow"); } // 额外的功能只属于猫 void climbTree() { System.out.println("Climbing tree..."); } } public class PolymorphismExample { public static void main(String[] args) { // 创建多个动物对象并通过向上转型存储它们 Animal myDog = new Dog(); Animal myCat = new Cat(); // 调用各自的 makeSound 方法 myDog.makeSound(); // 输出 Bark myCat.makeSound(); // 输出 Meow // 如果需要访问特定子类功能,则需使用 instanceof 和强制转换 if (myDog instanceof Dog) { ((Dog) myDog).fetchStick(); // 正确调用了 Dog 类中的特有方法 } if (myCat instanceof Cat) { ((Cat) myCat).climbTree(); // 正确调用了 Cat 类中的特有方法 } Object cValue = 42; // 假设我们有一个未知类型的变量 // 判断其实际类型并打印相应消息 System.out.println("The type of value is " + (cValue instanceof Double ? "Double" : (cValue instanceof Integer ? "Integer" : "Unknown"))); // 输出 Integer [^2] } } ``` 上述代码片段中: - 我们定义了一个通用的 `Animal` 类作为超类。 - 然后创建两个派生类 `Dog` 和 `Cat`,分别实现了自己的行为逻辑。 - 在主函数里演示了即使将这些对象赋给更广泛的父类引用 (`Animal`),仍然能够正确表现出各自的行为特征——这就是所谓的“编译看声明类型, 执行找真实类型”。 另外还加入了关于 `instanceof` 关键字使用的部分,用于确认某个对象的确切类别以便安全地进行向下造型操作而不会引发 ClassCastException 错误。 --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值