读书笔记--Java语言程序设计

第11章 继承和多态

11.1 引言

面向对象的编程允许你从已经存在的类中定义新的类，这称为继承。

11.2 父类和子类

继承使得你可以定义一个通用的类（即父类），之后扩充该类为一个更加特定的类（即子类）。

使用类来对同一类型的对象建模。不同的类也可能会有一些共同的特质和行为，这些共同的特质和行为都统一放在一个类中，它是可以被其他类所共享的。你可以定义特定的类继承通用类中的特征和方法。

在Java术语中，如果类C1扩展自另一个类C2，那么就称C1为次类(subclass)，将C2称为超类(superclass)。超类也称为父类(parent class)或基类(base class)，次类又称为子类(child class)，扩展类(extended class)或派生类(derived class)。子类从它的父类中继承可访问的数据域和方法，还可以添加新数据域和方法。

和传统的理解不同，子类并不是父类的一个子类，实际上，一个子类通常比它的父类包含更多的信息和方法。

父类的私有数据域在该类之外是不可访问的，因此，不能在子类中直接使用，但是，如果父类中定义了公共的访问器/修改器，那么可以通过这些公共的访问器/修改器来访问和修改它们。

不是所有的“是一种”（is-a）关系都该用继承来建模。

继承是用来为“是一种”（is-a）建模的。不要仅仅为了重用方法这个原因而盲目地扩展一个类。一个父类和它的子类之间必须存在是“是一种”（is-a）关系。

某些程序设计语言是允许从几个类派生出一个子类的。这种能力称为多重继承（multiple inheritance）。但是在Java中是不允许多重继承的。一个Java类只可能直接继承自一个父类。这种限制称为单一继承（single inheritance）。如果使用extends关键字来定义一个子类，它只允许有一个父类。

11.3 使用super关键字

关键字super指代父类，可以用于调用父类中的普通方法和构造方法。

子类继承它的父类中所有可访问的数据域和方法。关键字super是指这个super关键字所在的类的父类。关键字super可以用于两种途径：

1）调用父类的构造方法。

2）调用父类的方法。

11.3.1 调用父类的构造方法

构造方法用于构建一个类的实例。不同于属性和普通方法，父类的构造方法不会被子类继承。它们只能使用关键字super从子类的构造方法中调用。

调用父类构造方法的语法是：super()或者super(parameters);

语句super()调用父类的无参构造方法，而语句super(arguments)调用与参数匹配的父类的构造方法。语句super()和super(arguments)必须出现在子类构造方法的第一行，这是显式调用父类构造方法的唯一方式。

要调用父类构造方法就必须使用关键字super，而且这个调用必须是构造方法的第一条语句。在子类中调用父类构造方法的名字会引起一个错误。

11.3.2 构造方法链

构造方法可以调用重载的构造方法或父类的构造方法。如果它们都没有被显式地调用，编译器就会自动地将super()作为构造方法的第一条语句。

在任何情况下，构造一个类的实例时，将会调用沿着继承链的所有父类的构造方法。当构造一个子类的对象时，子类构造方法会在完成自己的任务之前，首先调用它的父类的构造方法。如果继承自其他类，那么父类构造方法又会在完成自己的任务之前，调用它自己的父类的构造方法。这个过程持续到沿着这个继承体系结构的最后一个构造方法被调用为止。这就是构造方法链(constructor chaining)。

一般情况下，最好能为每个类提供一个无参构造方法，以便于对该类进行扩展，同时避免错误。

11.3.3 调用父类的方法

关键字super不仅可以引用父类的构造方法，也可以引用父类的方法。所用语法如下：

super.方法名（参数）

11.4 方法重写

要重写一个方法，需要在子类中使用和父类一样的签名以及一样的返回值类型来对该方法进行定义。

子类从父类中继承方法。有时，子类需要修改父类中定义的方法的实现，这称作方法重写（method overriding）。

仅当实例方法是可访问时，它才能被覆盖。因为私有方法在它的类本身以外是不可访问的，所以它不能被覆盖。如果子类中定义的方法在父类中是私有的，那么这两个方法完全没有关系。

