java class文件内部各属性的实例化到堆栈和执行过程。

1.java 调用方法以及过程

调用方法，即让这个方法运行起来。eg：main作为起点，调用方法。

public static void main(String[] args){
    int area = getArea(4*5);
}

public static int gerArea(int x,int y){
    return x * y;
}

过程 ：

1.mian入口 ，开始(java源文件通过编译器，编译成class文件，class文件进入方法区，JVM调用main，创建栈帧，进栈运行)

2.调用方法，传递参数4->x,5->y（main调用getArea,传递参数，创建栈帧，进栈）

3.执行getArea,返回20给方法调用者area（计算结果，返回结果，出栈释放资源）

4.main获取放回结果 ，出栈释放资源。

2.一个复杂类的执行过程，以及各属性实例化到堆栈

public class testJava{
    
    public static int b = print();
    
    {
    	System.out.println("testJava构造块");
    }

    public int a= printA();
    
    public testJava(){
        System.out.println("testJava无参构造方法");
    }

    private int printA() {
    	System.out.println("testJava初始化变量");
		return 255;
	}

	public testJava(int x){
        this.a = x;
        System.out.println("testJava有参构造方法");
    }
    
    static {
        System.out.println("testJava静态代码块初始化");
    }

    public static int print() {
        System.out.println("testJava静态变量初始化");
        return 521;
    }
    
}

public class testJava1 extends testJava{
	
	public int d = printA();
	
	{
    	System.out.println("testJava1构造块");
    }
	
	static{
        System.out.println("testJava1的静态代码块初始化");
    }
	
    public static int c = print();

    
    public testJava1(){
        System.out.println("testJava1的构造方法");
    }

    
    
    public static int print(){
        System.out.println("testJava1的静态变量初始化");
        return 522;
    }

    private int printA() {
    	System.out.println("testJava1初始化变量");
		return 255;
	}
    
    public static void main(String[] args) {
        System.out.println("main start");
        testJava1 t1 = new testJava1();
    }
    
}

执行结果如下：

由上面可以分析知道，执行顺序：

       1.静态属性，静态方法声明，静态块。静态方法声明，静态块之间的顺序则是按照他们在代码的先后顺序。

　　2.动态属性，普通方法声明，构造块。

　　3.构造方法。

 

总结：

 

1:类加载过程，不涉及构造方法

2: 实例化过程，涉及构造方法

3.类中所有属性的默认值（一举而成）,直接赋值

4. 父类静态属性初始化，静态块，静态方法的声明（按出现顺序执行）

5. 子类静态属性初始化，静态块，静态方法的声明 （按出现顺序执行）

6.  调用父类的构造方法，

　　首先父类的非静态成员初始化，构造块，普通方法的声明（按出现顺序执行）

　　然后父类构造方法

7.  调用子类的构造方法，

　　首先子类的非静态成员初始化，构造块，普通方法的声明（按出现顺序执行）

　　然后子类构造方法

注意：

1.类加载过程中，可能调用了实例化过程（因为static可以修饰方法，属性，代码块，内部类），此时则会暂停类加载过程而先执行实例化过程（被打断），执行结束再进行类加载过程

2.new 类（）时就会创建一个对象了，但是这个对象还不会执行构造方法中的内容，而是带着这个创建的这个对象去执行非静态代码块中的 内容，执行完后，再去执行构造方法中的内容了