第7章 复用类

7.2 继承语法

如果基类没有默认构造函数，那么必须在Derive类的构造函数中显示调用Base类的带参构造函数。

import static java.lang.System.out;
class Base {
  Base(String name){
    out.println("Base constructor");
  }
}

public class Derive extends Base {
  Derive(){
    super("test"); /* If comment out this line, result a compile error*/
  }
  public static void main(String args[]){
  }
}

如果基类具有默认构造函数，那么编译器会帮你在Derive类的构造函数中黯然插入对于基类默认构造函数的掉用。

import static java.lang.System.out;
class Base {
  Base(){
    out.println("Base constructor");
  }
  Base(String name){
    out.println("Base constructor with one parameter");
  }
}

public class Derive extends Base {
  Derive(){
    //super(); /*Compilor inserts this line for you implicity*/
  }
  Derive(String name){
    //super(); /*Compilor inserts this line for you implicity*/
  }
  public static void main(String args[]){
    new Derive();
    new Derive("name");
  }
}/* Output:
Base constructor
Base constructor
*/

7.4 结合使用组合和继承

7.4.2 名称屏蔽

C++中重载只可以发生在水平层面上（即同一个类中，同一个作用域中），英文记做overloading。而一旦这种overloading的表现出现在垂直层面上（即继承体系上，一般是Derive类中声明一个方法的名称与Base类中的某个方法相同），英文记做overriding，也就是说overloading在垂直层面上不存在。而Derive类可以通过override一个在Base类中被声明为virtual的方法（这个方法在Base类和Derive类中的方法签名必须完全相同，亦即function name+parameter list必须完全相同，但return type可以是Base类方法return type的子类。详细参见这里：http://stackoverflow.com/questions/4665117/c-virtual-function-return-type）来实现runtime polymorphism。当overloading出现在处置层面的时候，并且方法没有被标记为virtual，那么父类的方法就被子类覆盖了，记住：被覆盖的不是某一个具体的方法，而是具有这个方法签名的所有方法。

Java中所有的方法默认都是Runtime绑定的，Java中的Overloading可以发生在不同层面上（Derive类中定义的方法与Base类中的相同签名的方法构成overloading），Java中可以用@Override 让Compiler帮助你正确的Override一个方法（你可能错误的进行了overloading）

import static java.lang.System.out;
class Base {
  void f(){}
}
public class Test extends Base {
  @Override
  void f(int i){} /*Result a compile errror unless remove parameter declaration*/  
  public static void main(String args[]){
  }
}

7.8 final关键字

7.8.1 final数据

public class Test{
    private final int a = 1;
      private final int b; //Blank final
    {
        //a = 2; //final data can not reassign
          b = 4;
    }
      
      public Test(){
        //a = 3; //final data can not reassign
    }
    public static void main(String args[]){
          new Test();
    }
}

或者

public class Test{
    private final int a = 1;
      private final int b; //Blank final
      
      public Test(){
        //a = 3; //final data can not reassign
          b = 4;
    }
    public static void main(String args[]){
          new Test();
    }
}

final数据也可以是local的哟～

public class Test{
    public static void main(String args[]){
          final int i;
          i = 3;
          //i = 5; /* This result a compile error */
    }
}

final基本类型的数据值不可变，final对象类型的数据引用不可变对象本身可变，Java在语法上不提供对象本身不可变的方法。

final参数与C++中的const reference parameter有着相同的效果：你不可以更改引用的对象，但被引用对象的内容的修改不受此关键字的限制。

 7.8.2 final方法

final方法阻止Derive类修改它的含义，也就是组织了多态。

Java5之前final方法还对编译器施加了类似于C++中inline的作用。但现在已经不再提倡。

private的方法意义上等同与final，但对于Derive类override的限制上有着不同的行为，详细看如下代码。

class Base {
  private void f1() {}
  private final void f2() {}
  public final void g() {}
}

public class Derive extends Base {
  void f1() {}
  void f2() {}
  /* This result a compile error : g() in Derive cannot override g() in Base, for overridden method is final*/
  void g() {}
  public static void main(String args[]){}
}

7.8.3 final类

语法上阻止了被声明为final的类被他人extends。

让我们来回忆一下如何在C++中实现这种效果，注意C++的语法：class中默认访问权限为private。

class UnDerived {
    UnDerived(){}
};

class Derive : UnDerived {
};

int main()
{
   Derive d;
   return 0;
}/* Compile output:
main.cpp: In constructor 'Derive::Derive()':
main.cpp:2:5: error: 'UnDerived::UnDerived()' is private
main.cpp:5:7: error: within this context
main.cpp: In function 'int main()':
main.cpp:10:11: note: synthesized method 'Derive::Derive()' first required here
*/

7.9 初始化及类的加载

类的加载顺序为，先遇到先加载，某个类如果有基类，那么它的基类也会被加载。

import static java.lang.System.out;
class Indicator {
  Indicator(String name){
    out.println(name);
  }
}

class Base {
  static Indicator i1 = new Indicator("i1");
  static Indicator i2;
  static {
    i2 = new Indicator("i2");
  }
  Base(){} 
}

public class Derive extends Base {
  static Indicator i6 = new Indicator("i6");
  static Indicator i7;
  static {
    i7 = new Indicator("i7");
  }
  Derive(){}
  public static void main(String args[]){
  }
}/*
i1
i2
i6
i7
*/

 

构造函数以及Static域的初始化顺序为先基类后子类。

确切的描述为：

1. 加载子类，加载基类，加载根基类
2. 根基类的static初始化，基类，最后是子类
3. 根基类的构造函数被调用，基类，最后是子类

 

import static java.lang.System.out;
class Indicator {
  Indicator(String name){
    out.println(name);
  }
}

class Base {
  static Indicator i1 = new Indicator("i1");
  static Indicator i2;
  static {
    i2 = new Indicator("i2");
  }
  private Indicator i3 = new Indicator("i3");
  private Indicator i4;
  private Indicator i5;
  {
    i4 = new Indicator("i4");
  }
  
  Base(){
    i5 = new Indicator("i5");
  } 
}

public class Derive extends Base {
  static Indicator i6 = new Indicator("i6");
  static Indicator i7;
  static {
    i7 = new Indicator("i7");
  }
  private Indicator i8 = new Indicator("i8");
  private Indicator i9;
  private Indicator ia;
  {
    i9 = new Indicator("i9");
  }
  Derive(){
    ia = new Indicator("ia");
  }
  public static void main(String args[]){
    new Derive();
  }
}/*
i1
i2
i6
i7
i3
i4
i5
i8
i9
ia
*/