JAVA编程思想(3) - 复用类(二)

组合和继承之间选择

• 组合和继承都允许在新的类中放置子对象，组合是显示地这么做的，而继承是隐式地做。
• 组合技术通常用于想在新类中使用现有类的功能而非它的接口这种情况。在新类中我们只能看到的是为新类所定义的接口，而非所嵌入对象的接口。为取得这个效果，需要在新类中嵌入一个现有类的private对象。
• 有时，允许类的用户直接访问新类中组合成分是极据意义的，声明为public（一般情况下是private）；如果成员对象自身都隐藏了具体实现，那么这种做法是安全的
• “is-a”（是一个）的关系是用继承来表达，而has-a（有一个）的关系是用组合来表达的。

protected关键字

• 在实际项目中，经常会想要将某些事物尽可能对这个世界隐藏起来，但仍然允许导出类的成员访问它们。
• 关键字protected它指明“就类用户而言，这是private的，但对于任何继承此类的导出类或其他任何位于同一个包内的类来说，它却是可以访问的。”（protected也提供了包内访问权限。）
• 尽管可以创建protected域，但是最好的方式还是将域保持为private；你应当一直保留“修改底层实现”的权力，然后通过protected方法来控制类的继承者的访问权限。

向上转型

• “新类是现有类的一种类型”这句话用来概括新类和基类之间的关系。

//: reusing/Wind.java// Inheritance & upcasting.class Instrument {  public void play() {}  static void tune(Instrument i) {    // ...    i.play();  }}// Wind objects are instruments// because they have the same interface:public class Wind extends Instrument {  public static void main(String[] args) {    Wind flute = new Wind();    Instrument.tune(flute); // Upcasting  }} ///:~

• 在此例中，tune()方法可以接受Instrument的引用。但在Wind.main()中，传递的给tune()方法的是一个Wind引用，java会严格检查类型，除非你认识到Wind对象同样是一种Instrument对象，而且也不存在任何tune()方法是可以通过Instrument来调用的，同时又不存在与Wind之中。将导出类的引用转换为基类的引用的动作，叫向上转型。
• 由导出类转型为基类，在继承图上是向上移动的，因此一般称为向上转型。由于向上转型是从一个较专用类型向比较通用的类型转换，所以总是安全的。也就是说导出类是基类的一个超集。它可能会有跟多的方法，但是至少具备基类中所含的方法。在向上转型的过程中，类接口唯一可能发生的事情是丢失方法，而不是获取它们，这就是为什么编译器在“未曾”明确表示转型或未曾指定特殊标记的情况下，仍然支持这种行为。

再论组合与继承

• 尽管在教授OOP的过程中我们多次强调继承，但这并不意味着尽可能使用它。相反，应当慎用这一技术，其使用场合仅限于你确信使用该技术确实有效的情况下。使用组合还是继承取决于你：你是否需要向上转型。

final关键字

• 根据上下文环境，Java的关键字final的含义存在着细微的区别，但通常它指的是“这是无法改变的”。不想做改变的可能出于两个理由：设计或效率，由于这两个原因相差很远，所以关键字final有可能被误用。
• final可能使用到的三种情况：数据、方法和类。

final数据

• 有时数据的恒定不变是很有用的，比如：
  1. 一个永不改变的编译时常量。
  2. 一个在运行时被初始化的值，而你不希望它被改变。
• 对于编译期常量这种情况，编译器可以将该常量值带入任何可能用到它的计算式中，减轻了一些运行时的负担。在Java中，这类常量必须是基本数据类型，并且以关键字final表示。在对这个常量进行定义的时候，必须对其进行赋值。
• 一个既是static又是final的域只占据一段不能改变的存储空间。
• 当对对象引用而不是基本类型运行final时，与对于基本类型不同，基本类型是使数值不变，而引用是使引用恒定不变。一旦引用被初始化指向一个对象，就无法再把它改为指向另一个对象。然而，对象其本身是可以修改的。

空白final

• Java允许生成“空白的final”，所谓空白的final是指被声明为final但又未给定初值的域。无论什么情况，编译器都会确保空白的final在使用前必须被初始化。但是空白final在关键字final的使用上提供个更大的灵活性。

//: reusing/BlankFinal.java// "Blank" final fields.class Poppet {  private int i;  Poppet(int ii) { i = ii; }}public class BlankFinal {  private final int i = 0; // Initialized final  private final int j; // Blank final  private final Poppet p; // Blank final reference  // Blank finals MUST be initialized in the constructor:  public BlankFinal() {    j = 1; // Initialize blank final    p = new Poppet(1); // Initialize blank final reference  }  public BlankFinal(int x) {    j = x; // Initialize blank final    p = new Poppet(x); // Initialize blank final reference  }  public static void main(String[] args) {    new BlankFinal();    new BlankFinal(47);  }} ///:~

• 必须在域的定义处或者每个构造器中用表达式对final进行赋值，这正是final域在使用前总是被初始化的原因。

final参数

• Java允许在参数列表中以声明的方式将参数指明为final。这意味着你无法在方法中更改参数引用所指的对象。
• 你可以阅读参数，但却无法修改参数。

final方法

