java继承与多态——多态

已于 2022-08-26 17:14:51 修改
阅读量1.5k 收藏 2
点赞数 2
分类专栏： Java SE零基础入门到进阶 文章标签： java 程序人生 intellij-idea
于 2022-08-25 14:02:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63033419/article/details/126451533
版权

文章目录

1. 多态

1.1 多态的概念

多态就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同 的状态。

例如不同的动物吃的食物不一样。



不同的交通工具速度不一样

1.2 多态的实现条件

要实现多态，必须要满足如下几个条件：

  • 必须在继承体系下
  • 子类必须要对父类中方法进行重写
  • 通过父类的引用调用重写的方法

多态体现：在代码运行时，当传递不同类对象时，会调用对应类中的方法。

class Animals {
    public String name;
    public int age;
    public Animals(String name, int age ) {
        this.name = name;
        this.age = age;
    }
    public void eat() {
        System.out.println(name + "吃饭");
    }
}

class Cat extends Animals{
    public Cat(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println(name + "吃饭");
    }
}

class Dog extends Animals{
    public Dog(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        //与父类的eat方法构成重写
        System.out.println(name + "吃饭");
    }
}

public class Test {
    public static void eat(Animals animals) {
        animals.eat();
    }
    
    public static void main(String[] args) {
        Dog dog = new Dog("大黄", 6);
        Cat cat = new Cat("小黑", 6);
        eat(dog);
        eat(cat);
    }
}




在编写 eat 这个方法的时候, 参数类型为 Animal (父类), 此时在该方法内部并不知道, 也不关注当前的 animals 引用指向的是哪个类型(哪个子类)的实例。此时 animals 这个引用调用 eat方法可能会有多种不同的表现(和 animals 引用的实例相关), 这种行为就称为多态。

1.3 重写

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


【方法重写的规则】

  • 子类在重写父类的方法时，一般必须与父类方法原型一致： 返回值类型、方法名 (参数列表) 要完全一致。
  • 被重写的方法返回值类型可以不同，但是必须是具有父子关系的。
  • 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被public修饰，则子类中重写该方法就不能声明为 protected。
  • 父类被static、private修饰的方法、构造方法都不能被重写。
  • 重写的方法, 可以使用 @Override 注解来显式指定.，有了这个注解能帮我们进行一些合法性校验.。例如不小心将方法名字拼写错了 (比如写成 aet)，那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法构成重写。


【重写与重载的区别】


重写方法名和参数都一样。

class Animals {
    public String name;
    public int age;

    public void eat() {
        System.out.println(name + "吃饭");
    }
    public void sleep() {
        System.out.println(name + "睡觉");
    }
    public void play() {
        System.out.println(name + "做游戏");
    }
}

class Cat extends Animals{
    public Boolean LoveClean;//爱干净

    public void catchMouse() {
        System.out.println(name + "抓老鼠");
    }
    public void eat() {
        System.out.println(name + "吃饭");//与父类的eat方法构成重写
    }
}


重载方法名相同，参数不同。

class Cat{
    public String name = "小黑";
    
    public void catchMouse() {
        System.out.println("抓老鼠");
    }
    public void catchMouse(String name) {//构成重载
        
    }
}


静态绑定： 也称为前期绑定(早绑定)，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。典型代表函数重载。

动态绑定： 也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法。

1.4 向上转型和向下转型

1.4.1 向上转型

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

语法格式：父类类型 对象名 = new 子类类型()

Aniamls animals = new Dog("大黄", 7);

向上转型的使用场景：

  • 直接赋值
  • 方法传参
  • 方法返回
class Animal {
    public String name;
    public int age;
    public Animal(String name, int age ) {
        this.name = name;
        this.age = age;
    }
    public void eat() {
        System.out.println(name + "吃食物");
    }
}

class Cat extends Animals {
    public Cat(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println(name + "吃食物");
    }
}

class Dog extends Animals {
   
    public Dog(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        //与父类的eat方法构成重写
        System.out.println(name + "吃食物");
    }
}

public class TestAniamls {
    // 方法传参：形参为父类型引用，可以接收任意子类的对象
    public static void eat(Animals animals) {
        animals.eat();
    }
    //作返回值：返回任意子类对象
    public static Animals byAnimals(String var) {
        if ("小狗狗".equals(var)) {
            return new Dog("小狗狗", 1);
        } else if ("小猫猫".equals(var)) {
            return new Cat("小猫猫", 1);
        }else {
            return null;
        }
    }
    public static void main(String[] args) {
        //直接赋值：子类对象赋值给父类对象
        Animals cat = new Cat("小黑", 7);
        Dog dog = new Dog("大黄", 6);
        eat(cat);
        eat(dog);

    }
}

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

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

