手记

Java代码执行顺序

程序中代码执行的顺序非常重要,稍有不慎便会是程序运行出错,那么我将结合实例来分析代码中的执行。

名词解释

首先了解几个名词:

非静态代码块

直接由 { } 包起来的代码,称为非静态代码块

静态代码块

直接由 static { } 包起来的代码,称为静态代码块

形参

比如你定义一个函数void add(int a, int b),这里的a和b就是形参。
当你进行函数调用的时候,add(1, 2),这里的1和2就是实参。

向前引用

所谓向前引用,就是在定义类、接口、方法、变量之前使用它们。

成员变量

在类体里面定义的变量称为成员变量;
如果该成员变量有 static 关键字修饰,则该成员变量称为 静态变量 或 类变量;
如果该成员变量没有 static 关键字修饰,则该成员变量被称为 非静态变量 或 实例变量。

局部变量

形参、方法内定义的变量、代码块中定义的变量,都属于局部变量。

类变量 (静态变量)

可以向前引用
变量属于类本身
类变量不依赖类的实例,类变量只在初始化时候在方法区中被分配一次空间,无论类的实例被创建几次,都不再为类变量分配空间
通过类的任意一个实例来访问类变量,底层都将将其转为通过类本身来访问类变量,它们的效果是一样的
一旦类变量的值被改变,通过类或类的任意一个实例来访问类变量,得到的都将是被改变后的值
将在类的初始化之前初始化

实例变量(非静态变量)

不能向前引用,如果向前引用,则称为非法向前引用,这是不允许的
变量属于类的实例对象
随着类的实例被创建而分配内存空间

实例演示

public class Parent {
	public int parentNum=0;
	public static int staticParentNum=0;
	
	{
		System.out.println("Parent---执行非静态代码块了1!");
	}
	
	{
		System.out.println("Parent---执行非静态代码块了2!");
	}
	
	static{
		System.out.println("Parent---执行静态代码块了1!");
	}
	
	static{
		System.out.println("Parent---执行静态代码块了2!");
	}

	public Parent(){
		System.out.println("Parent---无参构造函数!");
	}
	public Parent(int parentNum){
		this.parentNum=parentNum;
		System.out.println("Parent---有参构造函数!");
		
	}

	public void ParentMethod(int parentNum){
		this.parentNum=parentNum;
		System.out.println("Parent---非静态方法/parentNum="+parentNum);
	}
	
	public static void staticParentMethod(int staticParentNum){
		Parent.staticParentNum=staticParentNum;
		System.out.println("Parent---静态方法/staticParentNum="+staticParentNum);
	}
	
}

public class Child extends Parent{

	public int childNum=0;
	public static int staticChildNum=0;
	
	{
		System.out.println("Child---执行非静态代码块了1!");
	}
	
	{
		System.out.println("Child---执行非静态代码块了2!");
	}
	
	static{
		System.out.println("Child---执行静态代码块了1!");
	}
	
	static{
		System.out.println("Child---执行静态代码块了2!");
	}

	public Child(){
		super();
		System.out.println("Child---无参构造函数!");
	}
	
	public Child(int childNum){
		super(childNum);
		System.out.println("Child---有参构造函数!");
	}
	
	public void childMethod(int childNum){
		this.childNum=childNum;
		System.out.println("Child--非静态方法/childNum="+childNum);
	}
	
	public static void staticChildMethod(int staticChildNum){
		Child.staticChildNum=staticChildNum;
		System.out.println("Child---静态方法/staticChildNum="+staticChildNum);
	}

	
}

package test;

