java中的多态

爱码驱动

于 2024-07-30 18:44:33 发布

阅读量306

点赞数 5

文章标签： java 开发语言学习

本文链接：https://blog.csdn.net/huangtiandi11/article/details/140768612

版权

一、多态定义

多态是指同一个行为具有不同表现形式或形态的能力。例如：猫和狗都会吃饭，但猫是吃猫粮，狗是吃狗粮，这就是同一个行为，但具有不同的表现形式。

二、多态实现条件

1. 必须在继承体系下

2. 子类必须要对父类中方法进行重写（子类对父类中的某些方法进行重新定义）

3. 通过父类的引用调用重写的方法

三、多态格式

父类类型 变量名=new 子类类型();
变量名.方法名();//调用在子类中重写的方法

例：

//父类
public class Animal {
    String name;
    int age;
    public Animal(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void eat(){
        System.out.println(name+"正在吃饭！！！");
    }
}
//狗类
public class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(name+"正在吃狗粮！！！");
    }
}
//猫类
public class Cat extends Animal{
    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(name+"正在吃猫粮！！！");
    }
}
//
public class Main {
    public static void main(String[] args) {
        Animal dog=new Dog("旺财",3);
        dog.eat();
        Animal cat=new Cat("小黑",2);
        cat.eat();
    }
}

结果如下：

上述代码，dog.eat()和cat.eat()分别是由Dog和Cat这两个实际类型new出来的，因此， dog.eat()调用的是子类Dog中重写的方法，cat.eat()调用的是子类Cat中重写的方法.

四、重写

重写：也称为覆盖。重写是子类对父类非静态、非private修饰，非ﬁnal修饰，非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变。

重写规则：

1.子类在重写父类的方法时，一般必须与父类方法原型一致：返回值类型方法名 (参数列表) 要完全一致

2.被重写的方法返回值类型可以不同，但是必须是具有父子关系的

3.访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被public修饰，则子类中重写该方法就不能声明为 protected

4.父类被static、private修饰的方法、构造方法都不能被重写。

五、重写快捷操作

在子类中右键选择生成

然后选择重写方法

六、向上转型和向下转型

1、向上转型

向上转型：实际就是创建一个子类对象，将其当成父类对象来使用。（儿子变父亲）。

语法格式：

父类类型 对象名 = new 子类类型()

例：

Animal dog=new Dog("旺财",3);

Animal是父类类型，但是可以引用子类对象。

父类是大范围的类型，子类是小范围，所以子类向上转型是自动转换。

向上转型的优点：让代码实现更简单灵活。

向上转型的缺陷：不能调用到子类特有的方法。

2、向下转型

将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转换。

语法格式：

子类类型 对象名=（子类类型） 父类变量名;

例：

//
public class Animal {
    String name;
    int age;
    public Animal(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void eat(){
        System.out.println(name+"正在吃饭！！！");
    }
}
//
public class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(name+"正在吃狗粮！！！");
    }
    public void bark(){
        System.out.println(name+"正在汪汪汪");
    }
}
//
public class Main {
    public static void main(String[] args) {
        Animal dog=new Dog("旺财",3);
        dog.eat();
        Dog dog1=(Dog) dog;//向下转型
        dog1.bark();//调用子类独有的方法
    }
}

结果如下：

向下转型用的比较少，而且不安全，万一转换失败，运行时就会抛异常。Java中为了提高向下转型的安全性，引入了 instanceof ，如果该表达式为true，则可以安全转换。

例：

public class Main {
    public static void main(String[] args) {
        Animal dog=new Dog("旺财",3);
        if(dog instanceof Dog){
            Dog dog1=(Dog) dog;
            dog1.bark();
        }
    }
}

结果如下：