1.4.2 向下转型

将父类引用再还原为子类对象，即向下转型。

向下转型不安全。


因为猫和狗是动物，向上转型安全；但是动物不一定是猫或者狗，所以不安全。

class Animal {
    public String name;
    public int age;
    public Animal(String name, int age ) {
        this.name = name;
        this.age = age;
    }
    public void eat() {
        System.out.println(name + "吃食物");
    }
}

class Cat extends Animal {
    public Cat(String name, int age) {
        super(name, age);
    }
    public void catchMouse() {
        System.out.println(name + "抓老鼠");
    }
    @Override
    public void eat() {
        System.out.println(name + "吃食物");
    }
}

class Dog extends Animal {

    public Dog(String name, int age) {
        super(name, age);
    }
    public void brak() {
        System.out.println(name + "汪汪叫");
    }
    @Override
    public void eat() {
        //与父类的eat方法构成重写
        System.out.println(name + "吃食物");
    }
}

public class TestAnimals {
    public static void main(String[] args) {
        Animal animal = new Cat("小黑", 7);
        Cat cat = (Cat)animal;//向下转型
        cat.catchMouse();
    }
}


Dog类当中没有抓老鼠这一方法，引用的话会报错。

//部分代码
public class TestAnimals {
    public static void main(String[] args) {
        Animal animal = new Dog("大黄", 7);
        Cat cat = (Cat)animal;//向下转型
        cat.catchMouse();
    }
}


如果想要避免运行后报错，可以使用 instanceof关键字。

public class TestAnimals {
    public static void main(String[] args) {
        Animal animal = new Dog("大黄", 7);
        if (animal instanceof Cat) {
            Cat cat = (Cat)animal;//向下转型
            cat.catchMouse();
        }
    }
}


如果反生错误的话会返回一个 flase。

1.5 多态的优缺点


先来看一段代码：

一个用来画三种图形的代码

package demo1;

class Graph {
    public void draw() {
        System.out.println("画图形");
    }
}

class Rectangle extends Graph{
    @Override
    public void draw() {
        System.out.println("画矩形!");
    }
}

class Cycle extends Graph{
    @Override
    public void draw() {
        System.out.println("画圆!");
    }
}

class Triangle extends Graph{
    @Override
    public void draw() {
        System.out.println("画三角形!");
    }
}

public class Test {
    public static void main(String[] args) {
        Graph graph1 = new  Rectangle();
        graph1.draw();
        Graph graph2 = new Cycle();
        graph2.draw();
        Graph graph3 = new Triangle();
        graph3.draw();
    }
}


利用多态来进行优化：

package demo1;


class Graph {
    public void draw() {
        System.out.println("画图形");
    }
}

class Rectangle extends Graph{
    @Override
    public void draw() {
        System.out.println("画矩形!");
    }
}

class Cycle extends Graph{
    @Override
    public void draw() {
        System.out.println("画圆!");
    }
}

class Triangle extends Graph{
    @Override
    public void draw() {
        System.out.println("画三角形!");
    }
}

public class Test {
    public static void drawMap(Graph graph) {
        graph.draw();
    }

    public static void main(String[] args) {
        drawMap(new Rectangle());
        drawMap(new Cycle());
        drawMap(new Triangle());
    }
}

同样的drawMap方法，在做着不同的事情，说明这是一个多态。


多态使代码变得简洁了。

【使用多态的好处】

  1. 能够降低代码的 “圈复杂度”, 避免使用大量的 if - else。
  2. 如果要新增一种新的形状, 使用多态的方式代码改动成本也比较低。

在上面的代码中如果先要实现新的类直接添加就可以了。

//部分代码
class Apple extends Graph{
    public void draw() {
        System.out.println("画苹果!");
    }
}

public class Test {
    public static void drawMap(Graph graph) {
        graph.draw();
    }

    public static void main(String[] args) {
        drawMap(new Rectangle());
        drawMap(new Cycle());
        drawMap(new Triangle());
        drawMap(new Apple());
    }
}



