面向对象

第4章类的继承

计算机程序经常使用类之间的继承关系来表示对象之间的分类关系。
- 在继承关系中，有父类和子类。
- 父类也叫基类，子类也叫派生类。
- 父类、子类是相对的，一个类 B 可能是类 A 的子类，但又是类 C 的父类。
- 之所以叫继承，是因为子类继承了父类的属性和行为，父类有的属性和行为子类都有。
- 但子类可以增加子类特有的属性和行为，某些父类有的行为，子类的实现方式可能与父类也不完全一样。
- 使用继承一方面可以复用代码，公共的属性和行为可以放到父类中，而子类只需要关注子类特有的就可以了，另一方面，不同子类的对象可以更为方便地被统一处理。

4.1 基本概念

4.1.1 根父类 Object

在 Java 中，即使没有声明父类，也有一个隐含的父类，这个父类叫 Object。Object 没有定义属性，但定义了一些方法。
子类是知道自己的属性的，子类可以重写父类的方法，以反映自己的不同实现。所谓重写，就是定义和父类一样的方法，并重新实现。

4.1.2 方法重写

假如我们需要重写父类中的 toString() 方法，则只需要在子类的 toString() 方法前面加一个 @Override 注解，这表示 toString() 这个方法是重写的父类的方法。
Java 使用 extends 关键字表示继承关系，一个类最多只能有一个父类。
子类不能直接访问父类的私有属性和方法。除了私有的外，子类继承了父类的其他属性和方法。
在 new 的过程中，父类的构造方法也会执行，且会优先于子类执行。
super 关键字用于指代父类，可用于调用父类构造方法，访问父类方法和变量。
- super(color) 表示调用父类的带 color 参数的构造方法。调用父类构造方法时，super 必须放在第一行。
- super.getColor() 表示调用父类的 getColor 方法，当有歧义的时候，通过 super，可以明确表示调用父类的方法。
- super 同样可以引用父类非私有的变量。
- super 和 this 是不同的，this 引用一个对象，是实实在在存在的，可以作为函数参数，可以作为返回值，但 super 只是一个关键字，不能作为参数和返回值，它只是用于告诉编译器访问父类的相关变量和方法。
使用继承的一个好处是可以统一处理不同子类型的对象。
- 子类对象赋值给父类引用变量，这叫向上转型，转型就是转换类型，向上转型就是转换为父类类型。
- 变量 shape 可以引用任何 Shape 子类类型的对象，这叫多态，即一种类型的变量，可引用多种实际类型对象。
- 这样，对于变量 shape，它就有两个类型：类型 Shape，我们称之为 shape 的静态类型；类型 Circle/Line/ArrowLine，我们称之为 shape 的动态类型。
- shapes[i].draw() 调用的是其对应动态类型的 draw 方法，这称之为方法的动态绑定。
为什么要有多态和动态绑定呢？
- 创建对象的代码和操作对象的代码经常不在一起，操作对象的代码往往只知道对象是某种父类型，也往往只需要知道它是某种父类型就可以了。
- 可以说，多态和动态绑定是计算机程序的一种重要思维方式，使得操作对象的程序不需要关注对象的实际类型，从而可以统一处理不同对象，但又能实现每个对象的特有行为。

4.2 继承的细节

子类可以通过 super 调用父类的构造方法，如果子类没有通过 super 调用，则会自动调动父类的默认构造方法，那如果父类没有默认构造方法呢？
```
public class Base {private String member;public Base(String member) {this.member = member;}
}
```
- 这个类只有一个带参数的构造方法，没有默认构造方法。
- 这个时候，它的任何子类都必须在构造方法中通过 super 调用 Base 的带参数构造方法。否则，Java 会提示编译错误。
```
public class Child extends Base{public Child(String member) {super(member);}
}
```
- 另外需要注意的是，如果在父类构造方法中调用了可被重写的方法，则可能会出现意想不到的结果。在父类构造方法中调用可被子类重写的方法，是一种不好的实践，容易引起混淆，应该只调用 private 的方法。

4.2.2 重名与静态绑定

