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); //
     }
 }//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
  */
 //:~~~