java子类实例初始化过程



子类的实例化主要分为两个步骤：

<1>.类相关静态内容 初始化；

*先父类再子类：

  1.父类的static属性；

  2.父类的static块；

  3.子类的static属性；

  4.子类的static块；

<2>.类的实例内容 初始化；

*调用构造子：先父类后子类：构造子调用之前先实例化实例字段和块

  5.父类的普通属性；

  6.父类的普通块；

  7.父类的构造子；

  8.子类的普通属性；

  9.子类的普通块；

  10.子类的构造子；

 

举例：

Java代码  

1. package basic;  
2.   
3. public class ClzInit {  
4.     public static void main(String[] args) {  
5.         new Son();  
6.     }  
7. }  
8. class Parent {  
9.     protected int n = 5;  
10.     protected static int m = 5;  
11.     static {  
12.         m = m * 2;  
13.         System.out.println("父类静态块调用；    m="+m);  
14.     }  
15.     {  
16.         n = n * 2;  
17.         m = m * 2;  
18.         System.out.print("父类普通块调用；");  
19.         System.out.print("n="+n);  
20.         System.out.println("    m="+m);  
21.     }  
22.   
23.     public Parent() {  
24.         this.n = n * 10;  
25.         m = m + 10;  
26.         System.out.print("父类构造子；    n="+n);  
27.         System.out.println("    m="+m);  
28.     }  
29. }  
30.   
31. class Son extends Parent {  
32.     private int sn=3;  
33.     private static int sm=3;  
34.     static {  
35.         m = m + 2;  
36.         sm=sm+2;  
37.         System.out.println("子类静态块调用；    m="+m);  
38.     }  
39.     {  
40.         n = n + 2;  
41.         sn=sn+2;  
42.         m = m + 2;  
43.         System.out.println("子类普通块调用；");  
44.         System.out.print("n="+n);  
45.         System.out.print("sn="+sn);  
46.         System.out.println("    m="+m);  
47.     }  
48.   
49.     public Son() {  
50.         this.n = n + 10;  
51.         sn=sn+10;  
52.         m = m + 10;  
53.         System.out.print("子类构造子；n="+n);  
54.         System.out.println("    m="+m);  
55.     }  
56. }  

package basic;

public class ClzInit {
	public static void main(String[] args) {
		new Son();
	}
}
class Parent {
	protected int n = 5;
	protected static int m = 5;
	static {
		m = m * 2;
		System.out.println("父类静态块调用；	m="+m);
	}
	{
		n = n * 2;
		m = m * 2;
		System.out.print("父类普通块调用；");
		System.out.print("n="+n);
		System.out.println("	m="+m);
	}

	public Parent() {
		this.n = n * 10;
		m = m + 10;
		System.out.print("父类构造子；	n="+n);
		System.out.println("	m="+m);
	}
}

class Son extends Parent {
	private int sn=3;
	private static int sm=3;
	static {
		m = m + 2;
		sm=sm+2;
		System.out.println("子类静态块调用；	m="+m);
	}
	{
		n = n + 2;
		sn=sn+2;
		m = m + 2;
		System.out.println("子类普通块调用；");
		System.out.print("n="+n);
		System.out.print("sn="+sn);
		System.out.println("	m="+m);
	}

	public Son() {
		this.n = n + 10;
		sn=sn+10;
		m = m + 10;
		System.out.print("子类构造子；n="+n);
		System.out.println("	m="+m);
	}
}

 看输出结果，可见端倪：

Output代码  

1. 父类静态块调用；    m=10  
2. 子类静态块调用；    m=12  
3. 父类普通块调用；n=10    m=24  
4. 父类构造子；  n=100   m=34  
5. 子类普通块调用；  
6. n=102sn=5   m=36  
7. 子类构造子；n=112 m=46  

父类静态块调用；	m=10
子类静态块调用；	m=12
父类普通块调用；n=10	m=24
父类构造子；	n=100	m=34
子类普通块调用；
n=102sn=5	m=36
子类构造子；n=112	m=46

 