public class Test {

//	static{
//		System.out.println("Test---静态代码块!");
//	}
	public static void main(String[] args) {
		int key=10;
		switch (key) {
		case 0:
			Parent parent=new Parent();
			break;
//			Parent---执行静态代码块了1!
//			Parent---执行静态代码块了2!
//			Parent---执行非静态代码块了1!
//			Parent---执行非静态代码块了2!
//			Parent---无参构造函数!
//          说明:先加载静态代码块,后加载非静态代码块
		case 1:
			Child b= new Child();
			break;
//			Parent---执行静态代码块了1!
//			Parent---执行静态代码块了2!
//			Child---执行静态代码块了1!
//			Child---执行静态代码块了2!
//			Parent---执行非静态代码块了1!
//			Parent---执行非静态代码块了2!
//			Parent---无参构造函数!
//			Child---执行非静态代码块了1!
//			Child---执行非静态代码块了2!
//			Child---无参构造函数!
//			说明:创建子类,会先执行父类,先执行父类静态——>子类静态——>父类非静态——>父类构造
//——>子类非静态——>子类构造
		case 2:
			Child c= new Child(4);
            //这个构造函数中指明了调用父类的有参构造函数,若不指定,则调用父类无参构造函数
            break;
//			Parent---执行静态代码块了1!
//			Parent---执行静态代码块了2!
//			Child---执行静态代码块了1!
//			Child---执行静态代码块了2!
//			Parent---执行非静态代码块了1!
//			Parent---执行非静态代码块了2!
//			Parent---有参构造函数!
//			Child---执行非静态代码块了1!
//			Child---执行非静态代码块了2!
//			Child---有参构造函数!
			说明:静态代码块或非静态代码块执行顺序,按照代码前后编写顺序。
		case 3:
			Child d= new Child();
			Child e= new Child(4);
            break;
//			Parent---执行静态代码块了1!
//			Parent---执行静态代码块了2!
//			Child---执行静态代码块了1!
//			Child---执行静态代码块了2!
//			Parent---执行非静态代码块了1!
//			Parent---执行非静态代码块了2!
//			Parent---无参构造函数!
//			Child---执行非静态代码块了1!
//			Child---执行非静态代码块了2!
//			Child---无参构造函数!
//			Parent---执行非静态代码块了1!
//			Parent---执行非静态代码块了2!
//			Parent---有参构造函数!
//			Child---执行非静态代码块了1!
//			Child---执行非静态代码块了2!
//			Child---有参构造函数!
			说明:创建多个子类,但父类静态代码块只执行一次。
		case 4:
			Child.staticChildMethod(4);
            break;
//			Parent---执行静态代码块了1!
//			Parent---执行静态代码块了2!
//			Child---执行静态代码块了1!
//			Child---执行静态代码块了2!
//			Child---静态方法/staticChildNum=4
			说明:静态方法只可以调用静态变量。
		case 5:
			Parent.staticParentMethod(5);
            break;
//			Parent---执行静态代码块了1!
//			Parent---执行静态代码块了2!
//			Parent---静态方法/staticParentNum=5
			说明:静态方法可通过 父类名.静态方法() 调用。
		case 6:
			System.out.println("父类的静态变量值staticParentNum="+Parent.staticParentNum);
            break;
//			Parent---执行静态代码块了1!
//			Parent---执行静态代码块了2!
//			父类的静态变量值staticParentNum=0
			说明:调用静态变量时,静态代码块会执行。
		case 7:
			System.out.println("子类的静态变量值staticChildNum="+Child.staticChildNum);
            break;
//			Parent---执行静态代码块了1!
//			Parent---执行静态代码块了2!
//			Child---执行静态代码块了1!
//			Child---执行静态代码块了2!
//			子类的静态变量值staticChildNum=0
			说明:调用子类静态变量,父类静态代码块和子类静态代码块会被执行。
		case 8:
			System.out.println("父类的静态变量值staticParentNum="+Parent.staticParentNum);
			System.out.println("子类的静态变量值staticChildNum="+Child.staticChildNum);
            break;
//			Parent---执行静态代码块了1!
//			Parent---执行静态代码块了2!
//			父类的静态变量值staticParentNum=0
//			Child---执行静态代码块了1!
//			Child---执行静态代码块了2!
//			子类的静态变量值staticChildNum=0
			
		case 9:
			Child f= new Child();
			f.ParentMethod(3);
            break;
//			Parent---执行静态代码块了1!
//			Parent---执行静态代码块了2!
//			Child---执行静态代码块了1!
//			Child---执行静态代码块了2!
//			Parent---执行非静态代码块了1!
//			Parent---执行非静态代码块了2!
//			Parent---无参构造函数!
//			Child---执行非静态代码块了1!
//			Child---执行非静态代码块了2!
//			Child---无参构造函数!
//			Parent---非静态方法/parentNum=3
			说明:创建子类,用子类调用父类方法,非静态方法可以调用静态变量。

		default:
			break;
		}

	}

}

总结

  • Java代码初始化顺序
  1. 由 static 关键字修饰的(如:类变量(静态变量)、静态代码块)将在类被初始化创建实例对象之前被初始化,而且是按顺序从上到下依次被执行。静态(类变量、静态代码块)属于类本身,不依赖于类的实例。

  2. 没有 static 关键字修饰的(如:实例变量(非静态变量)、非静态代码块)初始化实际上是会被提取到类的构造器中被执行的,但是会比类构造器中的代码块优先执行到,非静态(实例变量、非静态代码块)的地位是相等的,它们将按顺序被执行。

  • 类变量(静态变量)、实例变量(非静态变量)、静态代码块、非静态代码块的初始化时机
  1. 由 static 关键字修饰的(如:类变量[静态变量]、静态代码块)将在类被初始化创建实例对象之前被初始化,而且是按顺序从上到下依次被执行;
  2. 没有 static 关键字修饰的(如:实例变量[非静态变量]、非静态代码块)初始化实际上是会被提取到类的构造器中被执行的,但是会比类构造器中的 代码块优先执行到,其也是按顺序从上到下依次被执行。
  • 容易混淆的一个知识点
    静态方法只允许直接访问静态成员,而实例方法中可以访问静态成员和实例成员,原因是类还没有实例化,所实例成员也没有被创建,静态方法中因此也不能用this。
0人推荐
随时随地看视频
慕课网APP