java迷题_Java——类谜题

1、令人混淆的构造器

代码如下格式：

public classConfusing {privateConfusing(Object o) {

System.out.println("Object");

}private Confusing(double[] dArray) {

System.out.println("double array");

}public static voidmain(String[] args) {new Confusing(null);

}

}

分析：null这个参数，两个构造器都可以接受，会怀疑这段代码是否会通过编译，运行后发现可以通过编译并且打印出double array？Why？

正解：知识点——Java重载解析过程是以两个阶段运行的。第一个阶段，选取所有可以获得并且可以使用的方法或构造器。第二阶段，从上一阶段选取的方法或构造器中选取一个最精准的方法。精准的理解——能接受的参数类型越少越精准。例如：本例中的Object，他接收的范围太广了，至少能够把double数组和int数组接受了，所以他就不精准。但是，能接收double数组但不能接收其他数据对象类型例如int，所以就相对来说显得更精准，所以在第二个阶段，选取了相对精准的方法，所以才会有了double的输出。

2、静态方法的覆盖

代码：

classDog {public static voidbark() {

System.out.print("woof ");

}

}class Basenji extendsDog {public static voidbark() { }

}public classBark {public static voidmain(String args[]) {

Dog woofer= newDog();

Dog nipper= newBasenji();

woofer.bark();

nipper.bark();

}

}

先来说明一件事情：nipper编译期类型为Dog类型，运行期类型为Basenji类型。

分析：静态方法的调用是在编译期选好的，而这个调用当然就要看对象的编译期类型。本例子中，woofer和nipper具有相同的编译类型Dog，虽然nipper在运行期间类型为Basenji，所以他们两个都会打印出woof即打印结果为：woof  woof。

静态方法的覆盖叫隐藏，一般方法的覆盖叫重载。重载能够得到动态分配的特性(其实就是看运行期的对象类型)，隐藏不能得到这种特性(隐藏只能看编译期类型)。所以，如果将Dog和Basenji中的函数方法去掉static，变为重载，那么将会只打印一个woof。

3、instanceof和强制类型转换

三个程序的代码：

public classType1 {public static voidmain(String[] args) {

String s= null;

System.out.println(sinstanceofString);

}

}public classType2 {public static voidmain(String[] args) {

System.out.println(new Type2() instanceofString);

}

}public classType3 {public static voidmain(String args[]) {

Type3 t3= (Type3) newObject();

}

}

(1)instanceof左边对象运行期为null的时候返回false。

(2)instanceof在编译的时候，如果两边都是类(A instanceof  B      A、B都是类)，则其中一个必须是另外一个的子类，否则就不能通过编译。很明显本例中的Type2和String没有子类关系，所以不能通过编译。

(3)先讨论下强制类型转换的知识：在Java中由于继承和向上转型，子类可以非常自然地转换成父类，但是父类转换成子类则需要强制转换。因为子类拥有比父类更多的属性、更强的功能，所以父类转换为子类需要强制。这种强制类型转换需要条件的。

父类能强制转换为子类：

Father father=new Son();//因为Java的继承和向上转型，子类可以很自然地转换为父类

但是请注意这个Son对象实例在内存中的本质还是Son类型的，只不过它的能力临时被消弱了而已，如果我们想变强怎么办？将其对象类型还原！

Son son=(Son)father; //这种强制类型转换时可以的。

其实father引用仍然是Father类型的，只不过是将它的能力加强了，将其加强后转交给son引用了，Son对象实例在son的变量的引用下，恢复真身，可以使用全部功能了。

父类不能强制转换为子类：当引用类型的真实身份(运行期的类型)是父类本身的类型时，强制类型转换就会产生错误。

Father father=new Father();

Son son=(Son)father;这个系统会抛出ClassCastException异常信息。

编译器在编译时只会检查类型之间是否存在继承关系，有则通过；而在运行时就会检查它的真实类型，是则通过，否则抛出ClassCastException异常。

所以在继承中，子类可以自动转型为父类，但是父类强制转换为子类时只有当引用类型真正的身份为子类时才会强制转换成功，否则失败。

4、Java类初始化顺序

JVM调用main函数时，会触发main函数所在类的初始化。首先，静态域被设置为缺省值(0)，接下来按照静态域的出现顺序进行初始化。

我们大家都知道，对于静态变量、静态初始化块、变量、初始化块、构造器，它们的初始化顺序依次是(这里先假设没有继承) :

(静态变量、静态初始化块(他们两个初始化顺序是根据写的位置))>(变量、初始化块(他们两个初始化顺序是根据写的位置))>构造器。

如果有继承的话，是按照这个顺序先去加载父类。

父类--静态变量

父类--静态初始化块

子类--静态变量

子类--静态初始化块

父类--变量

父类--初始化块

父类--构造器

子类--变量

子类--初始化块

子类--构造器

5、Java实例初始化顺序

代码如下：

classPoint {protected final intx, y;private final String name; //Cached at construction time

Point(int x, inty) {this.x =x;this.y =y;

name=makeName();

}protectedString makeName() {return "[" + x + "," + y + "]";

}public finalString toString() {returnname;

}

}public class ColorPoint extendsPoint {private finalString color;

ColorPoint(int x, inty, String color) {super(x, y);this.color =color;

}protectedString makeName() {return super.makeName() + ":" +color;

}public static voidmain(String[] args) {

System.out.println(new ColorPoint(4, 2, "purple"));

}

}

View Code

分析：打印出了[4,2]:null，并不是期望的[4,2]:purple。

总之，不要在构造器中调用可覆写的方法。在实例初始化中产生的循环将是致命的。该问题的解决方案就是惰性初始化，即当它第一次被使用时初始化，以此取代积极初始化，即当Point实例被创建时初始化，代码如下：

classPoint {protected final intx, y;private String name; //Lazily initialized

Point(int x, inty) {this.x =x;this.y =y;//name initialization removed

}protectedString makeName() {return "[" + x + "," + y + "]";

}//Lazily computers and caches name on first use

public final synchronizedString toString() {if (name == null)

name=makeName();returnname;

}

}

View Code

6、这是一个奇怪的谜题

代码：

public classCreator {public static voidmain(String[] args) {for (int i = 0; i < 100; i++)

Creature creature= newCreature();

System.out.println(Creature.numCreated());

}

}classCreature {private static long numCreated = 0;publicCreature() {

numCreated++;

}public static longnumCreated() {returnnumCreated;

}

}

View Code

这样不能通过编译，因为，它违背了一个Java规范。Java语言规范不允许一个本地变量声明语句作为一条语句在for、while或do循环中重复执行[JLS 14.12-14]。一个本地变量声明作为一条语句只能直接出现在一个语句块中。(一个语句块是由一对花括号以及包含在这对花括展中的语句和声明构成的。)所以，如果将这个循环改为：

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

Creature creature = new Creature();

}

加一个大括弧之后，他就能正常编译运行。