AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

多态语法详解

2023-11-24 60
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 多态语法详解

一：概念

1：同一个引用，调用了同一个方法，因为引用的对象不一样，所表现出来的行为也不一样。

1：多态实现条件

1：必须在继承体系下；

2：子类必须对父类中的方法进行重写；

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

二:重写：

重写也称覆盖。重写是子类对父类非静态，非private,非final修饰，非构造方法等的实现过程进行重新编写。

重写规则

1:方法名，参数列表（参数类型，个数，顺序），返回类型都要相同，（返回类型可以构成父子类关系）。

2：子类重写父类同名的方法时，子类方法的访问权限要大于父类的。

3：当在父类的构造方法中，调用了子类和父类同名的方法时，此时会调用子类的方法。

提醒： 不要在构造方法中调用重写的方法。

class Person{
    public String name;
    public int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        fun();
    }
    public void fun(){
        System.out.println("父类的fun()方法");
    }
}
class Student extends Person{
    public Student(String name, int age) {
        super(name, age);
    }
    public void fun(){
        System.out.println("子类的fun()方法");
    }
}
public class Test {
    public static void main(String[] args) {
        Student student=new Student("张三",20);
    }
}


4：父类方法被static ,final,private修饰不能重写

三：向上转型和向下转型

1:向上转型：

子类对象给到了父类对象，也可以理解为：父类引用引用的是子类对象，通过父类的引用去调用父类和子类同名的方法，不过调用的是子类的方法。（也叫作动态绑定）

1：直接赋值：

class Animal{
    private String name;
    private int age;
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    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 void eat(){
        System.out.println(this.age+"在吃饭");
    }
}
class Dog extends Animal{
    public Dog(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println(this.getName()+"吃狗粮");
    }
}
public class Test {
    public static void main(String[] args) {
        Animal animal=new Dog("旺财",3);//父类引用引用了子类对象
        animal.eat();//通过父类引用访问了和父类同名的子类方法，
    }
}

2：方法传参

class Animal{
    private String name;
    private int age;
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    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 void eat(){
        System.out.println(this.age+"在吃饭");
    }
}
class Dog extends Animal{
    public Dog(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println(this.getName()+"吃狗粮");
    }
}
class Cat extends Animal{
    public Cat(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println(this.getName()+"吃猫粮");
    }
}
public class Test {
    public static void fun(Animal animal){
        animal.eat();//同一个引用，引用了同一个方法，因为引用的对象不一样，所表现出来的行为不一样，我们把这种思想叫做多态
    }
    public static void main(String[] args) {
      Dog dog=new Dog("旺财",3);
      fun(dog);
      fun(new Cat("喵喵",2));
    }
}

3：返回值

作返回值，返回任意子类对象

class Animal{
    private String name;
    private int age;
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    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 void eat(){
        System.out.println(this.age+"在吃饭");
    }
}
class Dog extends Animal{
    public Dog(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println(this.getName()+"吃狗粮");
    }
}
class Cat extends Animal{
    public Cat(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println(this.getName()+"吃猫粮");
    }
}
public class Test {
    public static Animal fun(){
        return new Dog("旺财",3);
    }
    public static void main(String[] args) {
      Animal animal=fun();
      animal.eat();
    }
}

2:向下转型

将一个子类对象经过向上转型后当成父类方法使用，再也无法调用子类特有的方法，

class Animal{
    private String name;
    private int age;
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    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 void eat(){
        System.out.println(this.age+"在吃饭");
    }
}
class Dog extends Animal{
    public Dog(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println(this.getName()+"吃狗粮");
    }
}
class Cat extends Animal{
    public Cat(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println(this.getName()+"吃猫粮");
    }
    public void barks(){
        System.out.println(this.getName()+"摇尾巴");
    }
}
public class Test {
    public static void main(String[] args) {
     Animal animal =new Dog("旺财",3);
     animal.barks();
    }
}

但有时需要调用子类特有的方法，此时:将父类引用在还原为子类对象，也就是向下转型。

class Animal{
    private String name;
    private int age;
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    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 void eat(){
        System.out.println(this.age+"在吃饭");
    }
}
class Dog extends Animal{
    public Dog(String name, int age) {
        super(name, age);
    }
    public void barks(){
        System.out.println(this.getName()+"摇尾巴");
    }
    @Override
    public void eat() {
        System.out.println(this.getName()+"吃狗粮");
    }
}
class Cat extends Animal{
    public Cat(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println(this.getName()+"吃猫粮");
    }
}
public class Test {
    public static void main(String[] args) {
        Dog dog=new Dog("旺财" ,2);
        Animal animal =dog;
        dog=**(Dog)** animal;
        dog.barks();
    }
}


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

