继承和多态

Java 语言摒弃了 C++ 中难以理解的多继承特征，即 Java 不支持多继承，只允许一个类直接继承另一个类，即子类只能有一个直接父类， extends 关键字后面只能有一个类名。

如果定义一个 Java 类时并未显示指定这个类的直接父类，则这个类默认继承 java.lang.Object 类。

使用继承的注意点：

• 子类一般比父类包含更多的属性和方法；
• 父类中的 private 成员在子类中是不可见的，因此在子类中不能直接使用它们；
• 父类和其子类间必须存在“是一个”即 is-a 的关系，否则不能用继承；
• Java 只允许单一继承。

在面向对象语言中，继承是必不可少的、非常优秀的语言机制，它有如下优点：

• 实现代码共享，减少创建类的工作量，使子类可以拥有父类的方法和属性；
• 提高代码维护性和可重用性；
• 提高代码的可扩展性，更好的实现父类的方法。

所有事物有其好的一面，也有其不好的一面，继承的缺点如下：

• 继承是侵入性的，只要继承，就必须拥有父类的属性和方法；
• 降低代码灵活性，子类拥有父类的属性和方法后多了些约束；
• 增强代码耦合性（ 开发项目的原则为高内聚低耦合 ），当父类的常量、变量和方法被修改时，需要考虑子类的修改，有可能导致大段的代码重构。

由于子类不能继承父类的构造方法，因此，如果要调用父类的构造方法，可以使用 super 关键字。 super 可以用来访问父类的构造方法、普通方法和属性。

super 关键字的功能：

• 在子类的构造方法中显示的调用父类构造方法；
• 访问父类的成员方法和变量。

1. super 调用父类构造方法

super 关键字可以在子类的构造方法中显式地调用父类的构造方法，基本格式如下：

super(parameter-list);

其中， parameter-list 指定了父类构造方法中的所有参数。 super() 必须在子类构造方法的方法体的第一行。

我们来看一段代码，声明父类 Person 和子类 Student ，在 Person 类中定义一个带有参数的构造方法，如下：

1: public class Person {
2:     public Person(String name) {
3: 
4:     }
5: }
6: public class Student extends Person {
7: 
8: }

上述代码会出现 Student 类的编译错误，提示必须显式定义构造方法，错误信息如下：

Implicit super constructor Person() is undefined for default constructor. Must define an explicit constructor.

为什么会出现这个错误呢？

本例中，JVM 默认给 Student 类加了一个无参构造方法，而在这个方法中默认调用了 super() ，但是 Person 类中并不存在该构造方法，所以会编译错误。

*小结一下：
如果一个类中没有写任何的构造方法，JVM 会生成一个默认的无参构造方法。在继承关系中，由于在子类的构造方法中，第一条语句默认为调用父类的无参构造方法（即默认为 super() ，一般这行代码省略了）。所以当在父类中定义了有参构造方法，但是没有定义无参构造方法时，编译器会强制要求我们定义一个相同参数类型的构造方法。

2. super 访问父类成员

当子类的成员变量或方法与父类同名时，可以使用 super 关键字来访问。

如果子类重写了父类的某一个方法，即子类和父类有相同的方法定义，但是有不同的方法体，此时，我们可能通过 super 来调用父类里面的这个方法。

使用 super 访问父类中的成员与 this 关键字的使用类似，只不过它引用的是子类的父类 ，语法格式如下：

super.member

3. super 和 this 的区别

this 指的是当前对象的引用， super 是当前对象的父对象的引用。如果构造方法的第一行代码不是 this() 和 super() ，则系统会默认添加 super() 。

关于 Java 中 super 和 this 关键字的异同，可简单总结为以下几条：

（1）子类和父类中变量或方法名称相同时，用 super 关键字来访问。可以理解为 super 是指向自己父类对象的一个指针，在子类中调用父类的构造方法。

（2） this 是自身的一个对象，代表对象本身，可以理解为 this 是指向对象本身的一个指针，在同一个类中调用其它方法。

（3） this 和 super 不能同时出现在一个构造方法里面，因为 this 必然会调用其它的构造方法，其它构造方法中肯定会有 super 语句存在，所以在同一个构造方法里面有相同的语句，就失去了语句的意义，编译器也不会通过。

