「MoreThanJava」Day 6:面向对象进阶——多态

时间:2021-08-09 21:54:02

「MoreThanJava」Day 6:面向对象进阶——多态

  • 「MoreThanJava」 宣扬的是 「学习,不止 CODE」,本系列 Java 基础教程是自己在结合各方面的知识之后,对 Java 基础的一个总回顾,旨在 「帮助新朋友快速高质量的学习」
  • 当然 不论新老朋友 我相信您都可以 从中获益。如果觉得 「不错」 的朋友,欢迎 「关注 + 留言 + 分享」,文末有完整的获取链接,您的支持是我前进的最大的动力!

Part 1. 多态概述

多态,简而言之就是 同一个行为 具有 多个不同表现形式 或形态的能力。在面向对象的程序设计中,多态的能力是通过数据抽象和继承之后得来的

「MoreThanJava」Day 6:面向对象进阶——多态

比如,有一杯水,我不知道它是温的、冰的还是烫的,但是我一摸我就知道了,我摸水杯的这个动作 (方法),对于不同温度的水 (运行时不同的对象类型),就会得到不同的结果,这就是多态。

代码演示:

// 基类定义
public class Water {
public void showTem() { }
}
// 冰水
public class IceWater extends Water { @Override
public void showTem() { System.out.println("我的温度是: 0度"); }
}
// 温水
public class WarmWater extends Water {
@Override
public void showTem() { System.out.println("我的温度是: 40度"); }
}
// 开水
public class HotWater extends Water {
@Override
public void showTem() { System.out.println("我的温度是: 100度"); }
}
// 测试类
public class TestWater {
public static void main(String[] args) {
Water w = new WarmWater();
w.showTem(); w = new IceWater();
w.showTem(); w = new HotWater();
w.showTem();
}
}

结果输出:

我的温度是: 40度
我的温度是: 0度
我的温度是: 100度

这里的方法 showTem() 就相当于你去摸水杯。我们定义的 Water 类型的引用变量 w 就相当于水杯,你在水杯里放了什么温度的水,那么我摸出来的感觉就是什么。就像代码中的那样,放置不同温度的水,得到的温度也就不同,但水杯是同一个。

里氏替换原则(LSP)

面向对象的设计原则有一条关于多态的原则,它的描述大概是这样子的:子类对象 (object of subtype/derived class) 能够 替换 程序 (program)父类对象 (object of base/parent class) 出现的 任何地方,并且 保证原来程序的逻辑行为 (behavior) 不变及正确性不被破坏

这么说可能有点抽象,简单说就是 子类和父类的行为应该保持一致

哪些代码明显违背了 LSP?

实际上,里式替换原则还有另外一个更加能落地、更有指导意义的描述,那就是 “Design By Contract”,中文翻译就是 “按照协议来设计”。定义中父类和子类之间的关系,也可以替换成接口和实现类之间的关系。

为了更好地理解这句话,我举几个违反里式替换原则的例子来解释一下。

1 - 子类违背父类声明要实现的功能

父类中提供的 sortOrdersByAmount() 订单排序函数,是按照金额从小到大来给订单排序的,而子类重写这个 sortOrdersByAmount() 订单排序函数之后,是按照创建日期来给订单排序的。那子类的设计就违背里式替换原则。

2 - 子类违背父类对输入、输出、异常的约定

在父类中,某个函数约定:运行出错的时候返回 null;获取数据为空的时候返回空集合(empty collection)。而子类重载函数之后,实现变了,运行出错返回异常(exception),获取不到数据返回 null。那子类的设计就违背里式替换原则。

3 - 子类违背父类注释中所罗列的任何特殊说明

父类中定义的 withdraw() 提现函数的注释是这么写的:“用户的提现金额不得超过账户余额……”,而子类重写 withdraw() 函数之后,针对 VIP 账号实现了透支提现的功能,也就是提现金额可以大于账户余额,那这个子类的设计也是不符合里式替换原则的。

当然,当前的大环境下,注释的可信度还是得斟酌斟酌.. (不可尽信..)

Part 2. 向上转型 && 向下转型

