一段java代码加载分析认识加载过程

java代码加载过程基础：

不含继承：静态代码=》非静态代码=》构造函数

含继承：父类静态代码=》子类静态代码=》父类非静态代码=》父类构造函数=》子类非静态代码=》子类构造函数

 

static修饰的代码块或者变量：

1、只分配一块内存，一个class共享一块内存。

2、静态变量声明在初始化前完成，并赋值0。

3、静态变量或者静态代码块在类加载的时候就开始执行。然后执行完static变量和代码块后开始执行main方法。静态方法需要调用。

静态方法和普通方法的区别：静态方法是跟随类的，不需要new对象，需要使用的时候可直接通过“类名.方法名”使用。普通方法调用的时候需要new一个对象来调用。

4、static代码的加载是依次完成的。

 

在执行完static代码的时候，开始进入main函数执行。

 

代码段1：

 

public class StaticTest {  
	    public static int k=0;  
	    public static StaticTest s1=new StaticTest("s1");  
	    public static StaticTest s2=new StaticTest("s2");  
//	    public StaticTest s1 = new StaticTest("s1");
//	    public StaticTest s2 = new StaticTest("s2");
	    public static int i=print("i");  
	    public static int n=99;  
	    public int j=print("j");  
	      
	    {  
	        print("构造块");  
	    }  
	      
	    static  
	    {  
	        print("静态块");  
	    }  
	      
	    public static int print(String s)  
	    {  
	        System.out.println(++k+":"+s+"\ti="+i+"\tn="+n);  
	        ++n;  
	        return ++i;  
	    }  
	      
	    public StaticTest(String s)  
	    {  
	        System.out.println(++k+":"+s+"\ti="+i+"\tn="+n);  
	        ++i;  
	        ++n;  
	    }  
	  
	    public static void main(String[] args) {  
	    	System.out.println("===========");
	        new StaticTest("init");  
	    }  
	}

 

分析过程：

 

//1、加载StaticTest,k=0
//new StaticTest,静态代码只有k=0被加载了，非静态代码print("j")，syso：1：j i=0 n=0;2：构造块 i=1，n=1；3：构造函数：s1：i=2 n=2。s1创建实例对象成功。
//new StatisTest,静态变量加载k=0，s1，同上过程。syso:4:j i=3 n=3,5:构造块 i=4,n=4,构造函数:6:s2 i=5,n=5。s2创建实例对象成功。
//print(i),7:i i=6 n=6
//syso:8:静态快 i=7 n=99
//把静态代码加载完毕开始执行main函数，main函数中new StaticTest执行非静态代码：print("j")。syso:9:j i=8 n=100。10:构造块 i=9 n=101
//构造函数：11：init i=9 n=101

 

 

执行结果：

 

 

1:j	i=0	n=0
2:构造块	i=1	n=1
3:s1	i=2	n=2
4:j	i=3	n=3
5:构造块	i=4	n=4
6:s2	i=5	n=5
7:i	i=6	n=6
8:静态块	i=7	n=99
===========
9:j	i=8	n=100
10:构造块	i=9	n=101
11:init	i=10	n=102

 

 

 

 

 

 

代码段2：

说明static共享一块内存的问题。所以对于new StaticTest循环，不会栈溢出。

 

public class StaticTest {  
	    public static int k=0;  
//	    public static StaticTest s1=new StaticTest("s1");  
//	    public static StaticTest s2=new StaticTest("s2");  
	    public StaticTest s1 = new StaticTest("s1");
	    public StaticTest s2 = new StaticTest("s2");
	    public static int i=print("i");  
	    public static int n=99;  
	    public int j=print("j");  
	      
	    {  
	        print("构造块");  
	    }  
	      
	    static  
	    {  
	        print("静态块");  
	    }  
	      
	    public static int print(String s)  
	    {  
	        System.out.println(++k+":"+s+"\ti="+i+"\tn="+n);  
	        ++n;  
	        return ++i;  
	    }  
	      
	    public StaticTest(String s)  
	    {  
	        System.out.println(++k+":"+s+"\ti="+i+"\tn="+n);  
	        ++i;  
	        ++n;  
	    }  
	  
	    public static void main(String[] args) {  
	    	System.out.println("===========");
	        new StaticTest("init");  
	    }  
	}  

分析过程：

 

 

//因为static共享一块内存，所以new 本身不会存在死循环。如果把21行的static去掉，循环的时候会不断给分配一块新内存，在执行完所有的静态代码之后会报栈溢出错误。
//syso:1:i i=0 n=0;静态快;======；栈溢出错误

 

 

执行结果：

 

1:i	i=0	n=0
2:静态块	i=1	n=99
===========
Exception in thread "main" java.lang.StackOverflowError
	at test1.StaticTest.<init>(StaticTest.java:7)