Java中static成员的用法

（一）什么情况下我们要使用static呢？
1、只想用一个存储区域来保存一个特定的数据——无论要创建多少个对象，甚至根本不创建对象。
2、我们需要一个特殊的方法，它没有与这个类的任何对象关联。也就是说，即使没有创建对象，也需要一个能调用的方法。

（二）static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。
被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。

（三）（1）用public修饰static成员，表示它们是全局成员（成员变量和成员方法），当生成类的对象时，不为每一个对象生成static变量的副本，Java只为static变量生成一个副本，所有的类的对象共享这一个副本；当不存在任何类对象时，要访问一个public的static成员，用类名.成员访问。
（2）用private修饰的static成员，只能通过该类的方法进行访问。如果不存在任何类的对象时访问一
个private的static成员，则必须提供一个public的static方法，并且在调用该方法时，必须添加类名和点运算
符以进行限制。

（四）static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语
法为：
（1）类名.静态方法名(参数列表...)
（2）类名.静态变量名
（3）static {
// whatever code is needed for initialization goes here
}
形如这样的式子----用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块

（五）static变量
按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。两者的区别是： 对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。 对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。

（六）静态方法
静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为实例成员与特定的对象关联！这个需要去理解，想明白其中的道理，不是记忆！
因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。

（七）static代码块
static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。例如：
public class Test5 {
private static int a;
private int b;
static{
Test5.a=3;
System.out.println(a);
Test5 t=new Test5();
t.f();
t.b=1000;
System.out.println(t.b);
}
static{
Test5.a=4;
System.out.println(a);
}
public static void main(String[] args) {
// TODO 自动生成方法存根
}
static{
Test5.a=5;
System.out.println(a);
}
public void f(){
System.out.println("hhahhahah");
}
}
运行结果：
3
hhahhahah
1000
4
5
这个例子的运行顺序是：首先Java虚拟机调用main方法（因为mian方法是程序的入口），main方法位于Test5类中，此main方法是静态的，此时Java解释器查找路径，找到Test5.class文件，加载Test5.class。于此同时静态初始化开始了（包括静态变量和静态代码块的初始化，静态方法（除了main）不可以初始化，只可以用实例方法、静态方法调用或者类名、对象调用）。

（八）总结static变量和方法的访问限制：
（1）实例方法可以访问实例变量和实例方法
（2）实例方法可以访问静态变量和静态方法
（3）静态方法可以访问静态变量和静态方法
（4）静态方法不能访问实例变量和实例方法。静态方法中不能使用关键字this和super

（九）static final一起修饰的作用
从字面意思看，表示全局常量。static final修饰的变量只占据“一段”存储空间，这个存储空间不可以改变。也就是赋予它的值是不可以改变的。如果是基本类型，那么数值不可变；如果是引用变量，那么引用变量不变，一旦引用被初始化指向一个对象，就不可以把它指向另一个对象，但是这个对象的内容可以改变，也就是说这个对象里面的变量的值可以改变。比如：下面标记***的地方
//: c06:FinalData.java

import com.bruceeckel.simpletest.;
import java.util.;

class Value {
int i; // Package access
public Value(int i) { this.i = i; } // 注意;这里的i就是类的内容可以改变
}

public class FinalData {
private static Test monitor = new Test();
private static Random rand = new Random();
private String id;
public FinalData(String id) { this.id = id; }
// Can be compile-time constants:
private final int VAL_ONE = 9;
private static final int VAL_TWO = 99;
// Typical public constant:
public static final int VAL_THREE = 39;
// Cannot be compile-time constants:
private final int i4 = rand.nextInt(20);
static final int i5 = rand.nextInt(20);
private Value v1 = new Value(11);
private final Value v2 = new Value(22);
private static final Value v3 = new Value(33);
// Arrays:
private final int[] a = { 1, 2, 3, 4, 5, 6 };
public String toString() {
return id + ": " + "i4 = " + i4 + ", i5 = " + i5;
}
public static void main(String[] args) {
FinalData fd1 = new FinalData("fd1");
//! fd1.VAL_ONE++; // Error: can't change value
fd1.v2.i++; // Object isn't constant!
fd1.v1 = new Value(9); // OK -- not final
for(int i = 0; i < fd1.a.length; i++)
fd1.a[i]++; // Object isn't constant!
//! fd1.v2 = new Value(0); // Error: Can't
//! fd1.v3 = new Value(1); // change reference
//! fd1.a = new int[3];
System.out.println(fd1);
System.out.println("Creating new FinalData");
FinalData fd2 = new FinalData("fd2");
System.out.println(fd1);
System.out.println(fd2);
monitor.expect(new String[] {
"%% fd1: i4 = //d+, i5 = //d+",
"Creating new FinalData",
"%% fd1: i4 = //d+, i5 = //d+",
"%% fd2: i4 = //d+, i5 = //d+"
});
}
} ///:~

例（二）
package c06.net;

class Value{
static int c=0;
Value(){
c=15;
}
Value(int i){
c=i;
}
static void inc(){
c++;
}
}
class Count{
public static void prt(String s){
System.out.println(s);
}
Value v=new Value(10);
static Value v1,v2;
static{
prt( "v1.c= "+v1.c+ " v2.c= "+v2.c);
v1=new Value(27);
prt( "v1.c= "+v1.c+ " v2.c= "+v2.c);
v2=new Value(15);
prt( "v1.c= "+v1.c+ " v2.c= "+v2.c);
}

public   static   void   main(String[]   args){ 
    Count   ct=new   Count(); 
    prt( "ct.c= "+ct.v.c); 
    prt( "v1.c= "+v1.c+ "     v2.c= "+v2.c); 
    v1.inc(); 
    prt( "v1.c= "+v1.c+ "     v2.c= "+v2.c); 
    prt( "ct.c= "+ct.v.c); 
} 

}

运行结果：

v1.c=0 v2.c=0
v1.c=27 v2.c=27
v1.c=15 v2.c=15
ct.c=10
v1.c=10 v2.c=10
v1.c=11 v2.c=11
ct.c=11