//仅作为学习笔记

[java] view plain copy print ?

1. /* 
2.  
3. 子父类中的构造函数 
4.  
5. 在对子类对象进行初始化时，父类的构造函数也会运行 
6. 那是因为子类的构造函数默认的第一行有一句隐式的语句super() 
7.  
8. super()：会访问父类中空参数的构造函数，而且子类中所有的构造函数默认的第一行都是super() 
9.  
10. 为什么子类一定要访问父类中的构造函数？ 
11. 因为父类中的数据子类可以直接获取，所以子类对象在建立时=，需要查看父类是如何对这些数据进行初始化的 
12. 所以子类在对象进行初始化是要先访问下父类的构造函数 
13. 如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定 
14.  
15. 注意：super语句一定是在子类构造函数的第一行 
16.  
17. 子类的示例化过程 
18.  
19. 结论： 
20. 子类的所有的构造函数，默认都会访问父类中空参数的构造函数 
21. 因为子类每一个构造函函数内的第一行都有一句隐式的super 
22.  
23. 当父类中没有空参数的构造函数时候，子类必须手动通过super语句形式来访问父类中指定的构造函数 
24. 当然：子类中的构造函数第一行也可以手动的指定this语句来访问本类中的构造函数 
25. 子类中至少也会有一个构造函数会访问父类中的构造函数 
26. */  
27.   
28. class father //extends object //这个是所有类的父类   
29. {  
30.     private String word;  
31.     father()  
32.     {  
33.         System.out.println("Father 1");  
34.     }  
35.   
36.     father(String word)  
37.     {  
38.         this.word = word;  
39.         System.out.println("Father 2 " + word);  
40.     }  
41.   
42. }  
43.   
44. class sun  extends father  
45. {  
46.     sun()  
47.     {  
48.         super();//不写也会被隐式调用  
49.         System.out.println("Sun 1");  
50.     }  
51.   
52.     sun(String word)  
53.     {  
54.         super(word);  
55.         System.out.println("Sun 2 " + word);  
56.     }  
57.   
58. }  
59.   
60. class  ExtendDemo  
61. {  
62.     public static void main(String []args)  
63.     {  
64.         String w = "run...";  
65.         sun s = new sun();  
66.         System.out.println("---------------");  
67.         sun ss = new sun(w);  
68.           
69.           
70.     }  
71. }   

/*

子父类中的构造函数

在对子类对象进行初始化时，父类的构造函数也会运行
那是因为子类的构造函数默认的第一行有一句隐式的语句super()

super()：会访问父类中空参数的构造函数，而且子类中所有的构造函数默认的第一行都是super()

为什么子类一定要访问父类中的构造函数？
因为父类中的数据子类可以直接获取，所以子类对象在建立时=，需要查看父类是如何对这些数据进行初始化的
所以子类在对象进行初始化是要先访问下父类的构造函数
如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定

注意：super语句一定是在子类构造函数的第一行

子类的示例化过程

结论：
子类的所有的构造函数，默认都会访问父类中空参数的构造函数
因为子类每一个构造函函数内的第一行都有一句隐式的super

当父类中没有空参数的构造函数时候，子类必须手动通过super语句形式来访问父类中指定的构造函数
当然：子类中的构造函数第一行也可以手动的指定this语句来访问本类中的构造函数
子类中至少也会有一个构造函数会访问父类中的构造函数
*/

class father //extends object //这个是所有类的父类 
{
	private String word;
	father()
	{
		System.out.println("Father 1");
	}

	father(String word)
	{
		this.word = word;
		System.out.println("Father 2 " + word);
	}

}

class sun  extends father
{
	sun()
	{
		super();//不写也会被隐式调用
		System.out.println("Sun 1");
	}

	sun(String word)
	{
		super(word);
		System.out.println("Sun 2 " + word);
	}

}

class  ExtendDemo
{
	public static void main(String []args)
	{
		String w = "run...";
		sun s = new sun();
		System.out.println("---------------");
		sun ss = new sun(w);
		
		
	}
} 

