java 中的 static 关键字

一. Java中的 static 关键字作用：主要是用来做  内存管理  的

 1.1. 为某特定数据类型或对象分配单一的存储空间，而与创建对象的个数无关。

 1.2. 实现某个方法或属性与 类 相关，而不是类的对象，即，不需要创建类的实例，从而节约了内存

二. 具体应用

     在Java中,static  可修饰成员变量，方法。代码块，内部类。被static修饰的所属类，在类被加载时 就会被一同加载。切记：在Java中,static是不允许用来修饰局部变量。

 2.1. 静态变量 (被static修饰的成员变量)

    2.1.1.什么时候使用静态变量：

              在对象之间 共享 值时
              方便访问变量时

   2.1.2.静态变量的使用

 静态变量随着类的加载而加载。
 静态变量优先于对象存在。
 静态变量被 所有对象 所 共享，存储在方法区的 静态区 中。
 静态变量多了一个调用方式，可以被类名直接调用。

 2.1.3. 静态变量    VS     实例 / 成员变量（ 非静态变量）

            静态变量也称为 类变量，被所有的对象所共享，在内存中只有 一个 副本，它当且仅当在类初次加载时会被初始化一次，并由虚拟机来保证它的线程安全性；实例变量，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。
            静态变量随着类的加载而加载，也随着类的消失而消失，生命周期最长；实例变量随着对象的创建而加载，随着对象的消失而消失。按照对象的生命周期而存在。
            静态变量 存储在方法区的 静态区 中；实例变量 存在于对象所属的 堆内存 中。

            静态变量数据，被所有对象所共享；实例变量 是对象中的特有数据

2.2. 静态方法（声明方法的时候加上 static 关键字）

       2.2.1.静态方法可以直接通过  类名  调用，任何的实例也都可以调用；而非static方法是对象的方法，只有对象被创建出来后才可以被使用。

       2.2.2.静态方法  只能  访问所属类的 静态成员变量和成员方法 (因为 静态方法属于类，直接通过类名就可以调用，而此时可能没有任何实例，更谈不上操作实例变量和调用实例方法了）；非静态方法既可以访问静态又可以访问非静态。

       2.2.3.static方法中不能使用 this 和 super 关键字。因为this代表是对象。而静态存在时，有可能没有对象。所以静态方法运行时，this是没有任何对象代表的。

       2.2.4.main方法是 static的 (为了使得在调用main方法之前不需要创建任何实例对象)

       2.2.5. 即使没有显示地声明为static，类的构造器实际上也是静态方法。

 2.3. 静态代码块 -----------  优化程序性能(只会在类加载的时候执行一次，可将一些只需要进行一次的初始化操作都放在static代码块中进行。)

     2.3.1.用来初始化静态变量。

     2.3.1.static块可以置于类中的任何地方（只要不是方法内部），类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。

总结：无论是变量，方法，还是代码块，只要用static修饰，就是在类被加载时就已经"准备好了",也就是可以被使用或者已经被执行，都可以脱离对象而执行。反之，如果没有static，则必须要依赖于对象实例。

 2.4.静态内部类（被static修饰的类，处于某个类的内部，在外部类被加载时就被加载了并且只会被加载一次）------------  可 高效利用内存，而且使得代码简洁

      2.4.1. 静态内部类可以访问外部类的静态成员，包括private成员，但 不能访问外部类的非静态成员。

      2.4.2. 为什么要有静态内部类呢？看下面的例子：

   //外部类
   class Outer{  
    static int data = 111;  
     //静态内部类
     static class Inner{  
      void msg(){
       System.out.println("data is " + data);}  
     } 

  
  

   
       public 
   
   class 
   
   Demo {

  
  
    public static void main(String args[]){  
    Outer.Inner obj= new Outer.Inner();  
    obj.msg();  
    }  
 }  

后台输出 :data is 111

      main方法中创建了一个静态内部类的实例，并且调用了其msg() 方法。但是这里并没有创建外部类的实例，因为这里的Inner类是static的，并且可以访问外围类的static成员。如果把Inner之前的static去掉，那么这里要这样写：

Outer.Inner obj = new Outer().new Inner();（需要先创建外一个部类实例，然后才能创建内部类实例。obj 是 Inner 的实例）

      static 内部类编译后的样子：

  // Internal class generated by the compiler
  import java.io.PrintStream;  
  static class Outer$Inner{  
  Outer$Inner(){}  
  void msg(){  
  System.out.println((new StringBuilder()).append("data is ").append(Outer.data).toString());  
  }    
  } 

      上例中，如果msg() 方法也是静态的，那么内部类的实例也不需要创建了：

 class Outer2{  
   static int data=111;  
   static class Inner{  
    static void msg(){System.out.println("data is "+data);}  
   }
}

  
  

   
   public 
   
   class 
   
   Demo {

  
  
   public static void main(String args[]){  
      Outer2.Inner.msg();//no need to create the instance of static nested class  
   }  
 }  

后台输出 :data is 111

三.单例设计模式：

     static一个很重要的用途就是实现单例设计模式。单例模式的特点是该类只能有一个实例，为了实现这一功能，必须  隐藏  类的构造函数，即把构造函数声明为 private，并提供一个创建对象的方法，由于构造对象被声明为private，外界无法直接创建这个类型的对象，只能通过该类提供的方法来获取类的对象，要达到这样的目的只能把创建对象的方法声明为static，程序实例如下：

  
  

   
   class 
   
   Singleton
   
   {
  
  
  
  
	
   
   private 
   
   static 
   
   Singleton 
   
   instance
   
    = 
   
   null
   
   ;
  
  
  
  
	
   
   private 
   
   Singleton
   
   (){}
  
  
  
  
	
   
   public 
   
   static 
   
   Singleton 
   
   getInstance
   
   (){
  
  
  
  
		
   
   if
   
   (
   
   instance
   
    == 
   
   null
   
   ){
  
  
  
  
			
   
   instance 
   
   = 
   
   new 
   
   Singleton
   
   ();
  
  
  
  
		
   
   }
  
  
  
  
		
   
   return 
   
   instance
   
   ;
  
  
  
  
	
   
   }
  
  
  
  

   
   }
  
  

四. 案例

  public class Test {

     Person person = new Person( "Test" );

     static {

         System.out.println( "test static" );

     }

     

     public Test() {

         System.out.println( "test constructor" );

     }

     

     public static void main(String[] args) {

         new MyClass();

     }

   }

 

   class Person{

     static {

         System.out.println( "person static" );

     }

     public Person(String str) {

         System.out.println( "person " +str);

     }

   }

 

 

   class MyClass extends Test {

     Person person = new Person( "MyClass" );

     static {

         System.out.println( "myclass static" );

     }

     

     public MyClass() {

         System.out.println( "myclass constructor" );

     }

    }

后台输出 

test static
myclass static
person static
person Test
test constructor
person MyClass
myclass constructor

       这段代码的具体执行过程。首先加载Test类，因此会执行Test类中的static块。接着执行new MyClass()，而MyClass类还没有被加载，因此需要加载MyClass类。在加载MyClass类的时候，发现MyClass类继承自Test类，但是由于Test类已经被加载了，所以只需要加载MyClass类，那么就会执行MyClass类的中的static块。在加载完之后，就通过构造器来生成对象。而在生成对象的时候，必须先初始化父类的成员变量，因此会执行Test中的Person person = new Person()，而Person类还没有被加载过，因此会先加载Person类并执行Person类中的static块，接着执行父类的构造器，完成了父类的初始化，然后就来初始化自身了，因此会接着执行MyClass中的Person person = new Person()，最后执行MyClass的构造器。