与实例方法一样，静态方法也能被继承。但是，静态方法不能被覆盖。如果父类中定义的静态方法在子类中被重新定义，那么在父类中定义的静态方法将被隐藏。可以使用语法：父类名.静态方法名（Superclass.staticMethodName）调用隐藏的静态方法。

11.5 方法重写与重载

重载意味着使用同样的名字都是不同的签名来定义多个方法。重写意味着在子类中提供一个都方法的新的实现。

方法重写是指该方法必须使用相同的签名和相同的返回值类型在子类中定义。

方法重写发生在通过继承而相关的不同类中；方法重载可以发生在同一类中，也可以发生在由于继承而相关的不同类中。

方法重写具有同样的签名和返回值类型；方法重载具有同样的名字，都是不同的参数列表。

为了避免错误，可以使用一个特殊的Java语法，称为重写标注（override annotation），在子类的方法前面发一个@override。

该标注表示被标注的地方必须重写父类的一个方法。如果具有该标注的方法没有重写父类的方法，编译器将报告一个错误。如果没有使用重写标注，编译器不会报告错误。使用标注可以避免错误。、

11.6 Object类及其toString()方法

Java中的所有类都继承自java.lang.object类。

如果在定义一个类时没有指定继承性，那么这个类的父类就被默认是Object。

toString()方法的签名是：public String toString()

调用一个对象的toString()会返回一个描述该对象的字符串。默认情况下，它返回一个由该对象所属的类名、at符号（@）以及该对象的描述性字符串。应该重写toString方法，这样，它可以返回一个代表该对象的描述性字符串。

也可以传递一个对象来调用System.out.println(object)或者System,out.print(object)。这等价于调用System.out.println(object.toString())或者System.out.print(object.toString())。

11.7 多态

多态意味着父类的变量可以指向子类对象。

首先，定义两个有用的术语：子类型和父类型。一个类实际上定义了一个类型。子类定义的类型称为子类型（suntype），而父类定义的类型称为父类型（supertype）。

继承关系使一个子类继承父类的特征，并且附加一些新特征。子类是它的父类的特殊化，每个子类的实例都是其父类的实例，但是反过来就不成立。例如：每个圆都是一个几何对象，但并非每个几何对象都是圆。因此，总可以将子类的实例传给需要父类型的参数。

使用父类对象的地方都可以使用子类的对象。这就是通常所说的多态（polymorphism，它源于希腊文字，意思是“多种形式”）。简单来说，多态意味着父类型的变量可以引用子类型的对象。

11.8 动态绑定

方法可以在沿着继承链的多个类中实现，JVM决定运行时调用哪个方法。

方法可以在父类中定义而在子类中重写。例如，toString()方法是在Object类中定义的，而在GeometricObject类中重写。思考下面的代码：

Object o = new GeometricObject();

System.out.println(o.toString()); 

这里的o调用哪个toString()呢？为了这个问题，我们首先介绍两个术语：声明类型和实际类型。一个变量必须被声明为某种类型，变量的这个类型称为它的声明类型(declared）。这里，o的声明类型是object。一个引用类型变量可以是一个null值或者是对一个声明类型实例的引用。实例可以使用声明类型或者它的子类型的构造方法创建。变量的实际类型（actual typr）是被变量引用的对象的实际类。这里，o的实际类型是GeometricObject，因为o指向使用new GeometricObject()创建的对象。o调用哪个toString()方法由o的实际类型决定，这称为动态绑定。

动态绑定机制如下：假设对象o是类C1，C2，...，Cn-1，Cn的实例，其中C1是C2的子类，C2是C3的子类。也就是说，Cn是最通用的类，C1是最特殊的类。在Java中，Cn是Object类。如果对象o调用一个方法p，那么JVM会一词在类C1，C2，...，Cn-1，Cn中查找方法p的实现，知道找到为止。一旦找到一个实现，就停止查找，任何调用这个首先找到的实现。

匹配方法的签名和绑定方法的实现是两个不同的问题。引用变量的声明类型决定了编译时匹配哪个方法。在编译时，编译器会根据参数类型、参数个数和参数顺序找到匹配的方法。一个方法可能在沿着继承链的多个类中实现。Java虚拟机在运行时动态绑定方法的实现，这是由变量的实际类型决定的。

11.9 对象转换和instanceof运算符

对象的引用可以类型转换为对另外一种对象的引用，这称为对象转换。

总是可以将一个子类的实例转换为一个父类的变量，称为向上转换（upcasting)，因为子类的实例永远是它的父类的实例。当把一个父类的实例转换为它的子类变量（称为向下转换（downcasting))时，必须使用转换记号“（子类名）”进行显式转换，向编译器表明你的意图，为使转换成功，必须确保要转换的对象是子类的一个实例。如果父类对象不是子类的一个实例，就会出现一个运行异常ClassCastException。例如：如果一个对象不是Student的实例，它就不能转换成Student类型的变量。因此，一个好的经验是，在尝试转换之前确保该对象是另一个对象的实例。这是可以利用运算符instanceof来实现的。

