备考SCJP

Question

package pk;class A{
static A a1=new A(111);
public A(int i){
System.out.println("new Father()"+i);
}
{
System.out.println("father block");  //请问这类里的方法名怎么会没
}                                             //啊，而且还运行得了哦，不知
static {                                      //不知道这个是如何理解的，
System.out.println("static father block");//谁能告诉我这个原理，谢
}
}public class Init extends A{
static Init a2=new Init(222);
Init(){
this(12);
System.out.println("new son()");
}
Init(int x){
super(0);
System.out.println("new son(int)");
}
{
System.out.println("son block");
}
static {
System.out.println("static son block");
}
public static void main(String[] args){
new Init();
}
}

Answer 1

{
System.out.println("father block"); //请问这类里的方法名怎么会没
} //啊，而且还运行得了哦，不知
static { //不知道这个是如何理解的，
System.out.println("static father block");//谁能告诉我这个原理，谢
}
}哇～确实奇怪，没有类名的类，还没见过。。

Answer 2

不是啦,那是靜態初始化塊(static initializing block)

Answer 3

应该是你不写static的也会默认为是static.
所以
{
System.out.println("father block"); //请问这类里的方法名怎么会没
} //啊，而且还运行得了哦，不知
static { //不知道这个是如何理解的，
System.out.println("static father block");//谁能告诉我这个原理，谢
}
应该差不多一样吧.

Answer 4

static A a1=new A(111);
public A(int i){
System.out.println("new Father()"+i);
}
{
System.out.println("father block");  //请问这类里的方法名怎么会没
}   //这个叫显式初始化块.是在类构造函数之前调用的
               
static {                                      //不知道这个是如何理解的，
System.out.println("static father block");//谁能告诉我这个原理，谢
}
//这个叫静态初始化块,是在类加载的时候调用的,而且只调用一次.什么叫类加载和什么叫实例化自己要想清楚哦~}
经典题:一个没有main函数的helloworld
class Test{
static {
System.out.println("Hello Wrold!!");
System.exit(0);
}基础要打好啊~这些都没见过怎么考试哦??

Answer 5

}
System.out.println("father block");  //请问这类里的方法名怎么会没
}
这不是方法，是一个代码块
 static {                                      //不知道这个是如何理解的，
System.out.println("static father block");//谁能告诉我这个原理，谢
}
这就是个静态代码块咯

Answer 6

呵呵,这是个对象的方法，你把它看成是和“对象”的成员变量一样就行了．它会和对象的成员变量一样在“对象”构建之前被调用．所以，上述代码的调用顺序应为：
１ Ａ类的静态调用
2  Init类的静态调用
3  Init实例的初始化具体输出大致应如下：
father block   //１。 Ａ类的静态调用：初始化A的静态变量a1。调用具体的构造函数动作之前先调用对象方法区和变量初始化代码。
new Father()111   //调用a1的构造代码。
static father block   //A的其它静态方法区
father block       //2。  Init类的静态调用：初始化Init的静态变量a2。先以super(0)调用父类构造函数，调用父类具体构造函数动作之前先调用父类对象方法区
new Father()0 //super(0)调用的父类构造函数
son block //调用子类具体构造函数动作之前先调用子类对象方法区
new son(int) //a2的子类构造动作
static son block //Init的其它静态方法区
father block //3。 Init实例的初始化：初始化Init的变量前。先以super(0)调用父类构造函数，调用父类具体构造函数动作之前先调用父类对象方法区
new Father()0 //super(0)调用的父类构造函数
son block //调用子类具体构造函数动作之前先调用子类对象方法区
new son(int) //Init(int x)中子类构造动作
new son() //Init()中子类构造动作

Answer 7

把上面的例子里改成如下代码更能看出初始化的全过程：package test;public class A {
{
System.out.println("father block 0 " ); //请问这类里的方法名怎么会没啊，而且还运行得了哦，不知
} 

static {
System.out.println("static father block 0");
}
static A a1 = new A(111); public A(int i) {
System.out.println("new Father()" + i);
} {
System.out.println("father block"); //请问这类里的方法名怎么会没啊，而且还运行得了哦，不知
} 

static { 
System.out.println("static father block ");
}}
public class Init extends A {
String s = "".concat("str");
{
System.out.println("son block 0" );
}

static {
System.out.println("static son block 0");
}

static Init a2 = new Init(222); Init() {
this(12);
System.out.println("new son() " + 12);
} Init(int x) {
super(x);
System.out.println("new son(int)" + x);
} {
System.out.println("son block" );
}
static {
System.out.println("static son block");
} public static void main(String[] args) {
Init a3 = new Init();
}
}输出结果如下：
static father block 0
father block 0 
father block
new Father()111
static father block 
static son block 0
father block 0 
father block
new Father()222
son block 0
son block
new son(int)222
static son block
father block 0 
father block
new Father()12
son block 0
son block
new son(int)12
new son() 12