//仅作为学习笔记

[java] view plain copy print ?

1. /* 
2.  
3. 子父类中的构造函数 
4.  
5. 在对子类对象进行初始化时，父类的构造函数也会运行 
6. 那是因为子类的构造函数默认的第一行有一句隐式的语句super() 
7.  
8. super()：会访问父类中空参数的构造函数，而且子类中所有的构造函数默认的第一行都是super() 
9.  
10. 为什么子类一定要访问父类中的构造函数？ 
11. 因为父类中的数据子类可以直接获取，所以子类对象在建立时=，需要查看父类是如何对这些数据进行初始化的 
12. 所以子类在对象进行初始化是要先访问下父类的构造函数 
13. 如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定 
14.  
15. 注意：super语句一定是在子类构造函数的第一行 
16.  
17. 子类的示例化过程 
18.  
19. 结论： 
20. 子类的所有的构造函数，默认都会访问父类中空参数的构造函数 
21. 因为子类每一个构造函函数内的第一行都有一句隐式的super 
22.  
23. 当父类中没有空参数的构造函数时候，子类必须手动通过super语句形式来访问父类中指定的构造函数 
24. 当然：子类中的构造函数第一行也可以手动的指定this语句来访问本类中的构造函数 
25. 子类中至少也会有一个构造函数会访问父类中的构造函数 
26. */  
27.   
28. class father //extends object //这个是所有类的父类   
29. {  
30.     private String word;  
31.     father()  
32.     {  
33.         System.out.println("Father 1");  
34.     }  
35.   
36.     father(String word)  
37.     {  
38.         this.word = word;  
39.         System.out.println("Father 2 " + word);  
40.     }  
41.   
42. }  
43.   
44. class sun  extends father  
45. {  
46.     sun()  
47.     {  
48.         super();//不写也会被隐式调用  
49.         System.out.println("Sun 1");  
50.     }  
51.   
52.     sun(String word)  
53.     {  
54.         super(word);  
55.         System.out.println("Sun 2 " + word);  
56.     }  
57.   
58. }  
59.   
60. class  ExtendDemo  
61. {  
62.     public static void main(String []args)  
63.     {  
64.         String w = "run...";  
65.         sun s = new sun();  
66.         System.out.println("---------------");  
67.         sun ss = new sun(w);  
68.           
69.           
70.     }  
71. }   

/*

子父类中的构造函数

在对子类对象进行初始化时，父类的构造函数也会运行
那是因为子类的构造函数默认的第一行有一句隐式的语句super()

super()：会访问父类中空参数的构造函数，而且子类中所有的构造函数默认的第一行都是super()

为什么子类一定要访问父类中的构造函数？
因为父类中的数据子类可以直接获取，所以子类对象在建立时=，需要查看父类是如何对这些数据进行初始化的
所以子类在对象进行初始化是要先访问下父类的构造函数
如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定

注意：super语句一定是在子类构造函数的第一行

子类的示例化过程

结论：
子类的所有的构造函数，默认都会访问父类中空参数的构造函数
因为子类每一个构造函函数内的第一行都有一句隐式的super

当父类中没有空参数的构造函数时候，子类必须手动通过super语句形式来访问父类中指定的构造函数
当然：子类中的构造函数第一行也可以手动的指定this语句来访问本类中的构造函数
子类中至少也会有一个构造函数会访问父类中的构造函数
*/

class father //extends object //这个是所有类的父类 
{
	private String word;
	father()
	{
		System.out.println("Father 1");
	}

	father(String word)
	{
		this.word = word;
		System.out.println("Father 2 " + word);
	}

}

class sun  extends father
{
	sun()
	{
		super();//不写也会被隐式调用
		System.out.println("Sun 1");
	}

	sun(String word)
	{
		super(word);
		System.out.println("Sun 2 " + word);
	}

}

class  ExtendDemo
{
	public static void main(String []args)
	{
		String w = "run...";
		sun s = new sun();
		System.out.println("---------------");
		sun ss = new sun(w);
		
		
	}
}