最近几场面试中都问到了 static 关键字用法，在此添加一篇总结。
在《Java 编程思想》P86 页有这样一段话：
“static 方法就是没有 this 的方法。在 static 方法内部不能调用非静态方法，反过来是可以的。而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用 static 方法。这实际上正是 static 方法的主要用途。”
这段话虽然只是说明了 static 方法的特殊之处，但是可以看出 static 关键字的基本作用，简而言之，一句话来描述就是：
方便在没有创建对象的情况下来进行调用（方法/变量）
很显然，被 static 关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。
(比如 Math.abs()这个方法可以直接调用而不需要实例化 Math 类)
static 可以用来修饰类的成员方法、类的成员变量，另外可以编写 static 代码块来优化程序性能。
static 可以修饰
- 方法
- 成员变量（属性）
- 代码块（不能出现在方法内部）
注：
- 独立于类
- 在类加载的时候执行，只执行一次
- 修饰的方法只在调用时执行
static 修饰方法
static 方法一般称作静态方法，由于静态方法不依赖于任何对象就可以进行访问，因此对于静态方法来说，是没有 this 的，因为它不依附于任何对象，既然都没有对象，就谈不上 this 了。并且由于这个特性，在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是须依赖具体的对象才能够被调用。
虽然在静态方法中不能访问非静态成员方法和非静态成员变量，但是在非静态成员方法中是可以访问静态成员方法/变量的。
如果说想在不创建对象的情况下调用某个方法，就可以将这个方法设置为 static。我们最常见的 static 方法就是 main 方法，至于为什么 main 方法必须是 static 的，现在就很清楚了。因为程序在执行 main 方法的时候没有创建任何对象，因此只有通过类名来访问。
static 修饰成员变量
static 变量也称作静态变量，静态变量和非静态变量的区别是：
静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。
static 成员变量的初始化顺序按照定义的顺序进行初始化。
static 静态导包
/* PrintHelper.java文件 */
package com.dotgua.study;
public class PrintHelper {
public static void print(Object o){
System.out.println(o);
}
}/* App.java文件 */
import static com.dotgua.study.PrintHelper.*;
public class App
{
public static void main( String[] args )
{
print("Hello World!");
}
/**Output
* Hello World!
*///~
}上面的代码来自于两个 java 文件，其中的 PrintHelper 很简单，包含了一个用于打印的 static 方法。而在 App.java 文件中，我们首先将 PrintHelper 类导入，这里在导入时，我们使用了 static 关键字，而且在引入类的最后还加上了“.*”，它的作用就是将 PrintHelper 类中的所有类方法直接导入。不同于非 static 导入，采用 static 导入包后，在不与当前类的方法名冲突的情况下，无需使用“类名.方法名”的方法去调用类方法了，直接可以采用"方法名"去调用类方法，就好像是该类自己的方法一样使用即可。
static 修饰代码块
就是初始化块。
static 块可以置于类中的任何地方，类中可以有多个 static 块。在类初次被加载的时候，会按照 static 块的顺序来执行每个 static 块，并且只会执行一次。
执行过程：
- 加载类：通过 jvm 调用 ClassLoader 类中的 loaderClass 方法加载我们要执行的类
- 执行 static 修饰的内容（从上往下执行）
- 调用构造器
- 成员变量初始化
- 执行构造方法，对象创建完毕
static 修饰之后的内存分布
public class Person {
String name;
int age;
public String toString() {
return "Name:" + name + ", Age:" + age;
}
public static void main(String[] args) {
Person p1 = new Person();
p1.name = "zhangsan";
p1.age = 10;
Person p2 = new Person();
p2.name = "lisi";
p2.age = 12;
System.out.println(p1);
System.out.println(p2);
}
/**Output
* Name:zhangsan, Age:10
* Name:lisi, Age:12
*///~
}根据 Person 构造出的每一个对象都是独立存在的，保存有自己独立的成员变量，相互不会影响，他们在内存中的示意如下:
从上图中可以看出，p1 和 p2 两个变量引用的对象分别存储在内存中堆区域的不同地址中，所以他们之间相互不会干扰。但其实，在这当中，我们省略了一些重要信息，相信大家也都会想到，对象的成员属性都在这了，由每个对象自己保存，那么他们的方法呢？实际上，不论一个类创建了几个对象，他们的方法都是一样的：
两个 Person 对象的方法实际上只是指向了同一个方法定义。这个方法定义是位于内存中的一块不变区域（由 jvm 划分），我们暂称它为静态存储区。这一块存储区不仅存放了方法的定义，实际上从更大的角度而言，它存放的是各种类的定义，当我们通过 new 来生成对象时，会根据这里定义的类的定义去创建对象。多个对象仅会对应同一个方法，这里有一个让我们充分信服的理由，那就是不管多少的对象，他们的方法总是相同的，尽管最后的输出会有所不同，但是方法总是会按照我们预想的结果去操作，即不同的对象去调用同一个方法，结果会不尽相同。
我们知道，static 关键字可以修饰成员变量和方法，来让它们变成类的所属，而不是对象的所属，比如我们将 Person 的 age 属性用 static 进行修饰，结果会是什么样呢？请看下面的例子：
public class Person {
String name;
static int age;
/* 其余代码不变... */
/**Output
* Name:zhangsan, Age:12
* Name:lisi, Age:12
*///~
}结果发生了一点变化，在给 p2 的 age 属性赋值时，干扰了 p1 的 age 属性。
给 age 属性加了 static 关键字之后，Person 对象就不再拥有 age 属性了，age 属性会统一交给 Person 类去管理，即多个 Person 对象只会对应一个 age 属性，一个对象如果对 age 属性做了改变，其他的对象都会受到影响。我们看到此时的 age 和 toString()方法一样，都是交由类去管理。
public class Person {
private static int count = 0;
int id;
String name;
int age;
public Person() {
id = ++count;
}
public String toString() {
return "Id:" + id + ", Name:" + name + ", Age:" + age;
}
public static void main(String[] args) {
Person p1 = new Person();
p1.name = "zhangsan";
p1.age = 10;
Person p2 = new Person();
p2.name = "lisi";
p2.age = 12;
System.out.println(p1);
System.out.println(p2);
}
/**Output
* Id:1, Name:zhangsan, Age:10
* Id:2, Name:lisi, Age:12
*///~
}上面的代码起到了给 Person 的对象创建一个唯一 id 以及记录总数的作用，其中 count 由 static 修饰，是 Person 类的成员属性，每次创建一个 Person 对象，就会使该属性自加 1 然后赋给对象的 id 属性，这样，count 属性记录了创建 Person 对象的总数，由于 count 使用了 private 修饰，所以从类外面无法随意改变。
总结
static 主要有四种用法：
- 用来修饰成员变量，将其变为类的成员，从而实现所有对象对于该成员的共享；
- 用来修饰成员方法，将其变为类方法，可以直接使用“类名.方法名”的方式调用，常用于工具类；
- 静态块用法，将多个类成员放在一起初始化，使得程序更加规整，其中理解对象的初始化过程非常关键；
- 静态导包用法，将类的方法直接导入到当前类中，从而直接使用“方法名”即可调用类方法，更加方便。