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

最新推荐文章于 2024-09-14 18:46:05 发布

fangzhan666

最新推荐文章于 2024-09-14 18:46:05 发布

阅读量102

点赞数

分类专栏： Java 基础文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/fangzhan666/article/details/120656543

版权

Java 基础专栏收录该内容

38 篇文章 1 订阅

订阅专栏

面向对象

第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;
    }

    @Override
    protected 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 修饰符；
      - 写文档，说明可重写方法的实现机制，为子类提供指导，告诉子类应该如何重写；
      - 在基类修改可能影响子类时，写修改说明。
  - 基类、子类都是我们写的。