本文是依据JAVA解惑这本书，做的笔记。电子书见：http://download.csdn.net/detail/u010378705/7527721

谜题46

函数重载的问题。

JAVA重载解析过程：1. 选取全部可用的方法或者构造器；2. 从过程1中选取的方法或构造器中选择最精确的。

一般而言：能够强制要求编译器选择一个精确的重载版本号，将实參转型为形參所声明的类型。

继承中静态域的问题。

静态域由声明它的类及其全部子类共享。

假设须要让每个子类都具有某个域的单独拷贝，必须在每个子类中声明一个单独的静态域。

假设每个实例都须要一个单独的拷贝，则能够在基类中声明一个非静态域。

静态方法的问题。

对静态方法的调用不存在不论什么动态分配机制。静态方法是编译时刻选定的，依据修饰符编译期类型选定的。

静态方法不能被覆写，仅仅能被隐藏。

尽量使用类名来调用静态方法。

谜题49

public class Elvis {	
	public static final Elvis INSTANCE = new Elvis();
	private final int beltSize;
	private static final int YEAR = Calendar.getInstance().get(Calendar.YEAR);
	private Elvis() {
		beltSize = YEAR - 1930;
	}
	public int beltSize() {
		return beltSize;
	}
	public static void main(String[] args) {
		System.out.println(INSTANCE.beltSize());
	}
}

初始化的问题。

final类型的静态域被初始化之前存在被读取的可能，此时该静态域仅仅是所属类型的缺省值。

final类型的域仅仅有在初始化表达式是常量表达式时，才是常量。

类的初始化循环有待进一步理解。

谜题50

instanceof的问题

当instanceof左操作数为null时，返回false。

当instanceof左右操作数都是类的时候，当中一个必须是还有一个的子类型，否则编译错误。

转型操作符的行为与instanceof同样，当转型操作的两种类型都是类时，必须当中一个是还有一个子类型。

谜题51

class Point {
	protected final int x, y;
	private final String name;
	Point(int x, int y) {
		this.x = x;
		this.y = y;
		name = makeName(); // 3. 调用子类的方法。
	}
	protected String makeName() {
		return "[" + x + "," + y + "]";
	}
	public final String toString() {
		return name;
	}
}
public class ColorPoint extends Point{
	private final String color;
	ColorPoint(int x, int y, String color) {
		super(x, y); //2. 转向父类的构造函数。
		this.color = color; // 5. 初始化该属性。
	}
	protected String makeName() {
		//4.在子类的构造函数结束前运行。
		return super.makeName() + ":" + color;
	}
	public static void main(String[] args) {
		//1. 调用子类的构造函数。
		System.out.println(new ColorPoint(1, 2 , "red"));
	}
}

构造函数调用了子类覆写的方法。

实例初始化循环，能够採用惰性初始化。

谜题52

class Cache {	
	static {
		initializedIfNecessary();
	}
	private static int sum;
	public static int getSum() {
		initializedIfNecessary();
		return sum;
	}
	private static boolean initialized = false;
	private static synchronized void initializedIfNecessary() {
		if (! initialized) {
			for (int i = 0; i < 100; i++) {
				sum += i;
			}
			initialized = true;
		}
	}
}
public class Client {
	public static void main(String[] args) {
		System.out.println(Cache.getSum());
	}
}

同一时候使用了惰性初始化和积极初始化。

初始化顺序对结果的影响。

改动后的程序

class Cache {	
	private static final  int sum = computeSum();
	private static int computeSum() {
		int result = 0;
		for (int i = 0; i < 100; i++) {
			result += i;
		}
		return result;
	}
	public static int getSum() {
		return sum;
	}
}

谜题53

讲述了私有构造器捕获惯使用方法。

<span style="font-size:18px;">class Thing {
	public Thing(int i) {
		System.out.println("Thing:" + i);
	}
}
public class MyThing extends Thing {
	@SuppressWarnings("unused")
	private final int arg;
	public MyThing() {
		this(1);//能够调用其它类的方法获取返回值。
	}
	private MyThing(int i) {
		super(i);
		arg = i;
	}
}</span>

谜题54

静态方法调用时，实例不起作用。静态方法是属于类的。

谜题55

java语言规范不同意一个本地变量声明语句作为一条语句在循环中反复运行。一个本地变量声明作为一条语句，仅仅能直接出如今一个语句块中(花括号里的)。

for (int i = 0; i < 10; i++)

String str = "123";

这个编译不通过，改动正确为：

for (int i = 0; i < 10; i++) {

Stirng str = "123";

}