static关键字

---

前言

在《Java编程思想》当中有这样一段话：
“static方法就是没有this的方法。在static方法内部不能调用非静态方法，反过来是可以的。而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途。”
总结一下就是static：方便在没有创建对象的情况下来进行调用（方法/变量）
很显然，被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。

---

一、static内存使用

static关键字存储在我们的方法区当中的静态常量池当中，
static修饰的方法、变量和代码块都是可以被用来共享的。

 public class Person {
	private int age ;
	
	private String name;
	
	static String from;

	public Person(int age, String name) {
		super();
		this.age = age;
		this.name = name;
	}

	@Override
	public String toString() {
		return "Person [age=" + age + ", name=" + name + ", from=" + from + "]";
	}
	
	public static void main(String[] args) {
		Person person1 = new Person(20,"张三");
		Person person2 = new Person(21,"李四");
		Person.from = "中国";
		System.out.println(person1.toString());
		System.out.println(person2.toString());
	}
	
}

一个简单的例子结果如下：
Person [age=20, name=张三, from=中国]
Person [age=21, name=李四, from=中国]
说明static变量通用

person1和person2的name和age属性的值都在堆内存当中进行存储，且是该对象私有的，但是from属性扥值是存储在方法区的静态常量池当中的，是属于公共的。

二、static修饰符的三种用法

static 加载顺序

public class Test extends Base{
	 
    static{
        System.out.println("test static");
    }
     
    public Test(){
        System.out.println("test constructor");
    }
     
    public static void main(String[] args) {
        new Test();
    }
}
 
class Base{
     
    static{
        System.out.println("base static");
    }
     
    public Base(){
        System.out.println("base constructor");
    }
}

结果：
base static
test static
base constructor
test constructor
原因：
先来想一下这段代码具体的执行过程，在执行开始，先要寻找到main方法，因为main方法是程序的入口，但是在执行main方法之前，必须先加载Test类，而在加载Test类的时候发现Test类继承自Base类，因此会转去先加载Base类，在加载Base类的时候，发现有static块，便执行了static块。在Base类加载完成之后，便继续加载Test类，然后发现Test类中也有static块，便执行static块。在加载完所需的类之后，便开始执行main方法。在main方法中执行new Test()的时候会先调用父类的构造器，然后再调用自身的构造器。因此，便出现了上面的输出结果。

public class Test {
    Person person = new Person("Test");
    static{
        System.out.println("test static");
    }
     
    public Test() {
        System.out.println("test constructor");
    }
     
    public static void main(String[] args) {
        new MyClass();
    }
}
 
class Person{
    static{
        System.out.println("person static");
    }
    public Person(String str) {
        System.out.println("person "+str);
    }
}
 
 
class MyClass extends Test {
    Person person = new Person("MyClass");
    static{
        System.out.println("myclass static");
    }
     
    public MyClass() {
        System.out.println("myclass constructor");
    }
}

结果：
test static
myclass static
person static
person Test
test constructor
person MyClass
myclass constructor
原因：
类似地，我们还是来想一下这段代码的具体执行过程。首先加载Test类，因此会执行Test类中的static块。接着执行new MyClass()，而MyClass类还没有被加载，因此需要加载MyClass类。在加载MyClass类的时候，发现MyClass类继承自Test类，但是由于Test类已经被加载了，所以只需要加载MyClass类，那么就会执行MyClass类的中的static块。在加载完之后，就通过构造器来生成对象。而在生成对象的时候，必须先初始化父类的成员变量，因此会执行Test中的Person person = new Person()，而Person类还没有被加载过，因此会先加载Person类并执行Person类中的static块，接着执行父类的构造器，完成了父类的初始化，然后就来初始化自身了，因此会接着执行MyClass中的Person person = new Person()，最后执行MyClass的构造器。

总结

其实很简单，执行顺序就是父类static-子类static-父类构造-子类构造。