（4） this() 和 super() 都指的是对象，所以，均不可以在 static 环境中使用，包括 static 变量、 static 方法和 static 语句块。

（5）从本质上讲， this 是一个指向对象本身的指针，然而 super 是一个 Java 关键字。

将一个类型强制转换成另一个类型的过程被称为 类型转型 ，这里所说的 对象类型转型 ，是指 存在继承关系 的对象，不是任意类型的对象。当对不存在继承关系的对象进行强制类型转换时，会抛出 Java 强制类型转换（ java.lang.ClassCastException ）异常。

Java 语言允许某个类型的引用变量引用子类的实例，而且可以对这个变量进行转换。

Java 中引用类型之间的类型转换（前提是两个类是父子关系）主要有两种，分别的向上转型（upcasting）和向下转型（downcasting）。

（1）向上转型

父类引用指向子类对象为向上转型，语法格式如下：

fatherClass obj = new sonClass();

其中， fahterClass 是父类名称或接口名称， obj 是创建的对象， sonClass 是子类名称。

向上转型就是把子类对象赋给父类引用，不用强制转换。使用向上转型可以调用父类类型中的所有成员， 不能调用子类类型中特有成员 ，最终运行效果看子类的具体实现。

（2）向下转型

与向上转型相反，子类对象指向父类引用向下转型，语法格式如下：

sonClass obj = (sonClass) fahterClass;

向下转型可以调用子类类型中所有成员，不过需要注意的是：

如果父类引用对象指向的是子类对象，那么在向下转型的过程中是安全的，也就是编译是不会出错误。

但是如果父类引用对象是父类本身，那么在向下转型的过程中是不安全的，编译不会出错，但是运行时会出现我们开始提到的 Java 强制类型转换异常，一般使用 instanceof 运算符来避免出此类错误。

例如，Animal 类表示动物类，该类对应的子类有 Dog 类，使用对象类型表示如下：

1: Animal animal = new Dog();      // 向上转型，把 Dog 类型转换为 Animal 类型
2: Dog dog = (Dog) animal;         // 向下转型，把 Animal 类型转换为 Dog 类型

我们来看一个具体的示例演示对象类型的转换。例如，父类 Animal 和子类 Cat 中都定义了实例变量 name 、静态变量 staicName 、实例方法 eat() 和静态方法 staticEat() 。此外，子类 Cat 中还定义了实例变量 str 和实例方法 eatMethod() 。

父类 Animal 的代码如下：

 1: public class Animal {
 2:     public string name = "Animal: 动物";
 3:     public static String staticName = "Animal: 可爱的动物";
 4: 
 5:     public void eat() {
 6:         System.out.println("Animal: 吃饭");
 7:     }
 8: 
 9:     public static void staticEat() {
10:         System.out.println("Animal: 动物在吃饭");
11:     }
12: }

子类 Cat 的代码如下：

 1: public class Cat extends Animal {
 2:     public String name = "Cat: 猫";
 3:     public String str = "Cat: 可爱的小猫";
 4:     public static String staticName = "Dog: 我是喵星人";
 5: 
 6:     public void eat() {
 7:         System.out.println("Cat: 吃饭");
 8:     }
 9: 
10:     public static void staticEat() {
11:         System.out.println("Cat: 猫在吃饭");
12:     }
13: 
14:     public void eatMethod() {
15:         System.out.println("Cat: 猫喜欢吃鱼");
16:     }
17: 
18:     public static void main(String[] args) {
19:         Animal animal = new Cat();
20:         Cat cat = (Cat) animal;                // 向下转型
21: 
22:         System.out.println(animal.name);       // 输出 Animal 类的 name 变量 → Animal: 动物
23:         System.out.println(animal.staticName); // 输出 Animal 类的 staticName 变量 → Animal: 可爱的动物
24: 
25:         animal.eat();                          // 输出 Cat 类的 eat() 方法 → Cat: 吃饭
26:         animal.staticEat();                    // 输出 Animal 类的 staticEat() 方法 → Cat: 动物在吃饭
27: 
28:         System.out.println(cat.str);           // → 调用 Cat 类的 str 变量 → Cat: 可爱的小猫
29:         cat.eatMethod();                       // → 调用 Cat 类的 eatMethod 变量 → Cat: 猫喜欢吃鱼
30:     }
31: }

