java关键字static学习心得

static是java中又一重要的关键字，在一定环境下使用，可以提高程序的运行性能，优化程序的结构。其主要应用有以下几方面：

1.static修饰的成员变量，称为类变量/静态变量，以实现所有对象对该成员的共享。

2.static修饰的成员方法，称为类方法/静态方法，可直接通过类名调用，无需创建对象。

3.形成静态代码块，优化程序性能。

4.静态导包，一般将类的方法直接导入到当前类中，从而直接使用方法名即可调用类方法，更加方便。

5.修饰内部类，无需实例化外部类就可以调用内部类。

下面一附代码说明：

public class student {
    string name;
    static int age;
    public string tostring() {
      return "name:" + name + ", age:" + age;
    }
    public static void main(string[] args) {
     student s1 = new student();
      s1.name="张三";
      s1.age=20;
      student s2 = new student();
      s2.name="李四";
      s2.age=10;
      system.out.println(s1);
      system.out.println(s2);
    }
}
/**输出结果
name:张三, age:10
name:李四, age:10
*/

如上述代码，s1和s2两个对象分别存储在内存中堆区域的不同地址中，所以他们之间相互不会干扰。然而static关键字修饰了成员变量age，让其变成类的所属，而不是对象的所属，任何该类实例的对象都可以共享使用它。所以，输出的age均是最终赋给的10。如果去掉static，显然对象之间互不影响，输出如下：

name:张三, age:20
name:李四, age:10

如上述代码，out1调用out2时出错。由此代码可得，静态方法不能调用非静态的成员变量和成员方法。非静态方法可以调用静态的成员变量和成员方法。注意，static不影响成员的访问权限，java中能够影响到访问权限的关键词是private、public、protected，default。

public class test extends base{
  static{
    system.out.println("static静态块1");
  }
  public test(){
    system.out.println("test构造器");
  }  
  public static void main(string[] args) {
    new test();
  }
} 
class base{
  static{
    system.out.println("static静态块2");
  }
  public base(){
    system.out.println("base构造器");
  }
}

如上述代码，记住两句话，static代码块随类的加载一起加载。static修饰的变量方法比其他变量方法优先加载，且只加载一次。加载子类时，会首先加载父类。由此可以分析：在执行开始，先要寻找到main方法，因为main方法是程序的入口，但是在执行main方法之前，必须先加载test类，而在加载test类的时候发现test类继承自base类，因此会转去先加载base类，在加载base类的时候，发现有static块，便执行了static块。在base类加载完成之后，便继续加载test类，然后发现test类中也有static块，便执行static块。在加载完所需的类之后，便开始执行main方法。在main方法中执行new test()的时候会先调用父类的构造器，然后再调用自身的构造器。因此，运行结果如下：

static静态块2
static静态块1
base构造器
test构造器

/* a.java文件 */
package com.dogo.test;
public class a {
  public static void outword(object o){
    system.out.println(o);
  }
}
/* b.java文件 */
import static com.dogo.test.a.*;
public class b
{
  public static void main( string[] args )
  {
    outword("hello world!");
  }
  /**输出
   * hello world!
   */
}

如上述代码，a.java中包含一个简单的静态方法，在b.java中我们用static关键字将a类导入，由此，便无需使用“类名.方法名”的方法去调用类方法了，直接可以采用"方法名"去调用类方法，就好像是该类自己的方法一样。

/*outer.java*/
public class outer {
　　static {
    system.out.println("outer静态块");
  }
  public outer(){
    system.out.println("outer构造器");
  }
  static class inner{
    static{
      system.out.println("inner静态块");
    }
    
    public inner(){
      system.out.println("inner构造器");
    }
  }
}
/*test.java*/
public class test{
  public static void main(string[] args) {
    new outer.inner();
  }
}

如上述代码，记住，用static修饰内部类，外部类可以直接调用内部类，因为static修饰的的内部类是在加载外部类的同时加载的，所以，并不要实例化外部类就能直接调用静态内部类。例子中，在进入test的main方法之前，加载test类，然后执行new outer.inner();这里需要注意：因为inner是静态的，所以这里并不需要加载外部类和实例化外部类，可以直接加载inner并实例化。运行结果如下：

inner静态块
inner构造器

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

class singledemo{ 
    private static singledemo ins=null; 
    private singledemo(){} 
    public static singledemo getins(){ 
      if(ins==null){ 
        ins=new singledemo(); 
      } 
      return ins; 
    } 
  }