再谈向上转型

上一篇文章 里面我们已经谈到 —— 对象既可以作为它本身的类型使用,也可以作为它基类的类型使用。而这种把对某个对象的引用视为其基类型的引用的做法被称为 向上转型 (因为在继承树的画法中,基类位于子类上方)

语句 Water w = new WarmWater(); 就是向上转型的典型代码,这会将子类类型 WarmWater 转成父类的 Water 类型。

存在问题

❶ 向上转型时,子类单独定义的方法会丢失。

例如,我们如果在温水中定义一个喝水的方法 drink(),那么当 w 引用指向 WarmWater 类实例的时候是访问不到 drink() 方法的,w.drink() 会报错。

❷ 子类引用不能指向父类对象。

HotWater hotWater = (HotWater)new Water(); 这样是不行的。

向上转型的好处

  • 减少重复代码,提高代码可读性;
  • 提高系统扩展性;

举个例子,比如我现在有许多不同温度的水,如果不用向上转型,摸水杯这个动作我需要这样写:

// Water 类中方法定义
public void showTem(IceWater water) { water.showTem(); }
public void showTem(WarmWater water) { water.showTem(); }
public void showTem(HotWater water) { water.showTem(); }
// 测试类中调用
water.showTem(new IceWater());
water.showTem(new WarmWater());
water.showTem(new HotWater());

每一种不同温度的水我都需要在 Water 中单独定义一个方法 (因为都是不同的类型),数量一多,就会变得非常冗余和复杂。

但使用向上转型,一切就轻松多了:

// Water 类中方法定义
public void showTem(Water water) { water.showTem(); }
// 测试类中调用
water.showTem(new IceWater());
water.showTem(new WarmWater());
water.showTem(new HotWater());

就算新添加一种温度的水,我也只需要继承 Water 实现 showTem() 方法就行了,原有的代码几乎不需要修改。这也体现了软件设计原则中重要的 开闭原则 —— 对扩展开放,对修改封闭。

向下转型

与向上转型相对应的就是向下转型了 —— 也就是把父类对象转为子类对象。(这有大坑...)

还是用上面的摸水杯的例子来说明,我们先在温水 WarmWater 中加入一个喝水的方法:

public class WarmWater extends Water {
@Override
public void showTem() { System.out.println("我的温度是: 40度"); }
// 新增加的喝水的方法
public void drink() { System.out.println("喝水..."); }
}

示例代码:

class Tester {
public static void main(String[] args) {
Water water = new WarmWater();// 子类实例赋给父类引用 - 向上转型
WarmWater warmWater = (WarmWater) water;// Water向下转型为WarmWater
warmWater.drink(); IceWater iceWater = (IceWater) water;// Water向下转型为IceWater
iceWater.drink();// IDE 提示无法找到 drink() 方法
}
}

为什么第一段代码不报错呢?因为 water 本身就是 WarmWater 类型的对象,所以它理所当然的可以向下转型为 WarmWater 类型了,也理所当然的不能转型为 IceWater,这就好像你见过 一条狗突然变成一只猫 的情况吗?

再来看下列代码:

class Tester {
public static void main(String[] args) {
Water water = new Water();
WarmWater warmWater = (WarmWater) water;
// 下列代码报错:java.lang.ClassCastException: class Water cannot be cast to class WarmWater
warmWater.drink();
}
}

上面例子想要说明的是,Water 类型的对象 (父类型) 不能向下转型为任何类型的对象。这就好像你去考古,你发现了一个新生物,你知道它是一种动物,但你不能直接说它是猫或者狗...

向下转型注意事项

  • 向下转型的前提是父类对象指向的是子类对象;(也就是对应上面实例代码中向下转型 WarmWater 的情况.. new WarmWater() 首先得完成向上的转型..)
  • 向下转型只能转型为本类对象;(猫是不能变成狗的.. 对应上方 WamWater 类型就不能转成 IceWarm 类型的情况)

向下转型的意义

有的小伙伴可能看到这里有点懵了.. 向下转型需要先向上转型,这转来转去好玩儿是吗?

