java 中的 static 关键字

来源：互联网发布：成都市广电网络分公司编辑：程序博客网时间：2024/06/09 18:47

一. 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 =newPerson("Test");
    static{
        System.out.println("test static");
    }
     
    publicTest() {
        System.out.println("test constructor");
    }
     
    publicstaticvoidmain(String[] args) {
        newMyClass();
    }
   }
 
   classPerson{
    static{
        System.out.println("person static");
    }
    publicPerson(String str) {
        System.out.println("person "+str);
    }
   }
 
 
   classMyClassextendsTest {
    Person person =newPerson("MyClass");
    static{
        System.out.println("myclass static");
    }
     
    publicMyClass() {
        System.out.println("myclass constructor");
    }
    }

后台输出

test staticmyclass staticperson staticperson Testtest constructorperson MyClassmyclass 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的构造器。

阅读全文

2 0