java的static总结

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

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

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

几个例子：

例1：

public class Static{
      static{
          int x = 5;
      }

      static int x,y;

     public static void main(String args[]){
            x--;
            myMethod();
            System.out.println(x + y + ++x);
      }

      public static void myMethod(){
            y = x++ + ++x;
      }
}

分析如下：
首先，是静态变量与静态块的执行顺序问题。接下来才是变量作用域与全局变量之间的关系问题。静态块中定义的变量只会在他的作用域范围内部有效。而且只要是重新定义的，就不会受全局变量的影响。也就是说,main方法中的x--仅仅是针对全局变量的。由于Java会将该变量初始化，此时，i--=0，但是在下次用到 i 时，其值已经变为-1。接下来就是给 y 赋值。同理 x++ 的值应该是 -1 。但是在下次使用 i 时，其值已经变为 0 了。而对“0”累加的结果就是“1”，因此，y的值也是“0”。由此推断，最后结果为“3”

例2：

class StaticVary{
   static int x;
   int y;
   public int x(){
      return x;
   }
   public void setx(int newx){
      x=newx;  
   }

   public void sety(int newy){
      y=newy;  
   }
}

public class StaticVary_test{
   public static void main(String args[]){
        StaticVary p1=new StaticVary();
        StaticVary p2=new StaticVary();
        p1.setx(1);
        p2.setx(3);
       
        p1.sety(8);
        p2.y=10;
        System.out.println("***static:x is****************");
        System.out.println("p1.x="+p1.x());
        System.out.println("p2.x="+p2.x);
       
        System.out.println("***********************");       
        System.out.println("*****obiect:y is******************");
        System.out.println("p1.y="+p1.y);
        System.out.println("p2.y="+p2.y);      
   }

}

例3：

class StaticCode
{
static String country="StaticCode String";

{
    System.out.println("Class StaticCode block is loading!");   
}

static
{
    country = "china";
    System.out.println("country init="+country);
    System.out.println("Class StaticCode static block is loading!");   
}

StaticCode()
{
System.out.println(country);   
}

void ShowMe()
{
System.out.println(country);
}

}

class StaticCode2 extends StaticCode
{
static String country="StaticCode2 String";

   {
     System.out.println("Class StaticCode2 block is loading!");
   }
   static
   {
     System.out.println("Class StaticCode2 static block is loading!");   
   }   

   StaticCode2()
   {
   System.out.println(country);   
   }
  
   void ShowMe()
   {
   System.out.println(country);
   }  
}

class test
{
static
{
    System.out.println("Class test is loading!");
}
public static void main(String [] args)
{
    System.out.println("Begin executing main method!");
    //StaticCode st1=new StaticCode();
    StaticCode st=new StaticCode2();
    st.ShowMe();
}
}

/*

上述的代码执行结果是：

Class test is loading!

Begin executing main method!

country init=china

Class StaticCode static block is loading!

Class StaticCode static2 block is loading!

Class StaticCode block is loading!

china

Class StaticCode2 block is loading!

StaticCode2 String

StaticCode2 String

*/

说明：类的执行顺序是：

父类静态代码 → 子类静态代码 → 父类非静态代码块 → 父类构造 → 子类非静态代码块 → 子类构造

例4：

class StaticTest{
public int x=1;

public static int y=3;
}
public class StaticTester {
public static void main(String[] args) {
   StaticTest.y+=1;
   StaticTest t1=new StaticTest();
   StaticTest t2=new StaticTest();
   t1.x+=1;
   t1.y+=1;
   t2.x+=2;
   t2.y+=2;
   System.out.println("t1:x="+t1.x+",y="+t1.y);
   System.out.println("t2:x="+t2.x+",y="+t2.y);

}

}

输出结果：

t1:x=2,y=7
t2:x=3,y=7

对于static变量y，所有的StaticTest对象都共享同一个y 共用同一个y，JVM只为静态的y分配一次内存