一页比较形象的课件:
1.如果没有子类父类的关系,那么就是
静态变量、静态初始化块–>非静态变量、初始化块–>构造方法
2.如果有子类父类关系,那么就是
静态(父)–>静态(子)–>非静态(父)–>构造器(父)–>非静态(子)–>构造器(子)。
3.父类构造器先于子类构造器执行的原因如下:如果不初始化父类,而是先初始化子类,那么子类想要调用父类的方法时会发生异常。jvm为了防止这种情况,会先初始化父类,也就是如果在创建子类对象前没有创建一个父类对象,那么会先初始化父类,也就是先调用父类的构造器构造一个父类对象,然后才是调用子类的构造方法。
下面是一些题目及个人分析:
1.非父子类的初始化:
class A {
int value;
static A a1 = new A(1);
public A(int i) {
System.out.println("initialize A"+i);
value = i;
}
public A(A a) {
System.out.println("copy from A"+a.value);
value = a.value;
}
static A a2 = new A(2);
}
class B {
A a8;
// A a7 = new A(a6);
A a6 = new A(6);
static A a3 = new A(3);
static A a4;
static {
a4 = new A(4);
}
static A a5 = new A(5);
public B(int i) {
System.out.println("initialize B"+i);
a8 = new A(8);
}
A a7 = new A(a6);
}
public class Initialization {
static B b1 = new B(1);
static B b2;
public static void main(String[] args) {
System.out.println("main begins");
A a9 = new A(9);
b2 = new B(2);
System.out.println("main ends");
}
}
输出:(原输入是没有注释和空行的,这里是为了方便分块解释输出的由来)
/*A类的静态块
initialize A1
initialize A2
*/
/*B类的非静态块
initialize A3
initialize A4
initialize A5
*/
/*B类的非静态块
initialize A6
copy from A6
*/
/*B类的构造方法
initialize B1
initialize A8
*/
/*main方法的第一行输出
main begins
*/
/*A类的构造方法,由于A类没有非静态块,所以再次new的时候只有A类的构造方法起作用
initialize A9
*/
/*B类非静态块
initialize A6
copy from A6
*/
/*B类构造方法
initialize B2
initialize A8
*/
/*main的第二行输出
main ends
*/
我现在来解释一下代码的运行过程:
1)进入public类,执行静态块:
static B b1 = new B(1);
static B b2;
静态块的第一行new了一个B类,于是去到B类,依次执行三个静态语句
static A a3 = new A(3);
static A a4;
static {
a4 = new A(4);
}
static A a5 = new A(5);
第一个静态语句new了一个A类,我们看到A类,并执行两个静态语句,
static A a1 = new A(1);
public A(int i) {
System.out.println("initialize A"+i);
value = i;
}
public A(A a) {
System.out.println("copy from A"+a.value);
value = a.value;
}
static A a2 = new A(2);
第一个静态语句new了一个A类,此时调用构造方法,于是就得到了第一行的输出:
initialize A1
然后执行第二个静态语句,就得到了第二行输出:
initialize A2
至此A类的静态语句执行完毕,以后再new A(i)的时候就不会再执行这两句了,
2)于是回到B类,执行static A a3 = new A(3);
,也就是initialize A3,然后初始化A4,初始化A5,也就是第3至5行输出。至此,B类的静态块执行完毕,可以执行B类的的非静态语句了:
A a6 = new A(6);
A a7 = new A(a6);
于是得到:
initialize A6
copy from A6
这两行输出。
3)然后执行B类的构造方法,得到以下两行输出:
initialize B2
initialize A8
4)接着进入main方法,main方法的两个输出就不解释了
5)A a9 = new A(9);
这一句只执行A类的构造方法,因为静态块只执行一遍,A类又没有非静态块,于是只有一行输出:
initialize A9
6)最后执行new B(2),先执行B类的非静态块,然后执行B类的构造方法,也就是:
/*B类非静态块
initialize A6
copy from A6
*/
/*B类构造方法
initialize B2
initialize A8
*/
这道题就根据我的理解先讲到这,如果有什么不对的欢迎留言指出
2.父子类:
//Animal.java
public class Animal {
public Animal(){
System.out.println("I am an animal");
}
}
//Dog.java
public class Dog extends Animal{
public Dog(){
System.out.println("I am a dog");
}
}
//AnimalTest.java
public class AnimalTest {
public <T,S extends T> T testDemo(T t,S s){
System.out.println("I am type T and my type is "+t.getClass().getName());
System.out.println("I am type S and my type is "+s.getClass().getName());
return t;
}
public static void main(String[] args){
AnimalTest test=new AnimalTest();
Dog dog=new Dog();
Animal animal=new Animal();
Animal animal1=test.testDemo(animal,dog);
}
}
上面这段代码的输出为:
这是原因:
哈哈父类构造器先于子类构造器执行的原因如下:如果不初始化父类,而是先初始化子类,那么子类想要调用父类的方法时会发生异常。jvm为了防止这种情况,会先初始化父类,也就是如果在创建子类对象前没有创建一个父类对象,那么会先初始化父类,也就是先调用父类的构造器构造一个父类对象,然后才是调用子类的构造方法。