子类可以重写父类非 private 的方法，当调用的时候，会动态绑定，执行子类的方法。
那实例变量、静态方法和静态变量呢？它们可以重名吗？如果重名，访问的是哪一个呢？
- 重名是可以的，重名后实际上有两个变量或方法。
- private 变量和方法只能在类内访问，访问的也永远是当前类的，即：在子类中访问的是子类的；在父类中访问的是父类的，它们只是碰巧名字一样而已，没有任何关系。
- public 变量和方法，则要看如何访问它。
  - 在类内，访问的是当前类的，但子类可以通过 super. 明确指定访问父类的。
  - 在类外，则要看访问变量的静态类型：静态类型是父类，则访问父类的变量和方法；静态类型是子类，则访问的是子类的变量和方法。
  - 静态绑定，即访问绑定到变量的静态类型。
  - 静态绑定在程序编译阶段即可决定，而动态绑定则要等到程序运行时。
  - 实例变量、静态变量、静态方法、private 方法，都是静态绑定的。

4.2.3 重载和重写

重载是指方法名称相同但参数签名不同（参数个数、类型或顺序不同），重写是指子类重写与父类相同参数签名的方法。
当有多个重名函数的时候，在决定要调用哪个函数的过程中，首先是按照参数类型进行匹配的，换句话说，寻找在所有重载版本中最匹配的，然后才看变量的动态类型，进行动态绑定。

4.2.4 父子类型转换

子类型的对象可以赋值给父类型的引用变量，这叫向上转型，那父类型的变量可以赋值给子类型的变量吗？或者说可以向下转型吗？语法上可以进行强制类型转换，但不一定能转换成功。
我们以前面的例子来看：
```
Base b = new Child();
Child c = (Child)b;
```
- Child c = (Child)b 就是将变量 b 的类型强制转换为 Child 并赋值为 c，这是没有问题的，因为 b 的动态类型就是 Child，但下面的代码是不行的：
```
Base b = new Base();
Child c = (Child)b;
```
  - 语法上Java不会报错，但运行时会抛出错误，错误为类型转换异常。
- 一个父类的变量能不能转换为一个子类的变量，取决于这个父类变量的动态类型（即引用的对象类型）是不是这个子类或这个子类的子类。
```
public boolean canCast(Base b) {return b instanceof Child;
}
```
  - 这个函数返回 Base 类型变量是否可以转换为 Child 类型，instanceof 前面是变量，后面是类，返回值是 boolean 值，表示变量引用的对象是不是该类或其子类的对象。

4.2.5 继承访问权限 protected

变量和函数有 public/private 修饰符，public 表示外部可以访问，private 表示只能内部使用，还有一种可见性介于中间的修饰符 protected，表示虽然不能被外部任意访问，但可被子类访问。
另外，protected 还表示可被同一个包中的其他类访问，不管其他类是不是该类的子类。
我们来看个例子，这是基类代码：
```
public class Base {protected int currentStep;protected void step1() {}protected void step2() {}public void action() {this.currentStep = 1;step1();step2();}
}
```
- action 表示对外提供的行为，内部有两个步骤 step1() 和 step2()，使用 currentStep 变量表示当前进行到了哪个步骤。
- step1()、step2() 和 currentStep 是 protected 的，子类一般不重写 action，而只重写 step1 和 step2。
- 同时，子类可以直接访问 currentStep 查看进行到了哪一步。
- 这种思路和设计是一种设计模式，称之为模板方法。
  - action 方法就是一个模板方法，它定义了实现的模板，而具体实现则由子类提供。
  - 模板方法在很多框架中有广泛的应用，这是使用 protected 的一种常见场景。

4.2.6 可见性重写

重写方法时，一般并不会修改方法的可见性。
- 重写时，子类方法不能降低父类方法的可见性。
- 父类如果是 public，则子类也必须是 public，父类如果是 protected，子类可以是 protected，也可以是 public，即子类可以升级父类方法的可见性但不能降低。
继承反映的是“is-a”的关系，即子类对象也属于父类，子类必须支持父类所有对外的行为，将可见性降低就会减少子类对外的行为，从而破坏“is-a”的关系，但子类可以增加父类的行为，所以提升可见性是没有问题的。

4.2.7 防止继承 final