通过引用类型变量来访问所引用的属性和方法时，Java 虚拟机将采用以下绑定规则：

• 实例方法与引用变量实际引用的对象的方法进行绑定，这种绑定属于 动态绑定 ，因为是在 运行时 由 Java 虚拟机动态决定的。例如， animal.eat() 是将 eat() 方法与 Cat 类相绑定；
• 静态方法与引用变量所声明的类型的方法绑定，这种绑定属于静态绑定，因为是在 编译阶段 已经做了绑定。例如， animal.staticEat() 是将 staticEat() 方法与 Animal 类进行绑定；
• 成员变量（包括静态变量和实例变量）与引用变量所声明的成员变量绑定，这种绑定属于静态绑定，因为在编译阶段已经做了绑定。例如， animal.name 和 animal.staticName 都是与 Animal 类进行绑定。

Java 允许同一个类中定义多个同名方法，只要它们的形参列表不同即可。

如果同一个类中包含了两个或两个以上方法名相同，但形参列表不同的方法，这种情况称为 方法重载 （overload）。

如：在 JDK 的 java.io.PrintStream 中定义了十多个同名的 println() 方法。

1: public void println(int i) { ... }
2: public void println(double d) { ... }
3: public void println(String s) { ... }

这些方法完成的功能类似，都是格式化输出。根据参数的不同来区分它们，以进行不同的格式化处理和输出。它们之间就构成了方法的重载。实际调用时，根据实参的类型来决定调用哪一个方法。

*注：方法重载的要求是两同一不同：同一个类中方法名相同，参数列表不同。至于方法的其他部分，如方法返回值、修饰符等，与方法重载没有任何关系。

使用方法重载其实就是避免出现繁多的方法名，有些方法的功能是相似的，如果重新建立一个方法，重新取个方法名称，会降低程序可读性。

在子类中如果创建一个与父类中相同名称、相同返回值类型、相同参数列表的方法，只是方法体中的实现不同，以实现不同于父类的功能，这种方式被称为 方法重写 （override），又称为方法覆盖。

当父类中的方法无法满足子类需求或子类具有特有功能的时候，就需要方法重写。子类可以根据需要，定义特定于自己的行为。既沿袭了父类的功能名称，又根据子类的需要重新实现父类方法，从而进行扩展增强。

在重写方法时，需要遵循下面的规则：

• 参数列表必须完全与被重写的方法参数列表相同；
• 返回的类型必须与重写的方法的返回类型相同（Java 1.5 之后放宽了限制，返回值类型必须小于或等于父类方法的返回值类型）；
• 访问权限不能比父类中被重写方法的访问权限更低（public > protected > default > private）；
• 重写方法一定不能抛出新的检查异常或者比被重写方法声明更加宽泛的检查型异常。例如，父类的一个方法声明了一个检查异常 IOException ，在重写这个方法时就不能抛出 Exception ，只能抛出 IOExeption 的子类异常，可以抛出非检查异常。

另外还要注意以下几条：

• 重写的方法可以使用 @Override 注解来标识；
• 父类的成员方法只能被它的子类重写；
• 声明为 final 的方法不能被重写；
• 声明为 static 的方法不能被重写，但是能够再再次声明；
• 构造方法不能被重写；
• 子类和父类在同一个包中时，子类可以重写父类的所有方法，除了声明为 private 和 final 的方法；
• 子类和父类不在同一个包中时，子类只能重写父类的声明为 public 和 protected 的非 final 方法；
• 如果不能继承一个方法，则不能重写这个方法。

如果子类中创建了一个成员变量，而该变量的类型和名称都与父类中的同名成员变量相同，我们则称作变量隐藏。

Java 接口的定义方式与类基本相同，不过接口定义的关键字是 interface ，接口定义的语法格式如下：

