1、面向对象的四大特性
1、封装
封装:信息隐藏或者数据访问保护,类通过暴露有限的访问接口,授权外部仅能通过类提供的方式(或者叫函数)来访问内部信息或者数据
1.1、示例
下面这段代码是金融系统中一个简化版的虚拟钱包的代码实现
在金融系统中,我们会给每个用户创建一个虚拟钱包,用来记录用户在我们的系统中的虚拟货币量
对于虚拟钱包的业务背景,这里你只需要简单了解一下即可,在面向对象的实战篇中,我们会有单独两节课,利用 OOP 的设计思想来详细介绍虚拟钱包的设计实现
public class Wallet { private String id; private long createTime; private BigDecimal balance; private long balanceLastModifiedTime; // ... 省略其他属性 ... public Wallet() { this.id = IdGenerator.getInstance().generate(); this.createTime = System.currentTimeMillis(); this.balance = BigDecimal.ZERO; this.balanceLastModifiedTime = System.currentTimeMillis(); } public String getId() { return this.id; } public long getCreateTime() { return this.createTime; } public BigDecimal getBalance() { return this.balance; } public long getBalanceLastModifiedTime() { return this.balanceLastModifiedTime; } public void increaseBalance(BigDecimal increasedAmount) { if (increasedAmount.compareTo(BigDecimal.ZERO) < 0) { throw new InvalidAmountException("..."); } this.balance.add(increasedAmount); this.balanceLastModifiedTime = System.currentTimeMillis(); } public void decreaseBalance(BigDecimal decreasedAmount) { if (decreasedAmount.compareTo(BigDecimal.ZERO) < 0) { throw new InvalidAmountException("..."); } if (decreasedAmount.compareTo(this.balance) > 0) { throw new InsufficientAmountException("..."); } this.balance.subtract(decreasedAmount); this.balanceLastModifiedTime = System.currentTimeMillis(); } }
1.2、解释
从代码中,我们可以发现,Wallet 类主要有四个属性(也可以叫作成员变量),也就是我们前面定义中提到的信息或者数据
- id 表示钱包的唯一编号
- createTime 表示钱包创建的时间
- balance 表示钱包中的余额
- balanceLastModifiedTime 表示上次钱包余额变更的时间
我们参照封装特性,对钱包的这四个属性的访问方式进行了限制,调用者只允许通过下面这六个方法来访问或者修改钱包里的数据
- String getId()
- long getCreateTime()
- BigDecimal getBalance()
- long getBalanceLastModifiedTime()
- void increaseBalance(BigDecimal increasedAmount)
- void decreaseBalance(BigDecimal decreasedAmount)
之所以这样设计,是因为从业务的角度来说
- id、createTime 在创建钱包的时候就确定好了,之后不应该再被改动
所以我们并没有在 Wallet 类中,暴露 id、createTime 这两个属性的任何修改方法,比如 set 方法
而且这两个属性的初始化设置,对于 Wallet 类的调用者来说,也应该是透明的
所以我们在 Wallet 类的构造函数内部将其初始化设置好,而不是通过构造函数的参数来外部赋值 - 对于钱包余额 balance 这个属性,从业务的角度来说,只能增或者减,不会被重新设置
所以我们在 Wallet 类中,只暴露了 increaseBalance() 和 decreaseBalance() 方法,并没有暴露 set 方法 - 对于 balanceLastModifiedTime 这个属性,它完全是跟 balance 这个属性的修改操作绑定在一起的,只有在 balance 修改的时候,这个属性才会被修改
所以我们把 balanceLastModifiedTime 这个属性的修改操作完全封装在了 increaseBalance() 和 decreaseBalance() 两个方法中
不对外暴露任何修改这个属性的方法和业务细节
这样也可以保证 balance 和 balanceLastModifiedTime 两个数据的一致性
1.3、意义
如果我们对类中属性的访问不做限制,那任何代码都可以访问、修改类中的属性,虽然这样看起来更加灵活
但从另一方面来说,过度灵活也意味着不可控,属性可以随意被以各种奇葩的方式修改,而且修改逻辑可能散落在代码中的各个角落,势必影响代码的可读性、可维护性
比如某个同事在不了解业务逻辑的情况下
在某段代码中 "偷偷地" 重设了 wallet 中的 balanceLastModifiedTime 属性,这就会导致 balance 和 balanceLastModifiedTime 两个数据不一致
除此之外,类仅仅通过有限的方法暴露必要的操作,也能提高类的易用性
如果我们把类属性都暴露给类的调用者,调用者想要正确地操作这些属性,就势必要对业务细节有足够的了解,而这对于调用者来说也是一种负担
相反,如果我们将属性封装起来,暴露少许的几个必要的方法给调用者使用,调用者就不需要了解太多背后的业务细节,用错的概率就减少很多
这就好比,如果一个冰箱有很多按钮,你就要研究很长时间,还不一定能操作正确
相反,如果只有几个必要的按钮,比如开、停、调节温度,你一眼就能知道该如何来操作,而且操作出错的概率也会降低很多
2、抽象
封装主要讲的是如何隐藏信息、保护数据
而抽象讲的是如何隐藏方法的具体实现,让调用者只需要关心方法提供了哪些功能,并不需要知道这些功能是如何实现的
2.1、示例
public interface IPictureStorage { void savePicture(Picture picture); Image getPicture(String pictureId); void deletePicture(String pictureId); void modifyMetaInfo(String pictureId, PictureMetaInfo metaInfo); }
public class PictureStorage implements IPictureStorage { // ... 省略其他属性 ... @Override public void savePicture(Picture picture) { ... } @Override public Image getPicture(String pictureId) { ... } @Override public void deletePicture(String pictureId) { ... } @Override public void modifyMetaInfo(String pictureId, PictureMetaInfo metaInfo) { ... } }
2.2、解释
在上面的这段代码中,我们利用 Java 中的 interface 接口语法来实现抽象特性
调用者在使用图片存储功能的时候,只需要了解 IPictureStorage 这个接口类暴露了哪些方法就可以了,不需要去查看 PictureStorage 类里的具体实现逻辑
抽象这个特性是非常容易实现的,并不需要非得依靠接口类或者抽象类这些特殊语法机制来支持
换句话说,并不是说一定要为实现类(PictureStorage)抽象出接口类(IPictureStorage),才叫作抽象
即便不编写 IPictureStorage 接口类,单纯的 PictureStorage 类本身就满足抽象特性
之所以这么说,那是因为:类的方法是通过编程语言中的 "函数" 这一语法机制来实现的,通过函数包裹具体的实现逻辑,这本身就是一种抽象
调用者在使用函数的时候,并不需要去研究函数内部的实现逻辑,只需要通过函数的命名、注释或者文档,了解其提供了什么功能,就可以直接使用了
比如我们在使用 C 语言的 malloc() 函数的时候,并不需要了解它的底层代码是怎么实现的
抽象有时候会被排除在面向对象的四大特性之外
抽象这个概念是一个非常通用的设计思想,并不单单用在面向对象编程中,也可以用来指导架构设计等,而且这个特性也并不需要编程语言提供特殊的语法机制来支持
只需要提供 "函数" 这一非常基础的语法机制,就可以实现抽象特性、所以它没有很强的 "特异性",有时候并不被看作面向对象编程的特性之一
2.3、意义
如果上升一个思考层面的话,抽象及其前面讲到的封装都是人类处理复杂性的有效手段
在面对复杂系统的时候,人脑能承受的信息复杂程度是有限的,所以我们必须忽略掉一些非关键性的实现细节
而抽象作为一种只关注功能点不关注实现的设计思路,正好帮我们的大脑过滤掉许多非必要的信息
除此之外,抽象作为一个非常宽泛的设计思想,在代码设计中,起到非常重要的指导作用,很多设计原则都体现了抽象这种设计思想
比如:基于接口而非实现编程、开闭原则(对扩展开放、对修改关闭)、代码解耦(降低代码的耦合性)等
换一个角度来考虑,我们在定义类的方法的时候,也要有抽象思维
不要在 "方法定义" 中暴露太多的实现细节,以保证在某个时间点需要 "改变方法的实现逻辑" 的时候,不用去修改其 "定义"
比如 getAliyunPictureUrl() 就不是一个具有抽象思维的命名,因为某一天如果我们不再把图片存储在阿里云上,而是存储在私有云上,那这个命名也要随之被修改
相反,如果我们定义一个比较抽象的函数,比如叫作 getPictureUrl(),那即便内部存储方式修改了,我们也不需要修改命名
3、继承
3.1、介绍
继承是用来表示类之间的 is - a 关系,比如猫是一种哺乳动物
从继承关系上来讲,继承可以分为两种模式,单继承和多继承
单继承表示一个子类只继承一个父类,多继承表示一个子类可以继承多个父类,比如猫既是哺乳动物,又是爬行动物
为了实现继承这个特性,编程语言需要提供特殊的语法机制来支持
- 比如 Java 使用 extends 关键字来实现继承
- C++ 使用冒号(class B : public A)
- Python 使用 paraentheses()
- Ruby 使用 <
不过有些编程语言只支持单继承,不支持多重继承,比如 Java、PHP、C#、Ruby 等
而有些编程语言既支持单重继承,也支持多重继承,比如 C++、Python、Perl 等
3.2、意义
继承最大的一个好处就是代码复用
假如两个类有一些相同的属性和方法,我们就可以将这些相同的部分抽取到父类中,让两个子类继承父类,这样两个子类就可以重用父类中的代码,避免代码重复写多遍
不过这一点也并不是继承所独有的,我们也可以通过其他方式来解决这个代码复用的问题,比如利用 "组合关系" 而不是 "继承关系"
如果我们再上升一个思维层面,去思考继承这一特性,可以这么理解
我们代码中有一个猫类,有一个哺乳动物类,猫属于哺乳动物,从人类认知的角度上来说,是一种 is - a 关系
我们通过继承来关联两个类,反应真实世界中的这种关系,非常符合人类的认知,而且从设计的角度来说,也有一种结构美感
继承的概念很好理解,也很容易使用,但是过度使用继承,继承层次过深过复杂,就会导致代码可读性、可维护性变差
为了了解一个类的功能,我们不仅需要查看这个类的代码,还需要按照继承关系一层一层地往上查看 "父类、父类的父类 ..." 的代码
还有子类和父类高度耦合,修改父类的代码,会直接影响到子类
所以继承这个特性也是一个非常有争议的特性,很多人觉得继承是一种反模式,我们应该尽量少用,甚至不用
关于这个问题,在后面讲到 "多用组合少用继承" 这种设计思想的时候,我会非常详细地再讲解,这里暂时就不展开讲解了
4、多态
多态:子类可以替换父类,在实际的代码运行过程中,调用子类的方法实现
4.1、示例 1
public class DynamicArray { private static final int DEFAULT_CAPACITY = 10; protected int size = 0; protected int capacity = DEFAULT_CAPACITY; protected Integer[] elements = new Integer[DEFAULT_CAPACITY]; public int size() { return size; } public Integer get(int index) { return elements[index]; } //... 省略 n 多方法... public void add(Integer e) { ensureCapacity(); elements[size++] = e; } protected void ensureCapacity() { // ... 如果数组满了就扩容 ... } }
public class SortedDynamicArray extends DynamicArray { @Override public void add(Integer e) { ensureCapacity(); // 保证数组中的数据有序 int i; for (i = size - 1; i >= 0 && elements[i] > e; i--) { elements[i + 1] = elements[i]; } elements[i + 1] = e; size++; } }
public class Demo { public static void test(DynamicArray dynamicArray) { dynamicArray.add(5); dynamicArray.add(1); dynamicArray.add(3); for (int i = 0; i < dynamicArray.size(); i++) { System.out.println(dynamicArray.get(i)); } } public static void main(String[] args) { DynamicArray dynamicArray = new SortedDynamicArray(); test(dynamicArray); // 打印结果: 1、3、5 } }
4.2、解释 1
多态这种特性也需要编程语言提供特殊的语法机制来实现,在上面的例子中,我们用到了三个语法机制来实现多态
- 支持父类对象可以引用子类对象,也就是可以将 SortedDynamicArray 传递给 DynamicArray
- 支持继承,也就是 SortedDynamicArray 继承了 DynamicArray,才能将 SortedDyamicArray 传递给 DynamicArray
- 支持子类可以重写(override)父类中的方法,也就是 SortedDyamicArray 重写了 DynamicArray 中的 add() 方法
通过这三种语法机制配合在一起
我们就实现了在 test() 方法中,子类 SortedDyamicArray 替换父类 DynamicArray,执行子类 SortedDyamicArray 的 add() 方法,也就是实现了多态特性
4.3、示例 2
public interface Iterator { boolean hasNext(); String next(); String remove(); }
public class Array implements Iterator { private String[] data; @Override public boolean hasNext() { ... } @Override public String next() { ... } @Override public String remove() { ... } // ... 省略其他方法 ... } public class LinkedList implements Iterator { private LinkedListNode head; @Override public boolean hasNext() { ... } @Override public String next() { ... } @Override public String remove() { ... } // ... 省略其他方法 ... }
public class Demo { private static void print(Iterator iterator) { while (iterator.hasNext()) { System.out.println(iterator.next()); } } public static void main(String[] args) { Iterator arrayIterator = new Array(); print(arrayIterator); Iterator linkedListIterator = new LinkedList(); print(linkedListIterator); } }
4.4、解释 2
Iterator 是一个接口类,定义了一个可以遍历集合数据的迭代器,Array 和 LinkedList 都实现了接口类 Iterator
我们通过传递不同类型的实现类(Array、LinkedList)到 print(Iterator iterator) 函数中,支持动态的调用不同的 next()、hasNext() 实现
- 当我们往 print(Iterator iterator) 函数传递 Array 类型的对象的时候,print(Iterator iterator) 函数就会调用 Array 的 next()、hasNext() 的实现逻辑
- 当我们往 print(Iterator iterator) 函数传递 LinkedList 类型的对象的时候,print(Iterator iterator) 函数就会调用 LinkedList 的 next()、hasNext() 的实现逻辑
4.5、意义
多态特性能提高代码的可扩展性和复用性
我们利用多态的特性,仅用一个 print() 函数就可以实现遍历打印不同类型(Array、LinkedList)集合的数据
当再增加一种要遍历打印的类型的时候,比如 HashMap
我们只需让 HashMap 实现 Iterator 接口,重新实现自己的 hasNext()、next() 等方法就可以了,完全不需要改动 print() 函数的代码
如果我们不使用多态特性,我们就无法将不同的集合类型(Array、LinkedList)传递给相同的函数(print(Iterator iterator) 函数)
我们需要针对每种要遍历打印的集合,分别实现不同的 print() 函数
比如针对 Array,我们要实现 print(Array array) 函数,针对 LinkedList,我们要实现 print(LinkedList linkedList) 函数
而利用多态特性,我们只需要实现一个 print() 函数的打印逻辑,就能应对各种集合数据的打印操作,这显然提高了代码的复用性
多态也是很多设计模式、设计原则、编程技巧的代码实现基础
比如:策略模式、基于接口而非实现编程、依赖倒置原则、里式替换原则、利用多态去掉冗长的 if-else 语句等等
本文来自博客园,作者:lidongdongdong~,转载请注明原文链接:https://www.cnblogs.com/lidong422339/p/17501164.html
【推荐】国内首个AI IDE,深度理解中文开发场景,立即下载体验Trae
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步