时间：2018-07-20 作者：魏文应
一、类的继承
什么是继承？
继承，是Java面向对象的三大特征之一。类可以继承其它类的特性。继承的格式如下：
class 类A extends 类B{
}
比如，下面有三个名为 Person、Student、Graduate 的类：
public class Person {
public void eatFood(){
System.out.println("正在吃东西！");
}
}
public class Student extends Person {
public void myPrintln(){
System.out.println("Student print!");
this.eatFood();
}
}
public class Graduate extends Student{
String name;
public String getName(){
return name;
}
}
上面的代码中， Student 继承了 Person 类，这样，Student就 可以使用 Person 类内的方法和属性。同样，Graduate 继承了 Student 类，Graduate 既可以使用 Student的方法和属性，还可以使用 Person的方法和属性：
public class TestExtends {
public static void main(String[] args){
Student p1 = new Student();
p1.eatFood();
Graduate p2 = new Graduate();
p2.eatFood();
p2.myPrintln();
}
}
private 属性和方法不可继承
private 属性的方法和属性，是类私有的，子类不可以使用。比如，下面给 eatFood 方法加上 private 修饰，则子类就不能继承这个方法了：
public class Person {
private public void eatFood(){
System.out.println("正在吃东西！");
}
}
父类只有一个
一个类，只能继承一个父类（就好比一个人只有一个父亲一样）：
public class Student extends Person {
}
而下面这样是错误的，不能同时有两个父类：
public class Student extends Person Animal {
}
类的默认父类
每个类都有父类，就像每个人都有父母一样（除了最原始的那些类）。如果我们不显式地指明继承那个类，那么默认继承的是 Object 类，比如：
public class Student {
}
上这个 Student 类，没有指明继承哪个类，那么，默认就继承Object类：
public class Student extends Object{
}
二、方法的重写
方法的重写发生在子类中。
public class Person {
public void eatFood(){
System.out.println("一般人的吃饭方式！");
}
}
public class Student extends Person {
public void eatFood(){
System.out.println("学生的吃饭方式！");
}
}
public class TestExtends {
public static void main(String[] args){
Student p1 = new Student();
p1.eatFood();
}
}
上面代码中，Student 有自己的 eatFood() 方法，它将不再使用父类 Person 的 eatFood() 方法。即 p1.eatFood() 使用的是 Student 的 eatFood 方法。这就是 方法的重写。方法的 重写规则 如下：
- 要求子类方法的
返回值类型 方法名 （参数列表）与父类方法 保持一致。 - 子类方法的修饰符 不能小于 父类方法的修饰符。
- 若父类方法抛出异常，那么子类方法抛出的异常类型 不能大于 父类方法抛出的异常。
- 子类和父类，必须同为 static类型 或者 非static类型。
三、super 关键字
下面的 Student 类继承了 Person 类：
public class Person {
int id = 1;
}
public class Student extends Person {
int id = 2;
this.id = 3;
super.id = 4;
}
this.id 指的是 Student 类的成员变量 int id = 2; ，super.id 指的是 Person 类的成员变量 int id = 1;。从这个示例可以看出，当子类和父类 有重名 的属性时，属性有super前缀时，说明是父类的属性。属性有this前缀时，说明是当前子类的属性 。如果是方法，也同样适用：
public class Person {
public void show(){
System.out.println("这是父类。");
}
}
public class Student extends Person {
public void show(){
System.out.println("这是子类。");
}
public void test(){
this.show();
super.show();
}
}
super 用于 构造器 ：
super 还可以用类的构造器中。
显式地调用 super 父类构造器
public class Person {
String name;
public Person(String n){
name = n;
System.out.println("这是person构造器。");
}
}
public class Student extends Person {
public Student(){
super("魏文应");
System.out.println("这是Student构造器。");
}
}
上面的 子类Student 中的 super("魏文应"); ，就是使用的就是 父类Person 的构造器 Person(String n)。
默认调用 super 父类构造器
如果 没有显式 地调用 super 构造器，那子类中的构造器会 默认添加super() ，比如：
public class Student extends Person {
public Student(){
System.out.println("这是Student构造器。");
}
}
上面子类的构造器中，没有显式调用 父类 super 构造器。这时，编译器会自动添加 super() ：
public class Student extends Person {
super();
public Student(){
System.out.println("这是Student构造器。");
}
}
从上面可以看出，super() 必须写在子类构造器内部，而且要在类构造器内部代码的最前面，即类构造器内部的第一行代码。正因为 默认情况下，子类使用的是 super() ，所以这就意味着，父类必须有一个 空参构造器，比如父类 Person ：
public class Person {
String name;
public Person(){
name = n;
System.out.println("这是person构造器。");
}
}
为什么最好要有空参构造器？
我们知道，在类中，如果没有显式地定义构造器，编译器会自动添加一个空参构造器。比如下面：
public class Person {
String name;
}
通过编译器以后，会自动添加一个 Person() 构造器：
public class Person {
String name;
public Person(){
super(); // 没父类的类，默认继承Object类。
}
}
如果我们显式地定义了一个构造器，那么，编译器将不再自动添加一个空参构造器。比如下面这个类，就没有 空参构造器：
public class Person {
String name;
public Person(String n){
name = n;
System.out.println("这是person构造器。");
}
}
但是，上面我们说过，子类默认情况下，会使用父类的 空参构造器 super()，如果父类没有空参构造器，这时就会报错。所以，在构造类时，最好有一个空参构造器，以便子类使用 。
为什么说 this() 和 super() 不能同时出现在同一个构造函数中？
public class Person {
}
public class Student extends Person {
public Student(){
super();
System.out.println("这是Student 空参构造器。");
}
public Student(String n){
this();
System.out.println("这是Student 带参构造器。");
}
}
因为 super() 和 this() 都要写在构造器内的第一行，所以不能同时出现在一个构造器中。但是，你会发现，super 父类构造器一定会得到执行 。这也就意味着，每个类的构造器，都会先去执行父类的构造器，然后才开始执行本构造器的内容。
四、子类对象实例化的全过程
比如，我们有下面三个类，依次有继承关系：
public class Animal{
int age;
public Animal(){
age = 12;
}
}
public class Person extends Animal{
String name;
public Person(){
name = "魏文应";
}
}
public class Student extends Person {
int classNum;
public Student(){
classNum = 0911;
}
}
我们实例化一个 Student 对象：
Student s = new Stuent();
实例化的过程中，类的构造器会依次调用父类构造器，也就是下面的效果，Student() 构造器先调用执行Person()，然后才开始执行 classNum = 0911 代码。同样的Person()也是先执行Animal()，才执行 name = "魏文应";：
- 实例化过程
最终的效果是，依次将 age、name、classNum 这三个成员变量在内存堆中创建。也就是 Object() -> Animal() -> Person() -> Student() 这三个构造器依次得到执行。
