《Thinking in java》-学习笔记（6）

学习第六章的笔记如下：

六.第六章 类再生

        讲一下自己的一些体会理解：

（1）这一章主要讲的是代码的重复使用和再生。主要用到合成和继承的概念。

（2）合成的语法：就是在新类里定义对象句柄。

（3）每种非基本类型的对象都有一个toString()方法，可以重写这个方法。

（4）继承的语法：用到关键字 extends

class A{}
class B extends A{}

（5）可以为自己的每个类都创建一个main()，这样做的好处是使自己的测试代码能够封装到类内，方便为每个类

进行单元测试。

（6）在计划继承的时候，比较好的规则是将所有字段都设为private，并将所有方法都设为public，在特殊的场合

，我们需要做出调整。

（7）用super关键字，可以指定调用的方法是基类的方法。

class A{
 void foo(){}
}
class B extends A{
  void foo(){
      super.foo();
  }
}

（8）初始化基础类：创建衍生类的一个对象时，它其中包含了基础类的一个“子对象”，基础类子对象应该正确

地初始化，只有一种方法能保证这一点，在构建器中执行初始化。例如：

package exam;
import oypj.tools.*;
class Art{
	Art(int i){
		P.rintln("Art constructor");
	}
}
class Drawing extends Art{
	Drawing(int i){
		super(i); //初始化基础类的子对象
		P.rintln("Drawing constructor");
	}
}


public class Cartoon extends Drawing {
  Cartoon(int i){
	  super(i); //初始化基础类子对象
	  P.rintln("Cartoon constructor");
  }
  public static void main(String[] args){
	  Cartoon x=new Cartoon(2);
  }
}

如果不调用Cartoon(int i)内的基础类构建器“super(i)”，编译器就会报告自己找不到Drawing()形式的一个构建器。

因为我们已经为Drawing定义了构建器，所以系统不会再为我们创建默认的构建器。所以我们必须在子类的构建器中

调用基类的构建器完成初始化。

（9）在衍生类构建器中，对基础类构建器的调用时必须做的第一件事。

（10）一旦希望为一个类清除什么东西，必须写一个特别的方法，必须将这样的清除代码置于一个finally从句中，确

保在出现违例事件时也能执行。

（11）选择合成还是继承：“属于”关系是用继承来表达的，而“包含”关系是用合成来表达的。比如下面Car类：

package exam;
import oypj.tools.*;
class Engine{
	public void start(){}
	public void rev(){}
	public void stop(){}
}
class Wheel{
	public void inflate(int psi){}
}
class Window{
	public void rollup(){}
	public void rolldown(){}
}
class Door{
	public Window window=new Window();
	public void open(){}
	public void close(){}
}
public class Car {
	public Engine engine=new Engine();
	public Wheel[] wheel=new Wheel[4];
	public Door left=new Door(),right=new Door();
	Car(){
		for(int i=0;i<4;i++)
			wheel[i]=new Wheel();
	}
	public static void main(String[] args){
		Car car=new Car();
		car.left.window.rollup();
		car.wheel[0].inflate(72);
	}
}

（12）程序开发时一个不断递增或则累积的过程，就像人们学习知识一样。

（13）由于造型的方向是从衍生类到基础类，箭头朝上，所以通常把它叫作“上溯造型”，即Upcasting。

（14）final关键字：，声明“这个东西不能改变”。可以应用在 数据、方法、及类 的场合。对于对象句柄，

用final进行声明后，句柄会变成一个常数，不能把句柄变成指向另一个对象，但是对象本身是可以修改的。

这一限制对数组也同样适用，因为数组也是对象

（15）含有固定初始化值得final static 基本数据类型，它们的名字全部采用大写。

（16）对final进行赋值处理，在定义字段时使用一个表达式或者在每个构建器中。

（17）final能为方法上锁，防止任何继承类改变它本来的含义。在方法代码非常少或者禁止方法被覆盖的时候

才把方法设为final。

（18）类定义为final后，禁止进行继承。

（19）继承初始化：

//: Beetle.java
// The full process of initialization.
class Insect {
    int i = 9;
    int j;
    Insect() {
        prt("i = " + i + ", j = " + j);
        j = 39;
    }
    static int x1 =prt("static Insect.x1 initialized");
    static int prt(String s) {
    System.out.println(s);
    return 47;
    }
}
public class Beetle extends Insect {
    int k = prt("Beetle.k initialized");
    Beetle() {
        prt("k = " + k);
        prt("j = " + j);
    }
    static int x2 =prt("static Beetle.x2 initialized");
    static int prt(String s) {
        System.out.println(s);
        return 63;
    }
    public static void main(String[] args) {
        prt("Beetle constructor");
        Beetle b = new Beetle();
    }
} ///:~

输出的结果是：

static Insect.x initialized
static Beetle.x initialized
Beetle constructor
i = 9, j = 0
Beetle.k initialized
k = 63
j = 39

对Beetle 运行Java 时，发生的第一件事情是装载程序到外面找到那个类。在装载过程中，装载程序注意它
有一个基础类（即extends 关键字要表达的意思），所以随之将其载入。无论是否准备生成那个基础类的一
个对象，这个过程都会发生（请试着将对象的创建代码当作注释标注出来，自己去证实）。
若基础类含有另一个基础类，则另一个基础类随即也会载入，以此类推。接下来，会在根基础类（此时是
Insect）执行static 初始化，再在下一个衍生类执行，以此类推。保证这个顺序是非常关键的，因为衍生类
的初始化可能要依赖于对基础类成员的正确初始化。
此时，必要的类已全部装载完毕，所以能够创建对象。首先，这个对象中的所有基本数据类型都会设成它们
的默认值，而将对象句柄设为null 。随后会调用基础类构建器。在这种情况下，调用是自动进行的。但也完
全可以用super 来自行指定构建器调用（就象在Beetle()构建器中的第一个操作一样）。基础类的构建采用
与衍生类构建器完全相同的处理过程。基础顺构建器完成以后，实例变量会按本来的顺序得以初始化。最

后，执行构建器剩余的主体部分。

注释：上面这一点是摘抄《Thinking in java》，因为觉得很重要。