class Animal{
    private String name;
    private int age;
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    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 void eat(){
        System.out.println(this.age+"在吃饭");
    }
}
class Dog extends Animal{
    public Dog(String name, int age) {
        super(name, age);
    }
    public void barks(){
        System.out.println(this.getName()+"摇尾巴");
    }
    @Override
    public void eat() {
        System.out.println(this.getName()+"吃狗粮");
    }
}
class Cat extends Animal{
    public Cat(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println(this.getName()+"吃猫粮");
    }
}
public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog("旺财", 3);
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
             ((Dog) animal).barks();
        }
    }
}

文章标签：
Java
安全
十一..
目录
相关文章
糖果罐子
|
安全 编译器 C++
C++ 多态深入解析
C++ 多态深入解析
糖果罐子
83 0
那年春天
|
2月前
多态和动态绑定的区别是什么？
【10月更文挑战第14天】多态和动态绑定是面向对象编程中两个重要的概念，但它们有着不同的含义和作用。
那年春天
27 2
筱姌
|
6月前
多态的具体用法
多态的具体用法
筱姌
36 1
十一..
继承语法详解
继承语法详解
十一..
69 0
日星月云
多态性的使用举例
多态性的使用举例
日星月云
48 0
结构体
|
存储 Java 开发者
1.1 Lambda表达式的基础：Lambda表达式的定义与语法
1.1 Lambda表达式的基础：Lambda表达式的定义与语法
结构体
127 0
赛男丨木子丿小喵
多态在代码中的体现
多态在代码中的体现
赛男丨木子丿小喵
73 0
Bc_小徐
|
Java
Java语法之多态
上次给大家分享了Java的继承，今天小编给大家分享面向对象三大特性的第三大特性，也就是多态，fighting~~
Bc_小徐
84 0
Java语法之多态
头发够用的程序员
|
编译器 C++
多态（C++语言实现）
多态（C++语言实现）
头发够用的程序员
88 0
游客got4yp2fez3cw
|
C++
动态绑定，多态（带你从本质了解多态）（下）
动态绑定，多态（带你从本质了解多态）
游客got4yp2fez3cw
78 0

热门文章

最新文章

  • 1
    Hadoop迁移MaxCompute神器之DataX-On-Hadoop使用指南
  • 2
    如何生成和使用 SDK | 学习笔记
  • 3
    机器人现身日本竞选市长，承诺公平对待每一个人
  • 4
    Java Servlet Cookie 详解
  • 5
    我的家庭私有云计划-17
  • 6
    自媒体平台资讯03：邦阅号自媒体，一个定位于分享外贸经验的自媒体平台
  • 7
    树的遍历与图的遍历
  • 8
    Ganglia + Nagios 初步实践
  • 9
    clone错误——执行txkExecSetJaznCredentials.pl失败
  • 10
    并发操作的一致性问题 (2)
  • 1
    java日常开发中如何写出优雅的好维护的代码
    33
  • 2
    Hologres 索引：概念与实用场景
    28
  • 3
    《C 语言助力数据降维：开启 AI 算法优化之门》
    23
  • 4
    《C 语言赋能蚁群算法：革新网络路由优化之路》
    27
  • 5
    《C 语言与 R 语言在人工智能数据分析中的交融之路》
    22
  • 6
    《Java 与 C 语言在人工智能领域的交互协同之道》
    23
  • 7
    《C 语言携手 PaddlePaddle C++ API：开启深度学习开发新征程》
    23
  • 8
    二进制安装Kubernetes（k8s）v1.32.0
    45
  • 9
    云服务测评 | 基于云服务诊断全方位监管云产品
    316
  • 10
    jQuery Lightbox和弹出层插件flashy
    23

    • 相关课程

    更多
  • Python语言基础 - 函数、面向对象、异常处理

    • 相关电子书

    更多
  • 继承与功能组合
  • 低代码开发师（初级）实战教程
  • 阿里巴巴DevOps 最佳实践手册

    • 相关实验场景

    更多
  • 面向对象-1：类的定义
  • 对象和接口-2：常见用法
  • 函数类型-3：函数重载
  • 函数类型-1：基本语法
    • 下一篇
    阿里云对象存储OSS收费标准：存储、流量和请求等多个计费项详解