static关键字用法

java中static关键字可用于修饰：

1.属性：表示该属性变量在类被加载时即被创建并初始化，类加载过程只进行一次，因此静态变量也只被创建一次

2.方法：静态方法为类的公有方法，可直接用‘类名.方法名'访问，静态方法不可访问本类中的非静态成员，子类不可

将父类的静态方法覆盖为非静态的，反之亦然。此外，静态方法中不能使用this关键字，也不能用super关键字去访问

父类静态方法，可直接用'父类.父类静态方法名'访问。

3.代码块：静态初始化代码块，在类被加载时执行一次，可用于类的初始化

具体实例：

1）下面的例子中，静态变量staticVar，只在类第一次加载时被创建并初始化，以后无论创建多少类对象，该变量都不再

加载，因此每次都在原有基础上增加1，而实例变量instanceVar，只有当创建类对象时才对其进行创建并在构造函数中

加1，每创建一个对象，就对应创建一个instanceVar实例变量。注意：在静态方法中访问instanceVar将报错。

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

package com.pattywgm.a_fundamental;

import org.junit.Test;

/**
 * 
 * @author patty
 * @time 2014-12-4
 * @todo 考查static关键字的用法
 */
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
 */
//:~~~