有的时候我们不希望父类方法被子类重写，有的时候甚至不希望类被继承，可以通过 final 关键字实现。
一个 Java 类，默认情况下都是可以被继承的，但加了 final 关键字之后就不能被继承了。
一个非 final 的类，其中的 public/protected 实例方法默认情况下都是可以被重写的，但加了 final 关键字后就不能被重写了。

4.3 继承实现的基本原理

Base 包括一个静态变量 s，一个实例变量 a，一段静态初始化代码块，一段实例初始化代码块，一个构造方法，两个方法 step 和 action。

public class Base {public static int s;private int a;static {System.out.println("基类静态代码块, s：" + s);s = 1;}{System.out.println("基类实例代码块, a：" + a);a = 1;}public Base() {System.out.println("基类构造方法, a：" + a);a = 2;}protected void step() {System.out.println("base s：" + s + ", a：" + a);}public void action() {System.out.println("start");step();System.out.println("end");}
}

Child 继承了 Base，也定义了和基类同名的静态变量 s 和实例变量 a，静态初始化代码块，实例初始化代码块，构造方法，重写了方法 step。

public class Child extends Base{public static int s;private int a;static {System.out.println("子类静态代码块, s：" + s);s = 10;}{System.out.println("子类实例代码块, a：" + a);a = 10;}public Child() {System.out.println("子类构造方法, a：" + a);a = 20;}@Overrideprotected void step() {System.out.println("child s：" + s + ", a：" + a);}
}

演示继承原理：main 方法

/*** 输出:* 基类静态代码块, s：0* 子类静态代码块, s：0* ---- new Child()* 基类实例代码块, a：0* 基类构造方法, a：1* 子类实例代码块, a：0* 子类构造方法, a：10** ---- c.action()* start* child s：10, a：20* end** ---- b.action()* start* child s：10, a：20* end** ---- b.s：1** ---- c.s：10*/
public static void main(String[] args) {System.out.println("---- new Child()");Child c = new Child();System.out.println("\n---- c.action()");c.action();Base b = c;System.out.println("\n---- b.action()");b.action();System.out.println("\n---- b.s：" + b.s);System.out.println("\n---- c.s：" + c.s);
}

4.3.1 类加载过程

在 Java 中，所谓类的加载是指将类的相关信息加载到内存。
- 在 Java 中，类是动态加载的，当第一次使用这个类的时候才会加载。
- 加载一个类时，会查看其父类是否已加载，如果没有，则会加载其父类。
一个类的信息主要包括以下部分：
- 类变量（静态变量）；
- 类初始化代码；
- 类方法（静态方法）；
- 实例变量；
- 实例初始化代码；
- 实例方法；
- 父类信息引用。
类初始化代码包括：
- 定义静态变量时的赋值语句；
- 静态初始化代码块。
实例初始化代码包括：
- 定义实例变量时的赋值语句；
- 实例初始化代码块；
- 构造方法。
类加载过程包括：
- 分配内存保存类的信息；
- 给类变量赋默认值；
- 加载父类；
- 设置父子关系；
- 执行类初始化代码。
类初始化代码，是先执行父类的，再执行子类的。不过，父类执行时，子类静态变量的值也是有的，是默认值。
内存分为栈和堆，栈存放函数的局部变量，而堆存放动态分配的对象，还有一个内存区，存放类的信息，这个区在 Java 中称为方法区。加载后，Java 方法区就有了一份这个类的信息。

4.3.2 对象创建的过程

在类加载之后，new Child() 就是创建 Child 对象，创建对象过程包括：
- 分配内存；
- 对所有实例变量赋默认值；
- 执行实例初始化代码。
分配的内存包括本类和所有父类的实例变量，但不包括任何静态变量。
- 实例初始化代码的执行从父类开始，再执行子类的。
- 但在任何类执行初始化代码之前，所有实例变量都已设置完默认值。
- 每个对象除了保存类的实例变量之外，还保存着实际类信息的引用。
动态绑定实现的机制就是根据对象的实际类型查找要执行的方法，子类型中找不到的时候再查找父类。
- 如果继承的层次比较深，要调用的方法位于比较上层的父类，则调用的效率是比较低的，因为每次调用都要进行很多次查找。
- 大多数系统使用一种称为虚方法表的方法来优化调用的效率。
- 所谓虚方法表，就是在类加载的时候为每个类创建一个表，记录该类的对象所有动态绑定的方法（包括父类的方法）及其地址，但一个方法只有一条记录，子类重写了父类方法后只会保留子类的。
对变量的访问是静态绑定的，无论是类变量还是实例变量。