[public] interface interface_name [extends interface1_name[, interface2_name,...]] {
    // 接口体，其中可以包含定义常量和声明方法
    [public] [static] [final] type constant_name = value;        //定义常量
    [public] [abstract] returnType method_name (parameter_list); //声明方法
}

下面对以上语法做一些说明：

• public 表示接口的修饰符，当没有修饰符时，则使用默认的修饰符，此时该接口的访问权限仅局限于所属的包；
• interface_name 表示接口的名称；
• extents 表示接口的继承关系；
• interface1_name 表示要继承的接口名称；
• constant_name 表示变量名称，一般是 static 和 final 型的；
• return_type 表示方法返回值的类型；
• parameter_list 表示参数列表，在接口中的方法是没有方法体的。

*注：一个接口可以有多个直接父接口，但接口只能继承接口，不能继承类。

接口对于其声明、变量和方法都做了许多限制，这些限制作为 接口的特征 如下：

• 具有 public 访问控制符的接口，允许任何类使用，否则其访问权限局限 于所属的包；
• 方法的声明不需要其他修饰符，在接口中声明的方法，将隐式地声明为公有的（ public ）和抽象的（ abstract ）；
• 在 Java 接口中声明的变量其实都是常量，接口中的变量声明，将隐式地声明为 public、static 和 final ，即常量，所以接口中定义的变量 必须初始化 ；
• 接口没有构造方法，不能被实例化。

*注：一个接口不能够实现另一个接口，只可以继承接口，子接口可以对父接口的方法和常量进行重写。

1: public interfact StudentInterface extends PeopleInterface {
2:     int age = 25;               // 常量 age 重写父类接口中的 age 常量
3:     void getInfo();             // 方法 getInfo() 重写父接口中的 getInfo() 方法
4: }

接口的主要用途就是被实现类实现 ，一个类可以实现一个或多个接口，继承使用 extends 关键字，实现则使用 implements 关键字。一个类可以实现多个接口，类实现接口的语法格式如下：

<public> class <class_name> [extends superclass_name] [implements interface1_name[, interface2_name...]] {
    // 主体
}

实现接口需要注意以下几点：

• 实现接口与继承父类相似，一样可以获得所实现接口里定义的常量和方法。如果一个类需要实现多个接口，则多个接口之间可以逗号分隔；
• 一个类可以继承一个父类，并同时实现多个接口， implements 部分必须放在 extends 部分之后；
• 一个类实现了一个或多个接口之后，这个类必须完全实现这些接口里所定义的全部抽象方法（也就是重写这些抽象方法）；否则，该类将保留从父接口那里继承到的抽象方法，该类也必须定义成抽象类。

来看一个具体的例子吧。

在程序的开发中，需要完成两个数的求和运算和比较运算功能的类非常多，所以可以定义一个接口来将类似的功能组织在一起。

（1）创建一个名称为 IMath 的接口：

1: public interface IMath {
2:     public int sum();                // 完成两个数的相加
3:     public int maxNum(int a, int b); // 获取较大的数
4: }

（2）定义一个 MathClass 类并实现 IMath 接口：

 1: public class MathClass implements IMath {
 2:     private int num1;
 3:     private int num2;
 4:     public MathClass(int num1, int num2) {
 5:         // 构造方法
 6:         this.num1 = num1;
 7:         this.num2 = num2;
 8:     }
 9:     // 实现接口中的求和方法
10:     public int sum() {
11:         return num1 + num2;
12:     }
13:     // 实现接口中的获取较大数的方法
14:     public int maxNum(int a, intb) {
15:         if (a >= b) {
16:             return a;
17:         } else {
18:             return b;
19:         }
20:     }
21: }

在实现类中，所有的方法都使用了 public 访问修饰符声明。无论何时实现一个由接口定义的方法，它都必须实现为 public ，因为接口中的所有成员都显示声明为 public 。

（3）最后创建一个测试类 NumTest ，实例化接口的实现类 MathClass ，调用该类中的方法并输出结果：

1: public class NumTest {
2:     public static void main(String[] args) {
3:         MathClass calc = new MathClass(100, 300);
4:         System.out.println(calc.sum());            // → 400
5:         System.out.println(calc.maxNum(100, 300)); // → 300
6:     }
7: }