• 使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义。这是出于设计的考虑：想要确保在继承中使方法行为保持不变，并且不会被覆盖。
• 过去建议使用final方法的第二个原因是效率。不过在最近的Java版本中，这种做法正在逐渐的受阻，已经不再需要使用final方法来进行优化了，只有在想要明确禁止覆盖时，才将方法设置为final。

final和private关键字

• 类中所有的private方法都隐式地指定为是final的。由于无法取用private方法，所以也就无法覆盖它。可以对private方法添加final修饰词，但这并不能给该方法增加任何额外的意义。

//: reusing/FinalOverridingIllusion.java// It only looks like you can override// a private or private final method.import static net.mindview.util.Print.*;class WithFinals {  // Identical to "private" alone:  private final void f() { print("WithFinals.f()"); }  // Also automatically "final":  private void g() { print("WithFinals.g()"); }}class OverridingPrivate extends WithFinals {  private final void f() {    print("OverridingPrivate.f()");  }  private void g() {    print("OverridingPrivate.g()");  }}class OverridingPrivate2 extends OverridingPrivate {  public final void f() {    print("OverridingPrivate2.f()");  }  public void g() {    print("OverridingPrivate2.g()");  }}public class FinalOverridingIllusion {  public static void main(String[] args) {    OverridingPrivate2 op2 = new OverridingPrivate2();    op2.f();    op2.g();    // You can upcast:    OverridingPrivate op = op2;    // But you can't call the methods:    //! op.f();    //! op.g();    // Same here:    WithFinals wf = op2;    //! wf.f();    //! wf.g();  }} /* Output:OverridingPrivate2.f()OverridingPrivate2.g()*///:~

• “覆盖”只有在某方法是基类的接口的一部分时才会出现。即：必须将一个对象向上转型为它的基本类型并调用相同的方法。如果某方法是为private，它就是不是类的接口的一部分，它仅是一些隐藏于类中的程序代码，只不过是具有相同的名称而已。但如果导出类中以相同的名称生成一个public、protected或包访问权限方法的话，该方法就不会产生在基类中出现的“仅具有相同名称”的情况。此时你并没有覆盖该方法，仅是生成了一个新的方法。由于private无法触及而且能有效隐藏，所以除了把它看成是因为它所属类的组织结构的原因而存在外，其他任何事情不需要考虑到它。

final类

• 当将某个类的整体定义为final时，就表明了你不打算继承该类，而且也不允许别人这么做。换句话说，出于某种考虑，你对该类的设计永不需要做任何改动，或者出于安全考虑，你不希望它有子类。
• 无论类是否被定义为final，相同的规则都适用于定义为final的域。然而，由于final类禁止继承，所以final类中所有的方法都隐式指定为是final的，因为无法覆盖它们。在final类中可以给方法添加final修饰词，但这并没有添加任何意义。

初始化及类的加载

• 在许多语言之中，程序是作为启动过程的一部分立刻被加载的。然后是初始化，紧接着程序开始运行。这些语言的初始化过程必须小心控制，以确保定义为static的东西，其初始化不会造成麻烦。例如C++中，如果某个static期望在另一个static在被初始化之前就能有效地使用它，那么就会出现问题。
• Java不会出现这个问题，因为它采用的是一种不同的加载方式，因为Java中的所有事物都是对象，每个类的编译代码都存在于它自己的独立文件中，该文件只在需要使用程序代码的时候才会被加载。一般来说，可以说：“类的代码在初次使用时才被加载。”。这通常是指加载发生在创建类的第一个对象之时，但是当访问static域或者static方法时，也会发生加载。
• 初次使用之处也是static初始化发生之处，所有的static对象和static代码段都会在加载时按程序中的顺序而依次初始化。当然这只会发生一次。

继承和初始化

//: reusing/Beetle.java// The full process of initialization.import static net.mindview.util.Print.*;class Insect {  private int i = 9;  protected int j;  Insect() {    print("i = " + i + ", j = " + j);    j = 39;  }  private static int x1 =    printInit("static Insect.x1 initialized");  static int printInit(String s) {    print(s);    return 47;  }}public class Beetle extends Insect {  private int k = printInit("Beetle.k initialized");  public Beetle() {    print("k = " + k);    print("j = " + j);  }  private static int x2 =    printInit("static Beetle.x2 initialized");  public static void main(String[] args) {    print("Beetle constructor");    Beetle b = new Beetle();  }} /* Output:static Insect.x1 initializedstatic Beetle.x2 initializedBeetle constructori = 9, j = 0Beetle.k initializedk = 47j = 39*///:~

• 构造器也是static方法，尽管static关键字并没有显示的写出来。 （这个待日后深入理解）
• 在Beetle上运行Java时，所发生的第一件事情就是试图访问Beetle.main()(一个static方法)于是加载器开始启动并找出Beetle类的编译代码(其实就是在名为Beetle.class的文件中)。对于这次加载，编译器注意到它有个基类（通过关键字extend得知的），于是它继续进行加载。不管你是否打算产生一个该基类的对象，这都要发生。
• 如果该基类还有基类就继续加载，如此类推。接下来，根基类中的static初始化即会被执行（这里是Insect），然后是下一个导出类，依次类推。
• 至此为止，必要的类都被加载完成了，对象可以被创建了。首先，对象中的所有基本类型都会被设为默认值，对象引用被设为null,然后基类的构造器会被调用，在基类的构造器完成之后，实例变量按次序被初始化，最后，构造器的其余部分被执行。