「MoreThanJava」Day 6:面向对象进阶——多态

向上转型让我们有了统一处理一类抽象事物的能力,这大大减少了我们的重复代码,并增加了我们代码的可扩展性。可事实上是,尽管我们尽力抽象一类事物,让他们尽可能地保证行为的统一,但总有例外!(就像 上一次 我们讨论继承时提到的鸟类的例子,并不是所有鸟都能飞或者叫!)

所以当例外来临时,我们就可以及时判断并做对应的处理。(这也比较符合现实的情况)

最典型的例子就是 JDK 中的某一些集合类,对于集合类来说,并不需要记住存储所有存储对象的类型,而是统一抽象成了 Node 类型,就拿 HashMap 来说吧,存储一个元素 (putVal() 方法) 时就要判定当前节点时属于链表还是红黑树的部分:

「MoreThanJava」Day 6:面向对象进阶——多态

Part 3. 多态经典案例分析

我们来看一个经典的例子:

// A 类
public class A {
public String show(D object) { return "A and D"; }
public String show(A object) { return "A and A"; }
}
// B 类
public class B extends A {
public String show(B object) { return "B and B"; }
@Override
public String show(A object) { return "B and A"; }
}
// C 类
public class C extends B{ }
// D 类
public class D extends B{ }

测试类:

public class Tester {

    public static void main(String[] args) {
A a = new A();
A aRefB = new B();
B b = new B();
C c = new C();
D d = new D(); System.out.println("1-" + a.show(b));
System.out.println("2-" + a.show(c));
System.out.println("3-" + a.show(d)); System.out.println("4-" + aRefB.show(b));
System.out.println("5-" + aRefB.show(c));
System.out.println("6-" + aRefB.show(d)); System.out.println("7-" + b.show(b));
System.out.println("8-" + b.show(c));
System.out.println("9-" + b.show(d));
}
}

输出结果:

1-A and A
2-A and A
3-A and D
4-B and A
5-B and A
6-A and D
7-B and B
8-B and B
9-A and D

前三个比较容易,因为 B、C 都本质上是 A 类,所以 12 都进入了 A 类中签名为 show(A) 的方法。

但是第四个非常奇怪,A 对象类型引用了一个 B 类型的实例,输出是 B and A,而不是想象中的 B and B,为什么呢?

这里有一个新知识点:决定调用哪个方法的是引用变量类型

拿这里的 aRefB.show(b) 来说好了,aRefB 虽然是 A 类型的引用,但首先会查找 B 对象中的方法 (因为它实际的指向是 B),而引用 b 正好是一个 B 类型 (实质上是 is-a A 类型),所以符合 B 对象中签名为 show(A) 的方法,就输出了 B and A。如果 B 类型中没有符合签名的方法,那么会从父类中查找,继续这个过程直到找到或者报错。

如果你能理解这个过程,并分析其他的情况,那么说明你真的掌握了。

再来分析 b.show(d) 输出 A and D 的情况,就简单很多了:B 对象中不存在 show(D) 这样的签名,所以从父类 A 中查找,故输出了 A and D

要点回顾

  1. 多态概述 / 里氏替换原则 / 向上向下转型;
  2. 典型多态案例分析 / 练习;

练习

练习 1:工资结算系统

某公司有三种类型的员工,分别是部门经理、程序员和销售员。需要设计一个工资结算系统,根据提供的员工信息来计算月薪。

部门经理的月薪是每月固定 15000 元;

程序员的月薪按每月工作时间计算,每小时 150 元;

销售员的月薪是 1200 底薪加上销售额 5% 的提成;

抽象员工类:

public abstract class AbstractEmployee {
private String name; public AbstractEmployee(String name) {
this.name = name;
} // 获取工资
public abstract double getSalary();
public String getName() { return name; }
public void setName(String name) { this.name = name; }
}

项目经理类:

public class Manager extends AbstractEmployee {
public Manager(String name) {
super(name);
} @Override
public double getSalary() { return 15000; }
}

程序员类:

