文章目录
- 概况·引出
- 组合·概念·引入
- 区别 —— 继承 && 组合
-
- Is-a && Has-a 的抽象 解释
- 耦合度
- 再分析 设计优化层面 的区别
- 组合优于继承
-
- 类爆炸
- 总体剖析 —— 继承·组合·多态
- 结语
概况·引出
[组合]按正常来说是继承最后一个内容,但我认为其完美结合是继承和多态一起,因此本篇文章从继承,多态出发,全面剖析【组合】
组合·概念·引入
在【继承】博客中分析过其的优势所在,到此处为止,可知道弊处是 多层继承 会出现代码维护方面的问题,但也可通过final来避免 但一种东西总有弊处,只不过弊处不明显,恰如一,初始化方面,恰如二继承,解决了static不足的地方,另外,继承在各种代码方面没有明显不足,此时,在动态拓展,用户选择方面便是不足的地方,也是弊处所在,解决这个不足的,便是“组合” 组合,这个概念,其实,在类和对象的内容章节 就有了 —— 对某个类创建对象 即在一个类中创建另一个类的对象 是Java关系中的“组合”, 一个类继承另一个类,则是Java关系中的“继承”
区别 —— 继承 && 组合
假如有两个类,在第一 个类里创建针对第二个类的对象,和第一个类直接继承第二个类,表面看这两种,似乎在第一个类中,都可以直接调用第二个类的所有成员(隐藏的除外),这两种方式有区别? 先分析最本质的区别:耦合度 和 封装性
组合,即在第一个类里 创建第二个类的对象,两个类之间是相互独立的,第一个类只能通过对象与第二个类交互(松 藕和),人话就是,只能通过对象引用 来调用第二个类的成员(就是说只能通过这种方式来初始化和修改第二个类的成员数据) 这样,第二个类就是第一个类的组成部分,假如第一个类的功能是造车,那么第二个类可能是造轮胎,造车的必要步骤之一就是造轮胎,所以造轮胎(第二个类)就是造车(第一个类)的组成部分 在第一个类中定义成员(即使与第二个类的成员名字相同,),也不会干扰第二个类里面的细节,就是这两个类成员变量名字相同,值不同,因为是处于不同类,所以成员变量及值会储存在不同的内存空间,互不干扰。 即通过组合,第一个类(造车)无需了解第二个类(造轮胎)的内部细节,可通过调用直接使用第二个类的功能(造轮胎),提供给 造车的过程中使用,极大程度防止破坏第二个类的封装性 第二个类(造轮胎)的实现 并不依赖 第一个类(造车),换言之,我自己造轮胎,跟你造车又何关系,所以造轮胎(第二个类)的细节并不透露给造车(第二个类)【封装性 好】,我造好轮胎后,你(造车)只管选一个轮胎品牌去用就行,我造轮胎是独立于你造车而实现的 【松 耦合】!!!
继承,很明显,两个类确认继承关系后,就相当于是同为一类,子类就是在父类的基础上继续进行代码编写设计,即是子类依赖父类的实现(紧 耦合)!, 就是说子类是父类的改版,假设父类的结果实现是做出“普通轮胎”,子类则是轮胎的不同品牌,如雪地胎,越野胎等。雪地胎,越野胎是针对普通轮胎做出的改版,即是雪地胎,越野胎(子类)依赖普通轮胎(父类) 来实现,紧密相连,是为 紧 耦合!!! 由于两个类之间继承后,几乎同为一体,所以父类的细节对子类来说是公开的,此时,对父类来说,封装性被极大破坏! 就是我造雪地胎(第二个类,子类)必须依赖你造普通轮胎(第一个类,父类) 的基础上实现【紧 耦合】,所以造普通轮胎(第一个类,父类)的细节必须透露给造雪地胎(第二个类,子类),即【封装性 差】!
总结分析: 区别主要在 第二个类是否在第一个类的基础上 实现,换个表达就是第二个类是否依赖于第一个类
-
组合,第一个类只是对第二个类功能的取用,第二个类的实现基本独立于第一个类,不在第一个类的基础上而实现。
-
继承,可以说,第二个类(子类)的功能是第一个类(父类)功能的延续,
而组合中第二个类的功能与第一个类的功能是 取用关系,不是延续关系
Is-a && Has-a 的抽象 解释
书上总有“Is-a” && “Has-a” 对继承和组合的描述, 我只想说,谁想到这种解释的,抽象!!! 继承关系上,子类是父类功能的延续,即A_Tire(子类)是Tire(父类)的一种,就是“Is-a”的关系 组合,在Car里面创建对Tire的对象,这之间是取用关系,即是Car里有Tire(车有轮胎,车必须有轮胎及其的功能,才算车,就是车对轮胎功能的取用,是取用关系),就是“Has-a”的关系
耦合度
—— – – -官方(主流)分析 耦合度(Coupling),也叫耦合性,是软件工程中用于衡量不同模块或类之间相互依赖程度的指标 。 简单来说,它描述了当你修改一个模块时,对其他模块可能造成的影响有多大。耦合度越高,模块间的联系就越紧密,独立性就越差;反之,耦合度越低,模块就越独立
耦合 && 聚合
耦合和内聚是相辅相成的两个概念:
- 耦合 (Coupling) 关注的是模块之间的关系。
- 内聚 (Cohesion) 关注的是模块内部各元素之间的关联程度。
一个设计良好的系统,通常追求 “高内聚,低耦合”。这意味着每个模块都职责单一、功能集中(高内聚),同时模块之间的依赖关系尽可能简单、松散(低耦合)
再分析 设计优化层面 的区别
书上,大部分老师说,“组合优于继承” “能用组合尽量用组合” ,说是组合 耦合度和封装好 还好理解(其实已经好有点抽象,难以理解了),到最后一个理由 —— “组合”灵活性高,支持动态组合 为什么? 喵的,这是当时我根本理解不了一点,抽象至极!!!
- 在了解这一点原因后,由于理解不通,忽然,对“组合”“继承”变得好陌生,根本不知道何时使用,它们不是只有耦合度和封装性的区别吗?为什么组合灵活性高?
- 难道这两种不是 在第一个类(子类)中,都可以直接调用第二个类(父类)的所有成员(隐藏的除外)吗? 只是有两种不同的实现方式,其目的不都是一样? 为什么有灵活性的区别?
冥想的那几段时间,想通了这一点,又被其他地方堵塞了,云里雾里,在一直查阅之后,终于,融会贯通了,回头看,发现理解好“灵活性,动态组合”,才是真正搞清了何为“组合”,何为“继承”!!! 搞清后,对代码来说,设计层面上会很好地优化代码,避免代码冗长,就是跨入了“软件框架设计”的门槛 如何在主类中,凸显组合的优势 —— 灵活性高 需多态及注入方法的完美结合 这也是我当时一直想不通的点,需用到多态的知识点!
组合优于继承
”组合“和”继承“ 如何融入代码设计中,即如何完美 结合 ”继承“ ”组合“ ”多态“ ,如何淋漓尽致体现其 灵·活·性 ??? 灵活性 是这些内容模块在代码设计中,一起结合的 精华所在!!!
(可不看) 先讨论“组合”如何使用,,组合就是对 某类创建对象,通过对象的实例化 把多个类 集中在一个类(后续称这个类为“集中类”)里面,,那么在主类里,就可以通过这一个集中类,间接调用多个类。 一般创建对象都是通过对象调用·对应类里面的成员,, 但这样做就相当于在主类创建的对象里 调用其类里面的又一个对象,相当于在主类里调用一个类(第一个类),却在该调用的类里再一次调用另一个类(第二个类),就是为了调用第二个类,先调用第一个类为过渡,为什么这样搞,最终调的是第二个类,却还要调第一个类,为什么不直接调用第二个类, 第二个类最后可能调用的是其 子类! 用的就是 向上转型 ,抽象吧 (这一段是我当时没有举例子的 解释,可能很抽象,可不看,有例子的解释在下面)
假设第一个类的功能是造车,定义为“Car类”,第二个类的功能是造轮胎,定义为“Tire类”,有许多不同品牌的轮胎,即为Tire的子类。造车肯定是要装轮胎的,所以在Car类里,对Tire类创建对象,就是为了在Tire类里造好了的轮胎装到车(Car类)上。 Car类的功能是造车的必要步骤,如果要造某些品牌的车,步骤大致是相同的,但肯定有不同,因此在造某品牌车时,该某品牌车的类(称为主类)要继承Car类,并对Car类做该品牌车的细节修改,最后造成该品牌的车。 不同品牌的车,轮胎肯定不同,因此,继承了Car类的主类里,如何选择轮胎,即是在主类中,如何通过Car类调用Tire的子类? 此时需要在Car类里 创建一个方法,即为“注入方法” “注入方法”,顾名思义,就是为了注入哪个类的方法,人话就是,就是要装哪个轮胎,通过这个方法接收
public class Car{ //做普通车的类
public void setTire(Tire tire){
……(把轮胎装进车里的步骤)
}
……(除装轮胎外,造车的其他步骤)
}
public class Tire{
……(造轮胎的步骤)
}
public class A_Tire extends Tire{
……(对普通轮胎的改版,成为A轮胎,即轮胎的品牌A)
}
public class B_Tire extends Tire{
……(对普通轮胎的改版,成为B轮胎,即轮胎的品牌B)
}
public class A_Car extends Car{ //对普通车的改版类,即是车的品牌A,这个类即是为该品牌造车 就是造A车,那么就要装A轮胎
public static void main(Strings[] args){
A_Tire a = new A_Tire; //先把A轮胎造好,方便后续把A轮胎直接提供 造车步骤中 装轮胎 所需的轮胎,喵的真拗口
car.setTire(a); //把造好的轮胎,直接当作参数传给 注入方法(该方法的功能就是为车 装轮胎)
}
}
上方的演示代码,多态体现在 注入方法,明显可见其为 向上转型的方式之一 —— 方法传参
就是传的都是轮胎(需完成某个行为),但传的轮胎对象不同(不同的对象去完成),最后车上的轮胎不同(产生出不同 的状态,就是多态) 通过在主类(A_Car类)里创建对Car的对象,再通过该对象通过装轮胎的方法“注入方法”,此时变想要装什么轮胎呢? 然后针对各种轮胎,需要哪种轮胎就给对应的类创建对象,然后当作参数输入进注入方法,然后这个车的轮胎就装成功了
这段代码就是我之前总是提到的“组合·继承·多态 的完美结合”,还说其最大的优势 灵活性,所以其灵活性体现在哪? —— 想装哪个轮胎就装哪个!
类爆炸
优势都是对比出来的,多态的体现是在类的传输里,这样设计的核心就是组合, 有人说,不就是装轮胎吗,为什么不在Car类里面提前把轮胎装好,就是说一个Car类里只能装一种轮胎,如果有多种轮胎,就要创建多个Car1,Car2……? (会独自分析该种情况,难描述,这个分析可看可不看) 不说其他的,这些个Car类里面,只是轮胎不同,大部分的不变,不就是复制粘贴,改变其中的某些选择,这样只会体现代码设计不佳,类之间有大部分雷同,还有多个类,一个专属名词描述这种场景 —— ”类爆炸“ !!! 如果为每种车,装一种轮胎,而创建一个Car类,这样Car类会有多少,即是什么程度的”类爆炸“
- CarWithMichelinTire (装米其林胎的车) CarWithBridgestoneTire (装普利司通胎的车) CarWithSnowTire (装雪地胎的车) ……
- 如果你有 10 种车,5 种轮胎,你就得写 10 \\times 5 = 50 个类!这50个类只是某些改变,代码设计极其不佳,代码极其冗长,这就是代码的 类爆炸
因此,提前装轮胎不如在造车时 实时选轮胎,这样就只需一个Car类,想装哪个轮胎,就创建对Tire某个子类的对象(就是灵活,便是在此处凸显了”灵活性“),并把他提供给Car类的注入方法,就完美解决了”类爆炸“。 ”继承 + 组合“的方式,其中包含向上转型,这样设计极佳,极大提高代码可读性 创建一个Car类,该Car类就只是是造车的流程,包括如何装轮胎,如何刷油漆,Car类只提供”如何造“,没说要装哪种轮胎,刷哪种油漆,就是说,Car里面只是实现行为,没有实现的条件(轮胎没给,油漆没给),何时给条件? 是在 实际造某品牌的车 的类里继承Car类,并提供装的哪个轮胎(提供条件),此时轮胎才会装到车上。
不是说,类之间改变少就不该存在,恰如,Tire的子类,Tire只是普通轮胎,如果有多个品牌的轮胎,就继承成为Tire的子类,这样可以借助Tire类 极大方便 来设计不同轮胎,即使有多个不同的轮胎,即多个子类,就是有多个改变不大的类,这样的类存在有独自的意义,就不是”类爆炸“
总体剖析 —— 继承·组合·多态
继承·组合·多态的组合型代码设计思想,即是适时使用”继承“和”组合“,然后在使用时加以“多态”思想, 其 灵·活·性 是设计层面对代码的极大优化,代码简短,可选择范围大,可随时而变
这种设计思想,灵活性得归功于多态中向上转型,就是子类能向父类兼容(转型)。其灵活性不止体现在类之间的灵活(选择性多样),在类里面也会体现(类里面 代码逻辑编写的灵活性,这样设计后,代码会更加 极简,即降低圈复杂度)
结语
以上结论 带有我自己对该内容理解 而总结得出,可能分析不全,用词不适,总结不当,接受批评,欢迎指出