这里可以说明使用多态后，改动也比较方便。

1.6 避免在构造方法中调用重写的方法


先来看一段代码

package demo1;

class B {
    public B() {
// do nothing
        func();
    }
    public void func() {
        System.out.println("B.func()");
    }
}
class D extends B {
    private int num = 1;
    @Override
    public void func() {
        System.out.println("D.func() " + num);
    }
}
public class TestDemo {
    public static void main(String[] args) {
        D d = new D();
    }
}

这段代码也该是会输出 D.func() 1。


但是结果却是：



说明一开始num就没有被初始化为1。

  • 构造 D 对象的同时, 会调用 B 的构造方法。
  • B 的构造方法中调用了 func 方法, 此时会触发动态绑定, 会调用到 D 中的func。
  • 此时 D 对象自身还没有构造, 此时 num 处在未初始化的状态, 值为 0. 如果具备多态性，num的值应该是1。
  • 所以在构造函数内，尽量避免使用实例方法，除了final和private方法。

结论:

“用尽量简单的方式使对象进入可工作状态”, 尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触发动态绑定, 但是此时子类对象还没构造完成), 可能会出现一些隐藏的但是又极难发现的问题

与大师约会
关注
专栏目录
多态的设计与测试-（以图形绘制为例）
listen020的博客
12-13 327
Java多态是指一种能够通过使用相同的方法或接口调用不同的实现的能力。这种能力使得Java程序员能够将代码模块化，并且使得这些模块在被调用时能够根据具体情况自动选择正确的实现。例如，在Java中，多态可以通过让类继承某个抽象类或实现某个接口来实现。这样，一个类可以根据需要实现多个接口或抽象类中的方法，并且这些方法可以在运行时自动选择正确的实现。 图形绘制（GUI程序）：绘制图形分为以下步骤：（1）需要一个画板 （2）需要一个画笔：通过Graphics类实现
Java基础语法——继承与多态——超详解！！！
jing102102的博客
03-22 182
所谓继承类似于修仙小说中的血脉一般，祖辈牛*的大能会在血脉中留存一些“有的没的”作为后辈们的“天赋”，
关于Java的多态，还有令人蛋疼的数值传递
星海君的小窝
11-11 175
【多态写法，需要强制类型转换】 package ToObject.Practice.Duo; /** * 【多态写法，需要强制类型转换】 * 超人谈生意 * 谈生意时，突然有人跳楼 * 于是就过去救人去了 * @author xinha * */ class Person{ String name; Person(String name){ this.name =...
JAVA多态的实现方式
传a奇—学习博客
12-06 2010
多态从实现的角度分为：静态多态和动态多态       静态多态也叫做编译时多态       动态多态也叫做运行时多态   1.静态的多态: 函数重载是静态的多态的一种实现形式: 举例说明： class MethodOverloading { viod receive(int i) { System.out.println("Received one
java 继承与多态作业
万伏小太阳
04-15 834
题意： (程序题)编程模拟图形处理（绘制和计算图形面积）,要求从Shape类派生Circle（圆形）、Rectangle（矩形）、Square（正方形）和Triangle（三角形）四个子类，子类中实现对description属性的初始化，以及draw和area两个方法的实现。图形编号：1代表正方形，2代表矩形，3代表圆形，4代表三角形. 输入格式： 其中第一个数代表图形类别，后面的数代表计算该图形面积所需的值（正方形是边长，矩形是宽和高，圆形是半径，三角形底和高）。4 4 2，代表三角，底为4，高为2
JAVA中继承多态(多态分为编译时多态(也叫静态多态或重载多态)与运行时多态(也叫动态多态或继承多态))存在的三个必要条件
m0_53328194的博客
03-22 650
继承、重写、父类引用指向子类对象。
Java实验报告——类的继承、多态的应用
02-21
在本实验报告中，我们将深入探讨Java编程中的两个核心概念：类的继承和多态的应用。实验主要目标是加深对抽象类和抽象方法的理解，并掌握如何在实际编码中实现类的继承以及多态性。 首先，让我们理解抽象类和抽象...
Educoder题目：Java面向对象 - 封装、继承和多态答案解析.md
11-08
Educoder题目：Java面向对象 - 封装、继承和多态答案解析
继承与多态——实现代码重用
继承与多态简介 ## 1.1 什么是继承 继承是面向对象编程中的一个重要概念，它允许将已有的类作为基础，创建新的类，并在新的类中添加额外的属性和方法，使得新的类能够继承和复用已有类的特性。 在继承关系中，...
Java核心技术：封装、继承与多态——方法覆盖(Override)解析
在Java中，使用`extends`关键字表示继承关系，且Java支持单继承，即一个子类只能有一个直接父类，这有助于避免复杂的继承层次导致的问题。 3. 访问修饰符 Java中的访问修饰符用于控制类、接口、变量和方法的可见性...
【Java】图形类的多态与接口
weixin_52553215的博客
12-16 722
子类 点、线、圆形和矩形；圆形和矩形的面积、周长接口。
面向对象设计——类的继承和多态（包含方法重写，运算符重载）
不吃辣的IT男
06-10 1963
这里写目录标题一、类的继承（1）要点：（2）代码演示：二、类的多继承定义三、方法重写（1）定义：（2）代码：（3）补充： 一、类的继承 （1）要点： 1、在继承关系中，已有的、设计好的的类称为父类或基类，新设计的类称为子类或派生类。 2、派生类可以继承父类的公有成员，但是不能继承其私有成员。 3、在继承中基类的构造函数[init()方法]不会被自动调用，它需要在其派生类的构造中亲自专门调用。 4、如果需要在派生类中调用基类的方法是，通过“基类名。方法名（）”的方式来实现，需要带上基类的类名前缀且需要带上se
Java 继承与多态
qq_55829345的博客
11-14 1647
学会 Java 中的继承与多态，重载和重写又怎么用。
【Java基础】Java的继承和多态
wang_qiu_hao的博客
07-22 9733
接口继承和实现继承的规则不同，一个类只有一个直接父类，但可以实现多个接口。Java接口本身没有任何实现，只描述public行为，因此Java接口比Java抽象类更抽象化。Java接口的方法只能是抽象的和公开的，Java接口不能有构造方法，Java接口可以有public、Static和final属性。接口把方法的特征和方法的实现分隔开来，这种分隔体现在接口常常代表一个角色，它包装与该角色相关的操作和属性，而实现这个接口的类便是扮演这个角色的演员。2.{2.{{提示。............
Java继承与多态(多态篇)
qq_61688804的博客
05-17 2913
🎉🎉🎉写在前面： 博主主页：🌹🌹🌹戳一戳，欢迎大佬指点！ 博主秋秋：QQ：1477649017 欢迎志同道合的朋友一起加油喔💪 目标梦想：进大厂，立志成为一个牛掰的Java程序猿，虽然现在还是一个小菜鸟嘿嘿 -----------------------------谢谢你这么帅气美丽还给我点赞！比个心----------------------------- 多态🌈一，多态概念🌈二，多态的实现条件🌟2.1，向上转型🌟2.2，重写父类方法🌟2.3，通过父类引用调用重写的方法🌟2.4，整体代码🌈三，向..
Java—继承与多态
weixin_48112109的博客
05-27 5253
目录 1、继承 1.1、继承的定义 1.2、继承的使用场景 1.3、构造器 1.4、protected关键字 1.5、谨慎继承 2、多态 2.1、多态的定义 2.2、多态的实现方式 2.2.1、基于继承实现的多态 2.2.2、基于接口实现的多态 1、继承 1.1、继承的定义 继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。通过使用继承我们能够非常方便地复用以前的代码，能够大...
【java】案例：猫与狗 【继承】【多态】
intsum的博客
03-22 2170
package 多态; public class Animals { private String name; private int age; public int agee=9; //get,set方法 public String getName() { return name; } public void setName(String name) { this.name = name; ...
每日总结20230619：多态
最新发布
weixin_43735471的博客
06-19 120
1java多态是什么，具体表现形式有哪几种，
实验三 类的继承与多态的应用
无奈清风吹过的博客
06-16 1092
完成实验报告及源码链接：https://download.csdn.net/download/qq_29711355/856405531、练习类的继承与多态设计过程； 2、练习面向对象的图形用户界面设计、事件设计方法。1、利用多态性编程，创建一个 square 类实现，求三角形、正方形和圆等形状面 积。方法抽象出一个共享父类，定义一个函数为求 square 面积，根据形状共有 特征构建父类及子类继承关系，再重新定义各形状的求面积函数。要求在主类当 中创建不同类的对象，并求不同形状的面积。 2、在第 1 题的
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

与大师约会

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值