4.4 为什么说继承是把双刃剑

继承广泛应用于各种 Java API、框架和类库之中，一方面它们内部大量使用继承，另一方面它们设计了良好的框架结构，提供了大量基类和基础公共代码。使用者可以使用继承，重写适当方法进行定制，就可以简单方便地实现强大的功能。
继承为什么会有破坏力呢？主要是因为继承可能破坏封装，而封装可以说是程序设计的第一原则；另外，继承可能没有反映出 is-a 关系。

4.4.1 继承破坏封装

如果子类不知道基类方法的实现细节，它就不能正确地进行扩展。
子类和父类之间是细节依赖，子类扩展父类，仅仅知道父类能做什么是不够的，还需要知道父类是怎么做的，而父类的实现细节也不能随意修改，否则可能影响子类。
子类需要知道父类的可重写方法之间的依赖关系，而且这个依赖关系，父类不能随意改变。但即使这个依赖关系不变，封装还是可能被破坏。
父类不能随意增加公开方法，因为给父类增加就是给所有子类增加，而子类可能必须要重写该方法才能确保方法的正确性。
对于子类而言，通过继承实现是没有安全保障的，因为父类修改内部实现细节，它的功能就可能会被破坏；而对于基类而言，让子类继承和重写方法，就可能丧失随意修改内部实现的自由。

4.4.3 继承没有反映 is-a 关系

继承关系是设计用来反映 is-a 关系的，子类是父类的一种，子类对象也属于父类，父类的属性和行为也适用于子类。
在 is-a 关系中，重写方法时，子类不应该改变父类预期的行为，但是这是没有办法约束的。
继承是应该被当作 is-a 关系使用的，但是，Java 并没有办法约束，父类有的属性和行为，子类并不一定都适用，子类还可以重写方法，实现与父类预期完全不一样的行为。

4.4.4 如何应对继承的双面性

我们先来看怎么避免继承，有三种方法：
- 使用 final 关键字；
  - 给方法加 final 修饰符，父类就保留了随意修改这个方法内部实现的自由，使用这个方法的程序也可以确保其行为是符合父类声明的。
  - 给类加 final 修饰符，父类就保留了随意修改这个类实现的自由，使用者也可以放心地使用它，而不用担心一个父类引用的变量，实际指向的却是一个完全不符合预期行为的子类对象。
- 优先使用组合而非继承；
  - 使用组合可以抵挡父类变化对子类的影响，从而保护子类，应该优先使用组合。
  - 这样，子类就不需要关注基类是如何实现的了，基类修改实现细节，增加公开方法，也不会影响到子类了。
- 使用接口。
  - 组合的问题是，子类对象不能当作基类对象来统一处理了。解决方法是使用接口。
正确使用继承
- 如果要使用继承，怎么正确使用呢？
- 使用继承大概主要有三种场景：
  - 基类是别人写的，我们写子类；
    - 基类主要是 Java API、其他框架或类库中的类，在这种情况下，我们主要通过扩展基类，实现自定义行为。
    - 这种情况下需要注意的是：
      - 重写方法不要改变预期的行为；
      - 阅读文档说明，理解可重写方法的实现机制，尤其是方法之间的依赖关系；
      - 在基类修改的情况下，阅读其修改说明，相应修改子类。
  - 我们写基类，别人可能写子类；
    - 我们写基类给别人用，在这种情况下，需要注意的是：
      - 使用继承反映真正的 is-a 关系，只将真正公共的部分放到基类；
      - 对不希望被重写的公开方法添加 final 修饰符；
      - 写文档，说明可重写方法的实现机制，为子类提供指导，告诉子类应该如何重写；
      - 在基类修改可能影响子类时，写修改说明。
  - 基类、子类都是我们写的。

读书笔记：Java 编程的逻辑（四）相关推荐