public class Programer extends AbstractEmployee {
private Integer workHours; public Programer(String name, Integer workHours) {
super(name);
this.workHours = workHours;
} // 仅提供单独的 set 方法,工作时间理论上来说是一个私人的消息..
public void setWorkHours(Integer workHours) {
this.workHours = workHours;
}
@Override
public double getSalary() { return 150 * workHours; }
}

销售员类:

public class Salesman extends AbstractEmployee {
private Integer salesAmount; public Salesman(String name, Integer salesAmount) {
super(name);
this.salesAmount = salesAmount;
} // 也仅提供 set 方法,并不是所有人都能访问销售人员的销售金额
public void setSalesAmount(Integer salesAmount) {
this.salesAmount = salesAmount;
}
@Override
public double getSalary() { return 1200 + 0.05 * salesAmount; }
}

测试类:

import java.util.List;

public class Tester {
public static void main(String[] args) {
// 项目经理张三、996程序员李四、月销售过万的明星销售员王五
List<AbstractEmployee> employees = List
.of(new Manager("张三"), new Programer("李四", (21 - 9) * 6), new Salesman("王五", 10000)); // 发工资..
for (AbstractEmployee employee : employees) {
System.out.println(employee.getName() + "工资为:" + employee.getSalary());
}
}
}

程序输出:

张三工资为:15000.0
李四工资为:10800.0
王五工资为:1700.0

(ps:有感受到来自于现实主义的正义光辉洒在你的身上吗?)

参考资料

  1. 《Java 核心技术 卷 I》
  2. 《Java 编程思想》
  3. Introduction to Computer Science using Java - http://programmedlessons.org/Java9/index.html
  4. 重新认识java(五) ---- 面向对象之多态(向上转型与向下转型) - https://blog.csdn.net/qq_31655965/article/details/54746235
  5. 极客时间 | 设计模式之美 - https://time.geekbang.org/column/article/177110
  6. Python 100 天从新手到大师 - https://github.com/jackfrued/Python-100-Days
  • 本文已收录至我的 Github 程序员成长系列 【More Than Java】,学习,不止 Code,欢迎 star:https://github.com/wmyskxz/MoreThanJava
  • 个人公众号 :wmyskxz,个人独立域名博客:wmyskxz.com,坚持原创输出,下方扫码关注,2020,与您共同成长!

「MoreThanJava」Day 6:面向对象进阶——多态

非常感谢各位人才能 看到这里,如果觉得本篇文章写得不错,觉得 「我没有三颗心脏」有点东西 的话,求点赞,求关注,求分享,求留言!

创作不易,各位的支持和认可,就是我创作的最大动力,我们下篇文章见!

「MoreThanJava」Day 6:面向对象进阶——多态的更多相关文章

  1. 「MoreThanJava」Day 5:面向对象进阶——继承详解

    「MoreThanJava」 宣扬的是 「学习,不止 CODE」,本系列 Java 基础教程是自己在结合各方面的知识之后,对 Java 基础的一个总回顾,旨在 「帮助新朋友快速高质量的学习」. 当然 ...

  2. 「MoreThanJava」Day 4:面向对象基础

    「MoreThanJava」 宣扬的是 「学习,不止 CODE」,本系列 Java 基础教程是自己在结合各方面的知识之后,对 Java 基础的一个总回顾,旨在 「帮助新朋友快速高质量的学习」. 当然 ...

  3. 「MoreThanJava」机器指令到汇编再到高级编程语言

    「MoreThanJava」 宣扬的是 「学习,不止 CODE」,本系列 Java 基础教程是自己在结合各方面的知识之后,对 Java 基础的一个总回顾,旨在 「帮助新朋友快速高质量的学习」. 当然 ...

  4. 「MoreThanJava」Day2:变量、数据类型和运算符

    「MoreThanJava」 宣扬的是 「学习,不止 CODE」,本系列 Java 基础教程是自己在结合各方面的知识之后,对 Java 基础的一个总回顾,旨在 「帮助新朋友快速高质量的学习」. 当然 ...

  5. 「MoreThanJava」Day 3:构建程序逻辑的方法

    「MoreThanJava」 宣扬的是 「学习,不止 CODE」,本系列 Java 基础教程是自己在结合各方面的知识之后,对 Java 基础的一个总回顾,旨在 「帮助新朋友快速高质量的学习」. 当然 ...

  6. 「MoreThanJava」Day 7:接口详解

    「MoreThanJava」 宣扬的是 「学习,不止 CODE」,本系列 Java 基础教程是自己在结合各方面的知识之后,对 Java 基础的一个总回顾,旨在 「帮助新朋友快速高质量的学习」. 当然 ...

  7. 「MoreThanJava」当大学选择了计算机之后应该知道的

    「MoreThanJava」 宣扬的是 「学习,不止 CODE」,本系列 Java 基础教程是自己在结合各方面的知识之后,对 Java 基础的一个总回顾,旨在 「帮助新朋友快速高质量的学习」. 当然 ...

  8. 「MoreThanJava」计算机发展史—从织布机到IBM

    「MoreThanJava」 宣扬的是 「学习,不止 CODE」,本系列 Java 基础教程是自己在结合各方面的知识之后,对 Java 基础的一个总回顾,旨在 「帮助新朋友快速高质量的学习」. 当然 ...

  9. 「MoreThanJava」计算机系统概述

    「MoreThanJava」 宣扬的是 「学习,不止 CODE」,本系列 Java 基础教程是自己在结合各方面的知识之后,对 Java 基础的一个总回顾,旨在 「帮助新朋友快速高质量的学习」. 当然 ...

