什么是继承

继承是面向对象的三大特征之一，是实现代码复用的重要手段。

Java的继承通过extends关键字实现，实现继承的类称为子类，被继承的类称为父类（或者基类、父类）。

继承的语法如下：

 访问修饰符 class SubClass extends SuperClass{ //类定义部分 }

子类继承了父类，将获得父类的全部成员变量和方法，但是不能获得父类的构造器。

下面程序演示子类继承父类。

先定义一个父类：

 /** * Person类，作为父类 */ public class Person { ​ String name; ​ int age; ​ public void eat() { System.out.println("吃饭"); } ​ }

再定义一个子类，继承自上面已经定义好的父类：

 /** * Man子类，继承Person父类 */ public class Man extends Person {  }

再定义一个测试类：

 public class Test { ​ public static void main(String[] args) { Man man = new Man(); ​ // Man类本身并未定义name和age属性，但可以访问，说明Man继承了来自其父类的man和age属性 man.name = "Java"; man.age = 18; ​ // eat方法也继承自其父类 man.eat(); } ​ }

上面代码说明：当一个子类继承了一个父类，将获得父类的全部成员变量和方法。

做为子类，也可以有自己单独的成员变量和方法，其和父类构成了一般和特殊的关系。如，可以在上面的Man类添加自己的属性和方法：

 /** * Man子类，继承Person父类 * 添加自己的属性和方法，这样一样，这个类的对象就拥有了父类的成员变量、方法和自己类中的成员变量、方法 */ public class Man extends Person { boolean isRich; ​ public void earnMoney() { System.out.printf("男人要赚钱"); } }

Java的继承特点

在Java语言中，每个类只有一个直接父类，是单继承的。例如下面代码编译会报错：

 class SubClass extends SuperClass1, SuperClass2,SuperClass3...

但是，可以有多个间接父类，如：

 public class Man extends Person{...} public class Person extends Creature{...}

上面代码中，Creature是Person的直接父类，是Man的间接父类。

如果定义一个类时，没有显式地声明其直接父类，则这个类默认继承自java.lang,Object类。Object类是所有类的父类，要么是直接父类，要么是间接父类。

方法的重写

子类扩展了父类，是父类的一个特殊实现。当从父类继承来的方法不满足子类时，可以重写父类的方法。

下面程序先定义了一个Bird父类如下：

 /** * Person类，作为父类 */ public class Person {  public void eat() { System.out.println("人吃饭"); } ​ }

下面再定义一个Man类，这个类扩展了Person类，重写了Person类的eat()方法。

 /** * Man子类，继承Person父类 */ public class Man extends Person {  // 子类重写了父类的eat()方法 @Override public void eat() { System.out.println("男人要吃很多饭"); } ​ }

再写一个测试类：

 public class Test { ​ public static void main(String[] args) { Man man = new Man(); // 输出为：男人要吃很多饭 man.eat(); } ​ }

可以看到，程序执行的是Man类中的eat()方法，而不是Person类的eat()方法。

像上面这种子类和父类包含有相同名称、相同参数列表的现象被称为方法的重写(Override)，也被称为方法的覆盖。可以说子类重写了父类的方法，也可以说父类的方法被子类覆盖了。

方法的重写要遵循”两同两小一大“规则，即：

”两同“：方法名相同，参数列表相同“两小”：子类方法返回值类型应比父类方法返回值类型小或相等，子类方法声明抛出的异常应比父类小或相等”一大“：子类方法的访问权限应比父类的大或相等。

super关键字

前文提到，子类可以重写父类的方法。当子类覆盖了父类方法后，子类对象将无法访问父类被重写的方法，但可以通过super关键字在子类对象的方法中访问父类被重写的方法。

代码是这样的：

 /** * Man子类，继承Person父类 */ public class Man extends Person { ​ @Override public void eat() { // 可以在子类的方法中调用父类被覆盖的方法 super.eat(); System.out.println("男人要吃很多饭"); } ​ } ​

如果子类定义了和父类同名的实例变量，则在子类实例方法中将无法访问父类的该变量，这是因为被子类实例同名的实例变量隐藏了，这时候可以通过super关键字来访问。如下代码所示。

 class BaseClass{ public int a = 5; } ​ public class SubClasss extends BaseClass{ public int a = 7;  public void accessSubVar() { System.out.println(a); }  public void accessBaseVar() { System.out.print(super.a); }  public static void main(String[] args) { SubClasss s = new SubClasss(); s.accessSubVar(); // 输出7 s.accessBaseVar(); // 输出5 }  }

当程序创建一个子类对象时，系统不仅会为该类中定义的实例变量分配内存，也会为它从父类继承来的所有实例变量分配内存，即使子类定义了和父类同名的实例变量。也就是说，当系统创建一个Java对象时，如果该Java类有两个父类（一个直接父类A，一个间接父类B），假设A类中定义了2个实例变量，B类中定义了3个实例变量，自己子类中定义了2个实例变量，那么这个Java对象共有2+3+2个实例变量。

此外，super关键字还可以用来调用父类构造器。

 class Base { public double size; public String name; public Base(double size, String name) { this.size = size; this.name = name; } } ​ public class Sub extends Base { public String color;  public Sub(double size, String name, String color) { // 使用super关键字显式调用父类构造器 super(size, name); this.color = color; } }

如果我们在子类构造器中未显式调用父类构造器，则会隐式调用父类无参数的构造器。

 class Person { ​ public Person() { System.out.println("父类构造器执行。。。"); } ​ } ​ public class Man extends Person { ​ public Man() { System.out.println("子类构造器执行。。。"); }  public static void main(String[] args) { // 执行Man类的构造器时，会先执行其父类的构造器 // 所以输出结果为：父类构造器执行。。。子类构造器执行。。。 Man man = new Man(); } ​ }

所以，调用子类构造器时，总是会先调用其父类的构造器，如果父类还继承自别的间接父类，则会依次往上追溯执行构造器。Object是所有类的父类，所以，构造任何Java对象时，总会先执行Object类的构造器。