OnJava8读书笔记(java编程思想)--集合Collections
本篇博文参考on Java8中文版编写本编博文参考java编程思想第四版编写文章目录概述一.泛型和类型安全的集合二.基本概念三.添加元素组(Adding Groups of Element ...
Core Java 8 读书笔记-Networking编程
Core Java 8 读书笔记-Networking编程作者:老九-技术大黍原文:Core Java 8th Edition 社交:知乎公众号:老九学堂(新人有惊喜) 特别声明:原创不易,未经 ...
Java编程的逻辑 (29) - 剖析String
本系列文章经补充和完善,已修订整理成书<Java编程的逻辑>,由机械工业出版社华章分社出版,于2018年1月上市热销,读者好评如潮!各大网店和书店有售,欢迎购买,京东自营链接:http: ...
Java编程的逻辑 (59) - 文件和目录操作
本系列文章经补充和完善,已修订整理成书<Java编程的逻辑>,由机械工业出版社华章分社出版,于2018年1月上市热销,读者好评如潮!各大网店和书店有售,欢迎购买,京东自营链接:http:/ ...
Java编程的逻辑 (84) - 反射
本系列文章经补充和完善,已修订整理成书<Java编程的逻辑>,由机械工业出版社华章分社出版,于2018年1月上市热销,读者好评如潮!各大网店和书店有售,欢迎购买,京东自营链接:http: ...
【读书笔记】.NET本质论第四章-Programming with Type(Part Two)
欢迎阅读本系列其他文章: [读书笔记].NET本质论第一章 The CLR as a Better COM [读书笔记].NET本质论第二章-Components(Part One) [读书笔记].N ...
《Java编程的逻辑》终于上市了！，java开发面试笔试题
我总结出了很多互联网公司的面试题及答案,并整理成了文档,以及各种学习的进阶学习资料,免费分享给大家. 扫描二维码或搜索下图红色VX号,加VX好友,拉你进[程序员面试学习交流群]免费领取.也欢迎各位一起 ...
Java编程的逻辑 (34) - 随机
本系列文章经补充和完善,已修订整理成书<Java编程的逻辑>,由机械工业出版社华章分社出版,于2018年1月上市热销,读者好评如潮!各大网店和书店有售,欢迎购买,京东自营链接:http:/ ...
Java编程思想第四版学习总结
Java编程思想第四版学习总结文章目录 Java编程思想第四版学习总结第 1 章对象入门 1.1 抽象的进步 1.2 对象的接口 1.3 实现方案的隐藏 1.4 方案的重复使用 1.5 继承:重 ...
《Java编程的逻辑》阅后心得
<Java编程的逻辑> Java编程的逻辑第一部分编程基础与二进制第一章编程基础 1.1 数据类型和变量 1.2 赋值 1.2.1 基本类型 1.2.2 数组类型 1.3 基本运算 ...

读书笔记：Java 编程的逻辑（四）

面向对象

第4章类的继承

4.1 基本概念

4.1.1 根父类 Object

4.1.2 方法重写

4.2 继承的细节

4.2.2 重名与静态绑定

4.2.3 重载和重写

4.2.4 父子类型转换

4.2.5 继承访问权限 protected

4.2.6 可见性重写

4.2.7 防止继承 final

4.3 继承实现的基本原理

4.3.1 类加载过程

4.3.2 对象创建的过程

4.4 为什么说继承是把双刃剑

4.4.1 继承破坏封装

4.4.3 继承没有反映 is-a 关系

4.4.4 如何应对继承的双面性

读书笔记：Java 编程的逻辑（四）相关推荐

最新文章

热门文章

读书笔记：Java 编程的逻辑（四）

面向对象

第4章 类的继承

4.1 基本概念

4.1.1 根父类 Object

4.1.2 方法重写

4.2 继承的细节

4.2.2 重名与静态绑定

4.2.3 重载和重写

4.2.4 父子类型转换

4.2.5 继承访问权限 protected

4.2.6 可见性重写

4.2.7 防止继承 final

4.3 继承实现的基本原理

4.3.1 类加载过程

4.3.2 对象创建的过程

4.4 为什么说继承是把双刃剑

4.4.1 继承破坏封装

4.4.3 继承没有反映 is-a 关系

4.4.4 如何应对继承的双面性

读书笔记：Java 编程的逻辑（四）相关推荐

最新文章

热门文章

第4章类的继承