static关键字的作用及执行顺序

static(静态的)

当我们编写一个类时，其实就是在描述其对象的属性和行为，而并没有产生实质上的对象，只有通过new关键字才会产生出对象，这时系统才会分配内存空间给对象，其方法才可以供外部调用。我们有时候希望无论是否产生了对象或无论产生了多少对象的情况下，某些特定的数据在内存空间里只有一份，例如所有的中国人都有个国家名称，每一个中国人都共享这个国家名称，不必在每一个中国人的实例对象中都单独分配一个用于代表国家名称的变量。

static可以用来修饰:属性、方法、代码块、内部类

使用static修饰属性:静态变量(或类变量)

1. 属性:按是否使用static修饰,又分为:静态属性 vs 非静态属性（实例变量）
2. 实例变量:我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象的非静态属性时，不会导致其他对象中同样的属性值的修改。
3. 静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。
4. 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
5. 静态变量的加载要早于对象的创建
6. 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中

例:

public class Text {
    public static void main(String[] args) {

        Chinese c1 = new Chinese();
        c1.name = "小明";
        c1.age = 41;
        c1.nation = "CHN";

        Chinese c2 = new Chinese();
        c2.name = "小慧";
        c2.age = 29;
        c2.nation = "CHINA";

        System.out.println(c1.nation);//结果为CHINA
		

    }

}

class Chinese{

    String name;
    int age;
    static String nation;
}

使用static修饰方法:静态方法

1. 随着类的加载而加载，可以通过"类.静态方法"的方式进行调用
2. 静态方法中，只能调用静态的方法或属性
3. 在静态的方法内，不能使用this关键字、super关键字
4. 在非静态方法中不能声明静态的局部变量

例:

public class Text {
    public static void main(String[] args) {

        Chinese c1 = new Chinese();
        c1.name = "小明";
        c1.age = 41;
        c1.nation = "CHN";

        Chinese c2 = new Chinese();
        c2.name = "小慧";
        c2.age = 29;
        c2.nation = "CHINA";

//        System.out.println(c1.nation);

        Chinese.show();



    }

}

class Chinese{

    String name;
    int age;
    static String nation;

    public void eat(){
//        static String food;
        System.out.println("中国人吃中餐~");
    }

    public static void show(){
        System.out.println("我是一个中国人");
//        eat();
//        name = "tom";
        //可以调用静态的结构
        System.out.println(nation);
        walk();
    }

    public static void walk(){
        System.out.println("走路");
    }
}

static的执行顺序

父类Animal

public class Animal {

	private String name;
	private int legs;
	
	{
		System.out.println("父类的普通代码块");
	}
	static{
		System.out.println("父类的静态代码块");
	}

	public Animal(String name,int legs) {
		System.out.println("父类的构造方法");
	}
	
}

子类的方法

public class Dog extends Animal{
		
	private static Dog d = new Dog("大黄",5);
	private String name;
	private int legs;
	
	{
		System.out.println("子类的代码块");
	}
	//静态代码块
	static{
		System.out.println("子类的静态代码块");
	}

	public Dog(String name, int legs) {
		super(name, legs);
		System.out.println("子类的构造方法");
	}
		
}

测试类

public class Text {

	public static void main(String[] args) {

		Dog dog = new Dog("小狗狗",4);
	}

}

代码的执行顺序如下:

总结:

1. 静态的变量的位置 如果他在静态代码块之前 则先加载如果在静态的变量之后 则按照静态代码的顺序来执行
2. 如果有静态变量 则先加载静态变量 在进主方法 一个类中静态的代码会按照代码的顺序来执行
3. 静态代码块只执行一次 优先于代码块和构造方法
4. 静态代码块和静态变量同时存在时 按照先后顺序执行