类的继承

1、继承的特点

Java的继承通过extends关键字来实现，Java的继承具有单继承的特点，每个子类只有一个直接父类。

子类继承父类，将可以获得父类的全部属性和方法。值得指出的是：java的子类不能获得父类的构造器。

下面程序示范了子类继承父类的特点,下面是Fruit类的代码：

[java] view
plaincopy

public class Fruit {  

  

    public double weight;  

    public void info(){  

        System.out.println("我是一个水果，重" + weight + "g!");  

    }  

}  

接下来是定义的Fruit类的子类Apple：

[java] view
plaincopy

public class Apple extends Fruit{  

  

    public static void main(String[] args) {  

        Apple apple = new Apple();  

        //apple的本身没有weight属性，因为其父类有weight属性，可以访问apple对象的属性  

        apple.weight = 8;  

        apple.info();//打印的结果：我是一个水果，重8.0g!  

    }  

}  

上面的Apple类本来只是一个空类，它只包含了一个main方法，但程序中创建了Apple对象之后，就可以访问该Apple对象的weight

属性和info（）方法，这表明Apple对象也具有了weight属性和info方法。这就是继承的作用。

2、重写父类的方法

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

[java] view
plaincopy

public class Bird {  

  

    public void fly(){  

        System.out.println("我在天空中自由的翱翔");  

    }  

}  

下面再定义一个Ostrich类，这个类扩展了Bird类，重写了Bird类的fly方法：

[java] view
plaincopy

public class Ostrich extends Bird{  

  

    public void fly(){  

        System.out.println("我只能在地上跑");  

    }  

      

    public static void main(String[] args) {  

        Ostrich os = new Ostrich();  

        os.fly();//输出：我只能在地上跑  

    }  

}  

执行上面的程序，将看到执行os.fly()方法执行的不再是Bird的fly方法，而是执行Ostrich的fly方法。

这种子类包含于父类同名的方法的现象被成为方法重写。也可以说子类重写了父类的方法。

方法的重写要遵循“两同两小一大”规则，“两同”即方法名相同、形参列表相同，“两小”指的是子类方法返回值类型比父类的方法

返回值类型更小或相等，子类方法声明抛出的异常应比父类方法声明抛出的异常更小或相等。“一大”指的子类方法的访问

权限应比父类方法更大或相等，尤其需要指出的是，覆盖方法和被覆盖方法要么都是类方法，要么都是实例方法，不能一个

是类方法，一个是实例方法。例如如下代码将会引发编译错误：

[java] view
plaincopy

class BaseClass{  

    public static void test(){...}  

}  

  

class SubClass extends BaseClass{  

    public void test(){...}  

}  

当子类覆盖了父类方法后，子类的对象将无法访问父类中被覆盖的方法，但还可以在子类方法中调用父类中被覆盖方法。

如需在子类方法中调用父类中被覆盖方法，可以使用super（被覆盖的是实例方法）或者父类类名（被覆盖方法是类方法）

作为调用者来调用父类中被覆盖方法。

如果父类方法具有private访问权限，则该方法对其子类是隐藏的，因此子类无法访问该方法，也就是无法重写该方法。

如果子类中定义了一个与父类private方法具有相同方法名，相同形参，相同返回值类型的方法，依然不是重写，只是在子类中

重新定义了一个新方法，例如下面的代码是正确的：

[java] view
plaincopy

class BaseClass{  

    private void test(){...}  

}  

class SubClass extends BaseClass{  

    public static void test(){...}  

}  

3、父类实例的super引用

如果需要在子类方法中调用父类被覆盖的实例方法，可以使用super作为调用者来调用父类被覆盖的实例方法。为上面的Ostrich

类添加一个方法，在这个方法调用Bird中被覆盖的fly方法。

[java] view
plaincopy

public class Ostrich extends Bird{  

  

    public void fly(){  

        System.out.println("我只能在地上跑");  

    }  

      

    public static void main(String[] args) {  

        Ostrich os = new Ostrich();  

        os.fly();//输出：我只能在地上跑  

          

        os.callOverrideMethod();//输出：我在天空中自由的翱翔  

    }  

      

    private void callOverrideMethod(){  

        //在子类方法中通过super显示调用父类被覆盖的实例方法。  

        super.fly();  

    }  

      

}  

通过callOverrideMethod方法的帮助，就可以让Ostrich对象即可以调用覆盖的fly方法，也可以调用Bird类中被覆盖的方法。

super是Java提供的一个关键字，它是直接父类对象的默认引用。例如上面Bird类中定义的fly方法是一个实例方法，需要

通过Bird对象来调用该方法。而callOverrideMethod方法通过super就可以调用这个方法，可见super引用了一个Bird对象。

正如this不能出现在static修饰的方法中一样，super也不能出现static的方法中。static修饰的方法属于类的，该方法

调用者可能是一个类，而不是对象，也就不存在对应的父对象了，因此super引用也就失去了意义。

