聚合/组合

谨慎使用继承的方式来进行扩展，优先使用聚合/组合的方式来实现。

Father类里有两个方法A和方法B，并且A调用了B。子类Son重写了方法B，这时候如果子类调用继承来的方法A，那么方法A调用的就不再是Father.B()，而是子类中的方法Son.B()。如果程序的正确性依赖于Father.B()中的一些操作，而Son.B()重写了这些操作，那么就很可能导致错误产生。

上代码：

父类：

public class FatherClass {

    public int methodA(int i){
        return methodB(i);
    }

    public int methodB(int j){
        return ++j;
    }
}

子类：

public class SonClass extends FatherClass {

    @Override
    public int methodB(int i) {
        i = i + 100;
        return i;
    }

    public int callFatherMethodA(int i){
        return super.methodA(i);
    }

    public static void main(String[] args) {
        FatherClass fatherClass = new FatherClass();
        System.out.println("fatherClass.methodA:" + fatherClass.methodA(100));

        SonClass sonClass = new SonClass();
        System.out.println("sonClass.methodA:" + sonClass.methodA(100));
        System.out.println("sonClass.callFatherMethodA:" + sonClass.callFatherMethodA(100));
    }

输出结果，各位看官可以先预测一下：

fatherClass.methodA:101
sonClass.methodA:200
sonClass.callFatherMethodA:200

继承

继承（Inheritance）是一种联结类与类的层次模型。指的是一个类（称为子类、子接口）继承另外的一个类（称为父类、父接口）的功能，并可以增加它自己的新功能的能力，继承是类与类或者接口与接口之间最常见的关系。

在这里插入图片描述

继承是一种is-a关系。如苹果是水果，狗是动物，哈士奇是狗。

继承、聚合与组合的定义

继承:指的是一个类(称为子类、子接口)继承另外的一个类(称为父类、父接口)的功能，并可以增加它自己的新功能的能力，继承是类与类或者接口与接口之间最常见的关系；在Java中此类关系通过关键字extends明确标识，在设计时一般没有争议性；

关联:是两个类、或者类与接口之间语义级别的一种强依赖关系，比如我和我的朋友；这种关系比依赖更强、不存在依赖关系的偶然性、关系也不是临时性的，一般是长期性的，而且双方的关系一般是平等的、关联可以是单向、双向的；表现在代码层面，类B以类属性的形式出现在关联类A中，也可能是关联类A引用了一个类型为被关联类B的全局变量；

聚合:关联关系的一种特例，他体现的是整体与部分、拥有的关系，即has-a的关系，此时整体与部分之间是可分离的，他们可以具有各自的生命周期，部分可以属于多个整体对象，也可以为多个整体对象共享；比如计算机与CPU、公司与员工的关系等；表现在代码层面，和关联关系是一致的，只能从语义级别来区分；

组合:组合也是关联关系的一种特例，他体现的是一种contains-a的关系，这种关系比聚合更强，也称为强聚合；他同样体现整体与部分间的关系，但此时整体与部分是不可分的，整体的生命周期结束也就意味着部分的生命周期结束；比如你和你的大脑；表现在代码层面，和关联关系是一致的，只能从语义级别来区分；

组合

组合(Composition)体现的是整体与部分、拥有的关系。

正在上传…重新上传取消

在这里插入图片描述

组合是一种has-a的关系。如汽车有一个发动机，学校有一个老师等。

组合的实现

只需要将对象的引用置于新类中即可。

class A{
    ...
}
class B{
    private A;
    ...
}

在Java中，类中域为基本类型时会被自动初始化为对应的“零”，对象引用会被初始化为null。编译器并不是简单地为每一个引用都创建默认对象。若是想初始化对象引用，可以在代码中的下列位置进行：

在定义对象的地方。这也意味着它们会在构造器被调用之前被初始化。
在类的构造器中。
在临近使用这些对象之前，再初始化，这种方式也叫做惰性初始化。
使用实例初始化。

使用《Java编程思想》上面的例子说明：

class Soap{
    private String s;
    public Soap() {
        System.out.println("Soap()无参构造器");
        s = "Constructed";      //在类构造器中初始化
    }
    