为了能够进行通用程序设计，一个好的经验是把变量定义为父类型，这样，它就可以接受任何子类型的值。

instanceof是Java的关键字。在Java关键字中的每个字母都是小写的。

为了更好地理解类型转换，可以认为它们类似与水果、苹果、橘子之间的关系，其中水果类Fruit是苹果类Apple和橘子类Orange的父类。苹果是水果，所以，总是可以将Apple的实例安全地赋值给Fruit变量。但是，水果不一定是苹果，所以，必须进行显示转换才能将Fruit的实例赋值给Apple的变量。

只有源对象是目标类的实例时才能进行类型转换。在执行转换钱，程序使用instanceof运算符来确保源对象是否是目标类的实例。

对象成员访问运算符（.）优先于类型转换运算符。使用圆括号保证在点运算（.）之前进行转换。对基本类型值进行转换不同于对对象进行转换。转换基本类型值返回一个新的值。而转换对象引用不会创建一个新的对象。

11.10 Object类的equals方法

如同toString()方法，equals(Object)方法是定义在Object类中的另外一个有用的方法。

在Object类中定义的另外一个经常使用的方法是equals方法。它的签名是：

public boolean equals(Object o)

这个方法测试两个对象是否相等。调用它的语法是：

object1.equals(object2);

Object类中equals方法的默认实现是：

public boolean equals(Object obj) {

    return (this == obj);

}

这个实现使用==运算符检测两个引用变量是否指向同一个对象。因此，应该在自己的客户类中重写这个方法，以测试两个不同的对象是否具有相同的内容。

equals方法在Java API的许多类中被重写，比如Java.lang.String和Java.util.Date，用于比较两个对象的内容是否相等。String类中equals方法继承自Object类，然后在String类中被重写，使之能够检验两个字符串的内容是否相等。

比较运算符==用来比较两个基本数据类型的值是否相等，或者判断两个对象是否具有相同的引用。如果想让equals方法能够判断两个对象是否具有相同的内容，可以在定义这些对象的类时，重写类中的equals方法。运算符==要比equals方法的功能强大些，因为==运算符可以检测两个引用变量是否指向同一个对象。

在子类中，使用签名eqauls(SomeClassName obj) （例如：equals(Circle obj)）重写equals方法是一个常见错误，应该使用equals(Object obj)。

11.11 ArrayList类

ArrayList对象可以用于存储一个对象列表。

ArrayList是一种泛型类，具有一个泛型类型E。创建一个ArrayList时，可以指定一个具体的类型来替换E。例如，下面语句创建一个ArrayList，并且将其引用赋值给变量cities。该ArrayList对象可以用于存储字符。

ArrayList cities = new ArrayList();

 

从JDK1.7开始，语句

ArrayList list = new ArrayList();

可以简化为

ArrayList list = new ArrayList<>();

由于使用了称为类型推导的特征，构造方法中不再要求给出具体类型。编译器可以从变量的声明中推到出类型。