如下面的一个程序代码：

[java] view
plaincopy

public class P2 extends P1{  

  

    public static void main(String[] args) {  

        P2 p2 = new P2();  

//      p2.getName();  

          

        //例如下面这样写肯定会报编译错误的  

//      this.getName();    

    }  

      

    public void getName(){  

        System.out.println("我是XX");  

    }   

}     

P2类中直接用this调用getName方法报编译错误

与this引用类似的是，如果在构造器中使用super引用，则super引用指向该构造器正在初始化的对象所对应的父类对象。

如果子类定义了和父类同名的属性，也会发生子类属性覆盖父类属性的情形，正常情况下，子类里定义的方法、子类属性

直接访问该属性，都会访问到覆盖属性，无法访问到父类被覆盖的属性。但在子类定义的实例方法中可以通过super来访问

父类被覆盖的属性。跟上面讲到的在子类Ostrich中通过callOverrideMethod实例方法来访问Bird类中被覆盖的fly方法

[java] view
plaincopy

public class BaseClass {  

  

    public int a = 5;  

    public int b=9;  

}  

[java] view
plaincopy

public class SubClass extends BaseClass{  

  

    public int a = 7;  

      

    public void accessOwner(){  

        System.out.println(a);  

    }  

      

    public void accessBase(){  

        System.out.println(super.a);  

        System.out.println(b);//子类没有覆盖父类的属性，可以直接调用  

    }  

      

    public static void main(String[]args){  

        SubClass sb = new SubClass();  

        sb.accessOwner();//输出7  

        sb.accessBase();//输出5  

          

    }  

      

}  

4、调用父类的构造器

子类不会获得父类的构造器，但有时候子类构造器需要调用父类构造器的初始化代码。

在一个构造器中调用另一个重载的构造器使用this调用来实现，在子类构造器中调用父类构造器使用super来实现

看下面的程序:

[java] view
plaincopy

public class Base {  

  

    public double size;  

    public String name;  

      

    public Base(double size,String name){  

        this.size = size;  

        this.name = name;  

    }  

}  

[java] view
plaincopy

public class Sub extends Base{  

  

    public String color;  

      

    public Sub(double size, String name) {  

        super(size, name);  

    }  

  

    public Sub(double size,String name,String color){  

        //通过super调用父类构造器的初始化过程  

        super(size,name);  

          

        //this调用和super调用不能同时出现，下面代码出现编译错误  

//      this(size,name);  

          

          

        this.color = color;  

    }  

      

    public static void main(String[]args){  

        Sub s = new Sub(2.3, "测试测试", "黑色");  

        System.out.println(s.size + "--" + s.name + "--" + s.color);  

    }  

}  

从上面的程序中不难看出，使用super调用父类构造器也必须出现在子类构造器执行体的第一行，所以this调用和super调用

不会同时出现。

不管我们是否使用super调用来执行父类构造器的初始化代码，子类构造器总会调用父类的构造器一次。子类构造器调用父类

构造器分如下几种情况：

== 子类构造器执行体的第一行代码使用super显示调用父类的构造器，系统根据super调用里传入的实参列表调用父类对应的

构造器。

== 子类构造器执行体的第一行代码使用this显示调用本类中重载的构造器，系统将根据this调用里传入的实参列表调用本

类另一个构造器，执行本类中另一个构造器时即会调用父类的构造器。

== 子类构造器执行体中即没有super引用，也没有this掉用，系统将会在执行子类构造器之前，隐式调用父类无参的构造器。

不管上面哪一种情况，当调用子类构造器来初始化子类对象时，父类构造器总会在子类构造器之前执行，不仅如此，执行父类

构造器时，系统会再次上溯执行其父类的构造器...以此类推，创建任何Java对象时，最先执行的总是java.lang.Object类的

构造器。

下面定义了3个类，它们之间有严格的继承关系，通过这种继承关系可以看到构造器之间的调用关系。

[java] view
plaincopy

public class Creature {  

      

    public Creature(){  

        System.out.println("Creature无参构造器");  

    }  

}  

[java] view
plaincopy

public class Animal extends Creature{  

  

    public Animal(String name){  

        System.out.println("Animal带一个参数的构造器，该动物的name为" + name);  

    }  

      

    public Animal(String name,int age){  

        this(name);  

        System.out.println("Animal带两个参数的构造器，其age为" + age);  

    }  

      

}  

[java] view
plaincopy

public class Wolf extends Animal{  

  

    public Wolf(){  

        super("灰太狼", 12);  

        System.out.println("Wolf无参数的构造器");  

    }  

      

    public static void main(String[] args) {  

        new Wolf();  

    }  

  

}  

运行程序可以看到如下输出结果：

Creature无参构造器

Animal带一个参数的构造器，该动物的name为灰太狼

Animal带两个参数的构造器，其age为12

Wolf无参数的构造器