多态（java）

Pennywise.

已于 2022-12-10 21:01:27 修改

阅读量1.8k

点赞数 1

分类专栏： javaSE 文章标签： java 开发语言 jvm

于 2022-12-10 21:01:06 首次发布

本文链接：https://blog.csdn.net/qq_52134698/article/details/128268274

版权

javaSE 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

一什么是多态

多态是指当父类引用引用的对象不一样的时候表现出的行为是不一样的

二多态实现条件

必须在继承体系下

子类必须要对父类中的方法进行重写

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

以下是多态的一段代码

//父类
class animals{
    String name;
    int age;
    public void eat(){
    }
}

//子类
class dogs extends animals{

    public dogs(String name,int age){
        super.name = name;
        super.age = age;
    }
    //和父类一样的方法
    @Override
    public void eat(){
        System.out.println(name + "正在吃狗粮");
    }
}


class cats extends animals{
    public cats(String name,int age){
        super.name = name;
        super.age = age;
    }
    //和父类一样的方法
    @Override
    public void eat(){
        System.out.println(name + "正在吃猫粮");
    }
}

public class Main {

    public static void main(String[] args){
        //前面给的类型是父类后面却实例化子类的对象
        animals animal = new dogs("小黄",10);
        animal.eat();
        animal = new cats("小喵",4);
        animal.eat();
    }
}

结果：

1.必须在继承体系下

这个就是在所谓的继承体系下

2.子类必须要对父类中的方法进行重写

这里我们要先介绍一下是什么是重写

重写有三个条件：

和父类方法名称相同

和父类方法参数列表相同

和父类方法返回值相同

我们可以用@Override来检查这个方法是否为重写方法

注意;

1.private修饰的方法不能被重写

2.static修饰的方法不能被重写

3.子类的访问修饰限定权限要大于等于父类的权限

private < default < protected < public

4.被final修饰的方法不能被重写

此时这个方法被称作密封方法

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

然后就会出现所谓的多态运行：

三向上转型和向下转型

向上转型

当我们前面给的是父类类型后面却实例化子类的对象的时候就被称作向上转型：

public class Main {

    public static void main(String[] args){
        //前面给的类型是父类后面却实例化子类的对象
        animals animal = new dogs("小黄",10);
        animal.eat();
        animal = new cats("小喵",4);
        animal.eat();
    }
}

这种时候它只能访问父类自己的对象和子类的重载方法

向上转型的三种使用方法：

上面那种就是第一种使用方法

第二种:

public class Main {
    public static void fun(animals animal){
        animal.eat();
    }
    
    public static void main(String[] args){
        dogs dog = new dogs("小黄",10);
        cats cat = new cats("小喵",5);
        fun(dog);
        fun(cat);
        
    }
}

第三种：

public class Main {
    public static animals fun(int n){
        if(n == 0){
            return new dogs("小黄",12);
        }else{
            return new cats("小喵",5);
        }
    }

    public static void main(String[] args){
        dogs dog = new dogs("小黄",10);
        cats cat = new cats("小喵",5);
        fun(0).eat();
        fun(1).eat();

    }
}

向下转型

public class Main {

    public static void main(String[] args){
        animals animal = new dogs();
        if(animal instanceof dogs){
            dogs dog = (dogs)animal;
            dog.name = "小黄";
            dog.eat();
        }
    }
}

由于这种方法比较蠢而且有一定的风险所以不怎么使用

注：

instanceof是一种关键字，用来检测animal是否引用了dogs对象