操作	数组	ArrayList
创建数组/数组列表	String[] a = new String [10]	ArrayList list< String > = new ArrayList()
引用元素	a[index]	liset.get(index)
更新元素	a[index] = "London";	list.set(index, "London");
返回大小	a.length	list.size()
添加一个新元素		list.add("London")
插入一个新元素		list.add(index, "London")
删除一个元素		list.remove(index)
删除一个元素		list.remove(Object)
删除所有元素		list.clear()

 

 

 

 

 

 

 

 

 

 

一旦创建了一个数组，它的大小就确定下来了。可以使用方括号访问数组元素（例如：a[index]）。当创建ArrayList后，它的大小为0，如果元素不在数组列表中，就不能使用get(index)和set(index.element)方法。向数组列表中添加、插入和删除元素是比较容易的，而向数组中添加、插入和删除元素是比较复杂的。为了实现这些操作，必须编写代码操纵这个数组。注意，可以使用java.util.Arrays.sort(array)方法来对一个数组排序。如果要对一个数组列表排序。使用java.util.Collections.sort(arrayList)方法。

使用ArrayList来实现某些程序更简单，有以下两个原因：

       ArrayList的大小是灵活的，所以无须提前给定它的大小。而当创建一个数组时，它的大小必须给定。

       ArrayList包含许多有用的方法。比如，可以使用contains方法来测试某个元素是否在列表中。如果使用数组，则需要                    编写额外代码来实现该方法。

可以在数组里使用foreach循环来遍历元素。数组列表中的元素也可以使用foreach循环来进行遍历，语法如下：

for (elementType element: arrayList) {

    // Process the element

}

11.14 protected数据和方法

私有变量只能在类里访问，而公共成员可以被任意的其他类访问。

经常需要允许子类访问定义在父类中的数据域或方法，但不允许非子类访问这些数据域和方法。可以使用protected完成该功能。父类中被保护的数据域或方法可以在它的子类中访问。

修饰符private、protected和public都称为可见性修饰符（visibility modifier）或可访问性修饰符（accessibility modifier），因为它们指定如何访问类和类的成员。这些修饰符的可见性按下面的顺序递增：

 

表总结了类中成员的可访问性。

数据和方法的可见性

类中成员的修饰符	在同一类可访问	在同一包内可访问	在子类内可访问	在不同包可访问
public
protected				---------------------
（default）			---------------------	---------------------
private		------------------------	---------------------	---------------------

 

 

 

 

 

 

使用private修饰符可以完全隐藏类的成员，这样，就不能从类外直接访问它们，不使用修饰符就表示允许同一个包里的如何类直接访问类的成员，但是其他包中的类不可以访问。使用protected修饰符允许任何包中的子类或同一包中的类访问类的成员。使用public修饰符允许任意类访问类的成员。

类可以以两种方式使用：一种是用于创建该类的实例；另一种是通过扩展该类创建它的子类。如果不想从类的外部使用类的成员，就把成员声明成private。如果想让该类的用户都能使用类的成员，就把成员声明成public。如果想让该类的扩展者使用数据和方法，而不想让该类的用户使用，则把成员声明成protected。

修饰符private和protected只能用于类的成员。public修饰符和默认修饰符（也就是没有修饰符）既可以用于类的成员，也可以用于类。一个没有修饰符的类（即非公共类）是不能被其他包中的类访问的。

子类可以重写它的父类的protected方法，并把它的可见性改为public。但是，子类不能削弱父类中定义的方法的可访问性。例如：如果一个方法在父类中定义为public，在子类中也必须定义为public。

11.15 防止扩展和重写

一个被final修饰的类和方法都不能被扩展。被final修饰的数据域是一个常数。

有时候，可能希望防止类扩展。在这种情况下，使用final修饰符表明一个类是最终的，是不能作为父类的。Math就是一个最终类。String、StringBuilder和StringBuffer类也可以是最终类。也可以定义一个方法为最终的，最终方法不能被它的子类重写。

修饰符public、protected、private、static、abstract以及final可以用在类和类的成员（数据和方法）上，只有final修饰符还可以用在方法中的局部变量上。方法内的最终局部变量就是常量。