java里面的static关键字用法

具体实例：
1）下面的例子中，静态变量staticVar，只在类第一次加载时被创建并初始化，以后无论创建多少类对象，该变量都不再
 加载，因此每次都在原有基础上增加1，而实例变量instanceVar，只有当创建类对象时才对其进行创建并在构造函数中
加1，每创建一个对象，就对应创建一个instanceVar实例变量。注意：在静态方法中访问instanceVar将报错。

2）UseStatic类中，类加载时初始化顺序为：静态变量-->静态代码块

public class StaticTest {
      //默认为0 ,可不指定初始值
     static int staticVar; //静态变量，在类初始化时加载，只加载一次
     int instanceVar; //实例变量

     public StaticTest() {
          staticVar++;
          instanceVar++;
          System.out.println("staticVAr= "+staticVar+" instanceVar= "+instanceVar);

    }

     public void doSth(){
         System.out.println("Do something...");
     }

     public static void doSthStatic(){
// System.out.println(instanceVar); //不能对非静态字段 instanceVar 进行静态引用
         System.out.println("Do something static...");
     }

    @Test
    public void testStatic(){
          //单元测试会首先创建一个类的对象，然后再调用该测试方法
          new StaticTest();
     }

    public static void main(String[] args){
        // StaticTest staticTest;
         System.out.println(staticVar); //此时还未创建对象，staticVar值未增加，仍为0
         //每创建一个StaticTest对象，staticVar值增加1，instanceVAr值由0加1
         StaticTest staticTest1=new StaticTest(); //
         StaticTest staticTest2=new StaticTest();
         StaticTest staticTest3=new StaticTest();
         System.out.println("instanceVar(whole) is:"+staticTest3.instanceVar);
         int instanceVar=200; //局部变量优先
         System.out.println("instanceVar(local) is:"+instanceVar);
         System.out.println("staticVar(whole) is:"+staticVar);
         int staticVar=500; //局部变量优先
         System.out.println("staticVar(local) is:"+staticVar);

     }
} //end StaticTest
/**
 *
 * @author patty
 * @time 2014-12-4
 * @todo 考查static变量/方法/代码块
 * 类加载时加载顺序为：静态变量，静态代码块，然后才调用静态方法
 */
class UseStatic{
    public static int a=3;
    static int b;

    static void method(int c){
        System.out.println("C: "+c);
        System.out.println("A: "+a);
        System.out.println("B: "+b);
    }
    //代码块
    static{
        System.out.println("Static block...");
        System.out.println("a= "+a+" b= "+b);// 3 0
        b=a*5;
        System.out.println("a= "+a+" b= "+b);// 3 15
    }

    public static void main(String[] args){
        method(24);
        System.out.println(StaticTest.staticVar); //0
    }
}//end UseStatic

class StaticDemo extends StaticTest{
    static int sta;
    int stb;
    public StaticDemo() {
        //super();
        sta++;
        stb++;
        System.out.println("sta= "+sta+" stb= "+stb);
    }
    //此处不可将doSth声明为静态方法，即子类不能以static覆盖父类的非静态方法
    public void doSth(){
        super.doSth();
        System.out.println("Sub do something");
    }
    //此处必须加上static修饰符，因为实例方法不能覆盖 StaticTest 中的静态方法
    public static void doSthStatic(){
        StaticTest.doSthStatic(); //静态方法不可用super关键字，用父类名直接访问
        System.out.println("Sub do something static");
    }

    public static void main(String[] args){
        System.out.println("sta= "+sta);
        new StaticDemo().doSth();
        doSthStatic();
    }
}

///：output:
/* StaticTEst
   * testStatic
     staticVAr= 1 instanceVar= 1
     staticVAr= 2 instanceVar= 1
   * main
       0
     staticVAr= 1 instanceVar= 1
     staticVAr= 2 instanceVar= 1
     staticVAr= 3 instanceVar= 1
     instanceVar(whole) is:1
     instanceVar(local) is:200
     staticVar(whole) is:3
     staticVar(local) is:500

 *StaticDemo
     sta= 0
     staticVAr= 1 instanceVar= 1
     sta= 1 stb= 1
     Do something...
     Sub do something
     Do something static...
     Sub do something static
 */

通过上面的例子相信你应该对java中的static关键字有一些了解了，如果你还是不理解的话建议找一些看看，下面我们来总结一下。
java中static关键字可用于修饰：
1.属性：表示该属性变量在类被加载时即被创建并初始化，类加载过程只进行一次，因此静态变量也只被创建一次，即内存中只有唯一的一个。
2.方法：静态方法为类的公有方法，可直接用‘类名.方法名'访问，也就是说我们不需要创建一个类的对象，就可以直接访问这个类里面的方法。
  这就好比是我们一提到猫，不用去看具体的是哪只猫，就能想到两只眼睛四条腿，还有一个尾巴，这些都是属于猫共有的。
   静态方法不可访问本类中的非静态成员，子类不可。将父类的静态方法覆盖为非静态的，反之亦然。此外，静态方法中不能使用this关键字。
3.代码块：静态初始化代码块，在类被加载时执行一次，可用于类的初始化。比如我们想要在一个类在初始化的时候就要执行一些内容，
  这些内容可以放到静态代码块中。


如果看完上面的内容。