随机推荐

  1. there is no spatial analyst license available or enabled

    解决方案:右击license—属性

  2. solr

    一.启动命令 tar -zxvf solr-.tgz cd solr-\example java -jar start.jar 默认监听8983端口 java -Djetty.port= -jar s ...

  3. HDU 3652:B-number(数位DP)

    http://acm.hdu.edu.cn/showproblem.php?pid=3652 题意:求数位含有13和可以被13整除的数字个数. 思路:记录3种状态: st == 0 表示 从最高位到第 ...

  4. MST&lpar;prim&rpar;&plus;树形dp-hdu-4756-Install Air Conditioning

    题目链接: http://acm.hdu.edu.cn/showproblem.php?pid=4756 题目意思: n-1个宿舍,1个供电站,n个位置每两个位置都有边相连,其中有一条边不能连,求n个 ...

  5. 在TCP协议下的数据传送

    本人小白菜逼一枚,,,,刚建立博客,也写不了太深入的,就写点上课的笔记什么的.有错误希望广大博友指出,我一定虚心学习接收改正. 我的新浪邮箱:liudaohui0805@sina.com 我的QQ邮箱 ...

  6. Paho -物联网 MQTT C Cient的实现和详解

    概述   在文章Paho - MQTT C Cient的实现中,我介绍了如何使用Paho开源项目创建MQTTClient_pulish客户端.但只是简单的介绍了使用方法,而且客户端的结果与之前介绍的并 ...

  7. Java数据持久层框架 MyBatis之API学习七(动态 SQL详解)

    对于MyBatis的学习而言,最好去MyBatis的官方文档:http://www.mybatis.org/mybatis-3/zh/index.html 对于语言的学习而言,马上上手去编程,多多练习 ...

  8. Java——泛型

    前言 一般的类和方法,使用的都是具体的类型:基本类型或者自定义的类.如果我们要编写出适用于多种类型的通用代码,那么肯定就不能使用具体的类型.前面我们介绍过多态,多态算是一种泛化机制,但是也会拘泥于继承 ...

  9. 牛客国庆集训派对Day5 数论之神

    题目描述 终于活成了自己讨厌的样子. 这是她们都还没长大的时候发生的故事.那个时候,栗子米也不需要为了所谓的爱情苦恼. 她们可以在夏日的午后,花大把的时间去研究生活中一些琐碎而有趣的事情,比如数论. ...

  10. python学习之----Lambda表达式

    Lambda 表达式本质上就是一个函数,可以作为其他函数的变量使用:也就是说,一个函 数不是定义成f(x, y),而是定义成f(g(x), y),或f(g(x), h(x)) 的形式. Beautif ...