Java之static用法(详解)

原文地址：http://jeelee.iteye.com/blog/528508

在Java语言中，static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。 

被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。 
用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象时，不生成static变量的副本，而是类的所有实例共享同一个static变量。 
static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用），但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用，这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。 

static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为： 
类名.静态方法名(参数列表...) 
类名.静态变量名 
用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块（用处非常大）。 

static在Java语言中的使用有四种：(变量、方法、代码块、内部类) 

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

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

3、static代码块 
static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。 
例如： 
// -- Java code example 

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代码块的位置可以随便放置！ 
static { 
Test5.a = 5 ; 
System.out.println(a); 
} 
public void f(){ 
System.out.println( " hhahhahah " ); 
} 
} 

运行结果： 
3 
hhahhahah 
1000 
4 
5 

利用静态代码块可以对一些static变量进行赋值，最后再看一眼这些例子，都一个static的main方法，这样JVM在运行main方法的时候可以直接调用而不用创建实例。 

4. 静态内部类（Inner Class） 

为正确理解static在应用于内部类时的含义，必须记住内部类的对象默认持有创建它的那个封装类的一个对象的句柄。然而，假如我们说一个内部类是static的，这种说法却是不成立的。 

static内部类意味着： 
(1) 为创建一个static内部类的对象，我们不需要一个外部类对象。 
(2) 不能从static内部类的一个对象中访问一个外部类对象。 

但在存在一些限制：由于static成员只能位于一个类的外部级别，所以内部类不可拥有static数据或static内部类。 

倘若为了创建内部类的对象而不需要创建外部类的一个对象，那么可将所有东西都设为static。为了能正常工作，同时也必须将内部类设为static。如下所示： 

//: Parcel10.Java 
// Static inner classes 
package c07.parcel10; 

abstract class Contents { 
abstract public int value(); 
} 

interface Destination { 
String readLabel(); 
} 

public class Parcel10 { 
private static class PContents 
extends Contents { 
private int i = 11; 
public int value() { return i; } 
} 
protected static class PDestination 
implements Destination { 
private String label; 
private PDestination(String whereTo) { 
label = whereTo; 
} 
public String readLabel() { return label; } 
} 
public static Destination dest(String s) { 
return new PDestination(s); 
} 
public static Contents cont() { 
return new PContents(); 
} 
public static void main(String[] args) { 
Contents c = cont(); 
Destination d = dest("Tanzania"); 
} 
} ///:~ 

在main()中，我们不需要Parcel10的对象；相反，我们用常规的语法来选择一个static成员，以便调用将句柄返回Contents和Destination的方法。 

通常，我们不在一个接口里设置任何代码，但static内部类可以成为接口的一部分。由于类是“静态”的，所以它不会违反接口的规则——static内部类只位于接口的命名空间内部： 

//: IInterface.java 
// Static inner classes inside interfaces 

interface IInterface { 
static class Inner { 
int i, j, k; 
public Inner() {} 
void f() {} 
} 
} ///:~ 

建议大家在每个类里都设置一个main()，将其作为那个类的测试床使用。但这样做的一个缺点就是额外代码的数量太多。若不愿如此，可考虑用一个static内部类容纳自己的测试代码。如下所示： 

//: TestBed.java 
// Putting test code in a static inner class 

class TestBed { 
TestBed() {} 
void f() { System.out.println("f()"); } 
public static class Tester { 
public static void main(String[] args) { 
TestBed t = new TestBed(); 
t.f(); 
} 
} 
} ///:~ 

这样便生成一个独立的、名为TestBed$Tester的类（为运行程序，请使用“java TestBed$Tester”命令）。可将这个类用于测试，但不需在自己的最终发行版本中包含它。 

PS: 静态内部类--代码示例 
Java中我们经常会使用到内部类（inner classes），如果没有Static的内部类，它的instance的创建是依赖于其元类的。这样的关系似乎比较难表达，让我们直接看下面的代码： 
1: public class Outer { 
2:      int var; 
3 
4:      void outerHoge() { 
5:          System.out.println("hogehoge"); 
6:      } 
7: 
8:      void outerHote2() { 
9:          /* 普通内部类Instance的生成 */ 
10:          Inner i = new Inner(); 
11:          staticHoge sh = new StaticHoge(); 
12: 
13:          /* 非static的内部类，下面的写法看起来很正常， 
14:           * 语法上似乎也没什么错误，实际上却是错误的 
15:           * （编译错误） 
16:           */ 
17: //        Inner i2 = new this.Inner(); 
18:      } 
19: 
20:      /* 依赖于元类的内部类*/ 
21:      class Inner { 
22:          void innerHoge() { 
23:              /* 依赖于Instance的内部变量 
24:               * 
25:               */ 
26:              var = 1; 
27:              outerHoge(); 
28:          } 
29:      } 
30: 
31:      static class StaticHoge() { 
32:          void methodHoge() { 
33:              /* 下面的写法是不对的 
34:               * 同样是编译错误 
35:               */ 
36: //            var = 10; 
37: //            outerHoge(); 
38: //            Inner inner = new Inner(); 
39:          } 
40:      } 
41: } 

static的内部类的使用，我们可以像Package一样用它： 
1: public class Outer2 { 
2:      public static class StaticHoge1 { 
3:          //... 
4:      } 
5:      public static class StaticHoge2 { 
6:          //... 
7:      } 
8: } 

可以像下面这样使用： 
1: Outer2.StaticHoge1 sh1 = new Outer2.StaticHoge1(); 
2: Outer2.StaticHoge2 sh2 = new Outer2.StaticHoge2(); 

是不是很方便？ 

不过对于内部的Static类，需要注意下面几点： 
●为创建一个static内部类的对象，我们不需要一个外部类对象 
●不能从static内部类的一个对象中访问一个外部类对象 
●由于static成员只能位于一个类的外部级别，所以内部类不可拥有static数据或static内部类