think in java第六章笔记

1.在实际应用中，经常想把某些东西深深地隐藏起来，但同时允许访问衍生类的成员。protected关键字可帮助我们做得到。它的意思是：它本身是私有的，但可由这个类继承的任何东西或者同一个包内的其他任何东西访问。

2.

class Instrument {
	public void play() {
		
	}
	static void tune(Instrument i) {
		i.play();
	}
}
public class Wind extends Instrument{

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Wind flute = new Wind();
		Instrument.tune(flute);
	}

}

在tune中，代码适用于Instrument以及从Instrument衍生出来的任何东西。

3.类继承图的画法是根位于最顶部，再逐渐向下扩展。

4.为判断自己到底应该选用合成还是继承，一个最简单的方法就是考虑是否需要从新类上溯造型回基础类。若必须上溯，就需要继承。但如果不需要上溯造型，就应该提醒自己防止继承的滥用。

5.

<pre name="code" class="java">class Value {
	int i = 1;
}

public class FinalData {

	final int i1=9;
	static final int i2 = 99;
	public static final int i3=39;
	
	final int i4=(int)(Math.random()*20);
	static final int i5=(int)(Math.random()*20);
	
	Value v1=new Value();
	final Value v2 = new Value();
	static final Value v3 = new Value();
	
	final int[] a={1,2,3,4,5,6};
	
	public void print(String id) {
		System.out.println(id+":"+"i4="+i4+",i5="+i5);
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		FinalData  fd1 = new FinalData();
		//fd1.i1++; cant't change value
		fd1.v2.i++;
		fd1.v1 = new Value();
		
		for(int i = 0; i <fd1.a.length; i++) {
			fd1.a[i]++;
		}
		
		//fd1.v2 = new Value();
		//fd1.v3 = new Value();
		//fd1.a = new int[3];
		
		fd1.print("fd1");
		System.out.println("Creating new FinalData");
		FinalData fd2 = new FinalData();
		fd1.print("fd1");
		fd2.print("fd2");
	}

}

不能由于某样东西的属性是final，就认定它的值能在编译期知道。i4和i5在运行期间随即生成数字。例子的这一部分也向大家揭示出将final值设为static和非static之间的差异。只有当值在运行期间初始化的前提下，这种差异才会揭示出来。对于fd1和fd2来说，i4的值是唯一的，但i5的值不会由于创建了另一个FinalData对象而发生改变。因为它的属性是static，而且在载入时初始化，而非创建一个对象时初始化。

6.将类定义为final后，结果只是禁止进行继承——没有更多限制。然而，由于它禁止了继承，所以一个final类中的所有方法都默认为final。

7.

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) {
		// TODO Auto-generated method stub
		prt("Beetle constructor");
		Beetle b = new Beetle();
	}

}

对Beetle运行时，发生的第一件事情是装载程序到外面找到那个类。在转载的过程中，装载程序注意它有一个基础类(即extends关键字要表达的意思)，所以随之将其装入。无论是否准备生成那个基础类的一个对象，这个过程都会发生。若基础类含有另一个基础类，则另一个基础类随即也会装入。接下来，会在根基础类执行static初始化，再下一个衍生类执行。保证这个顺序非常关键，因为衍生类的初始化可能要依赖对基础类成员的正确初始化。

此时，必要的类已全部装载完毕，所以能够创建对象。首先，这个对象中的所有基本数据类型都会设成它们的默认值，而将对象句柄设为null。随后调用基础类构建器。