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