谨慎使用继承的方式来进行扩展，优先使用聚合/组合的方式来实现。
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》