    @Override
    public String toString() { return s;}
}

public class Bath {
    private String s1 = "Happy";//在定义对象的地方初始化
    private Soap castille = new Soap();
    private String s2;
    private int i;
    
    public Bath() { System.out.println("Bath() 无参构造器");}
    //实例初始化
    {
        i = 31;
        System.out.println("初始化i为31");
    }
    
    @Override
    public String toString() {
        if(s2 == null) {        //惰性初始化
            s2 ="Java";
        }
        return s1 + "\t"+ s2 + "\t" + i + "\t" + castille;
    }
    
    public static void main(String[] args) {
        System.out.println(new Bath());
    }
}
/*
output:
Soap()无参构造器
初始化i为31
Bath() 无参构造器
Happy   Java    31  Constructed
*/

组合与继承的区别

首先，从类的关系确定时间点上，组合和继承是有区别的：

继承，在写代码的时候就要指名具体继承哪个类，所以，在编译期就确定了关系。并且从基类继承来的实现是无法在运行期动态改变的，因此降低了应用的灵活性。

组合，在写代码的时候可以采用面向接口编程。所以，类的组合关系一般在运行期确定。

另外，代码复用方式上也有一定区别：

继承结构中，父类的内部细节对于子类是可见的。所以我们通常也可以说通过继承的代码复用是一种白盒式代码复用。

如果基类的实现发生改变，那么派生类的实现也将随之改变。这样就导致了子类行为的不可预知性。

组合是通过对现有的对象进行拼装（组合）产生新的、更复杂的功能。因为在对象之间，各自的内部细节是不可见的，所以我们也说这种方式的代码复用是黑盒式代码复用。

因为组合中一般都定义一个类型，所以在编译期根本不知道具体会调用哪个实现类的方法。

最后，Java中不支持多继承，而组合是没有限制的。就像一个人只能有一个父亲，但是他可以有很很多辆车。

优缺点对比

组 合 关 系	继 承 关 系
优点：不破坏封装，整体类与局部类之间松耦合，彼此相对独立	缺点：破坏封装，子类与父类之间紧密耦合，子类依赖于父类的实现，子类缺乏独立性
优点：具有较好的可扩展性	缺点：支持扩展，但是往往以增加系统结构的复杂度为代价
优点：支持动态组合。在运行时，整体对象可以选择不同类型的局部对象	缺点：不支持动态继承。在运行时，子类无法选择不同的父类
优点：整体类可以对局部类进行包装，封装局部类的接口，提供新的接口	缺点：子类不能改变父类的接口
缺点：整体类不能自动获得和局部类同样的接口	优点：子类能自动继承父类的接口
缺点：创建整体类的对象时，需要创建所有局部类的对象	优点：创建子类的对象时，无须创建父类的对象

为什么组合优于继承

相信很多人都知道面向对象中有一个比较重要的原则『多用组合、少用继承』或者说『组合优于继承』。从前面的介绍已经优缺点对比中也可以看出，组合确实比继承更加灵活，也更有助于代码维护。

所以，建议在同样可行的情况下，优先使用组合而不是继承。因为组合更安全，更简单，更灵活，更高效。

注意，并不是说继承就一点用都没有了，前面说的是【在同样可行的情况下】。有一些场景还是需要使用继承的，或者是更适合使用继承。

另外，除了《阿里巴巴Java开发手册》，在很多其他资料中也有关于组合和继承的介绍和使用约束：

继承要慎用，其使用场合仅限于你确信使用该技术有效的情况。一个判断方法是，问一问自己是否需要从新类向基类进行向上转型。如果是必须的，则继承是必要的。反之则应该好好考虑是否需要继承。《Java编程思想》

只有当子类真正是超类的子类型时，才适合用继承。换句话说，对于两个类A和B，只有当两者之间确实存在is-a关系的时候，类B才应该继续类A。《Effective Java》