a中static关键字详解。

 

由于学习需要找了半天找到了这篇文章，发现作者写的很不错，就转载给大家：

 

 

static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。     

 

    被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。 

    public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象时，不生成static变量的副本，而是类的所有实例共享同一个static变量。

    private修饰的staitc成员变量，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用），但是不能在其他类中通过类名来直接引用，这一点很重要。而且private修饰的方法，也不能在其他类中通过类名来直接引用。

    实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用 

 

    static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为：

    类名.静态方法名(参数列表...)

    类名.静态变量名

    用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块

 

1.static变量

      声明为static的变量在定义的地方被初始化，并且只能初始化一次。

      如果初始化，就生成类初始化函数<clinit>,否则没有:a.在它被声明的时候赋值, b.在静态或非静态快里初始化 

      按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。两者的区别是： 

　    在类被加载时static修饰的成员变量被初始化，与类关联，只要类存在，static变量就存在。对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。一个static变量单独划分一块存储空间，不与具体的对象绑定在一起，该存储空间被类的各个对象所共享。也就是说当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例对象共用同一个static变量。static修饰的成员变量能在创建任何实例对象之前被访问，而不必引用任何对象，也就是说不管创建多少对象，static修饰的变量只占有一块内存。当运行时，在程序空间中，类的所有对象访问到的静态变量都是同一个值，当其中一个对象改变了静态变量的值，其他对象都将受到影响。

      对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。当某个对象被创建时，它们才真正地存在于内存空间之中，而且对象本身对它们的改变，不会影响到其它对象。就好像 Person的一个对象zhangsan，zhangsan的改变不会影响到其它Person对象一样。

 

      被static修饰而没有被final修饰的类的属性变量只能在两种情况下初始化:(可以不初始化） 

      如果初始化，就生成类初始化函数<clinit>,否则没有

      a.在它被声明的时候赋值,例:

       public class Test{

          public static l int a=8;

          private Test(){

          }

       }

 

      b.在静态或非静态快里初始化

      public class Test{

          public static l int a;

          static{a=50;}

          private Test(){

          }

      }

解释：

当类的属性被同时被修饰为static时候，他属于类的资源（类变量）,在类加载后，进行连接时候，分三步： 先验证；然后准备，准备时，先分配内存，接着默认初始化；可以进行解析。最后，进行类初始化，类初始化前，必须保证它的父类已经初始化了，所以最先初始化的是超类，对于接口，不必初始其父接口。类初始化时，它把类变量初始化语句及静态初始化语句放到类初始化方法中，所以，如果无此两种语句，也就没<clinit>类初始化方法,而构造函数是在当类 被实例化的时候才会执行,所以用构造函数,这时候这个属性没有被初始化.程序就会报错.而static块是类被加载的时候执行,且只执行这一次,所以在 static块中可以被初始化.

 

 

看下面这段代码：

class Value{

  static int c=0;

  static void inc(){

    c++;

  }

}

class Count{

  public static void prt(String s){

    System.out.println(s);

  }

  public static void main(String[] args){

    Value v1,v2;

    v1=new Value();

    v2=new Value();

    prt("v1.c="+v1.c+"  v2.c="+v2.c);

    v1.inc();

    prt("v1.c="+v1.c+"  v2.c="+v2.c);  

  }

}

结果如下：

v1.c=0  v2.c=0

v1.c=1  v2.c=1

 

由此可以证明它们共享一块存储区。static变量有点类似于C中的全局变量的概念。值得探讨的是静态变量的初始化问题。我们修改上面的程序：

 

class Value{

  static int c=0;

  Value(){

    c=15;

  }

  Value(int i){

    c=i;

  }

  static void inc(){

    c++;

  }

}

class Count{

  public static void prt(String s){

    System.out.println(s);

  }

    Value v=new Value(10);

    static Value v1,v2;

    static{

      prt("v1.c="+v1.c+"  v2.c="+v2.c);

      v1=new Value(27);

      prt("v1.c="+v1.c+"  v2.c="+v2.c);

      v2=new Value(15);

      prt("v1.c="+v1.c+"  v2.c="+v2.c);

    }

 

  public static void main(String[] args){

    Count ct=new Count();

    prt("ct.c="+ct.v.c);

    prt("v1.c="+v1.c+"  v2.c="+v2.c);

    v1.inc();

    prt("v1.c="+v1.c+"  v2.c="+v2.c);

    prt("ct.c="+ct.v.c);

  }

}

 

运行结果如下：

 

v1.c=0  v2.c=0

v1.c=27  v2.c=27

v1.c=15  v2.c=15

ct.c=10

v1.c=10  v2.c=10

v1.c=11  v2.c=11

ct.c=11

 

　　这个程序展示了静态初始化的各种特性。如果你初次接触Java，结果可能令你吃惊。可能会对static后加大括号感到困惑。首先要告诉你的是，static定义的变量会优先于任何其它非static变量，不论其出现的顺序如何。正如在程序中所表现的，虽然v出现在v1和v2的前面，但是结果却是v1和v2的初始化在v的前面。在static{后面跟着一段代码，这是用来进行显式的静态变量初始化，这段代码只会初始化一次，且在类被第一次装载时。如果你能读懂并理解这段代码，会帮助你对static关键字的认识。在涉及到继承的时候，会先初始化父类的static变量，然后是子类的，依次类推。

 

　　通常一个普通类不允许声明为静态的，只有一个内部类才可以。这时这个声明为静态的内部类可以直接作为一个普通类来使用，而不需实例一个外部类。如下代码所示：

 

public class StaticCls{

  public static void main(String[] args){

    OuterCls.InnerCls oi=new OuterCls.InnerCls();

  }

}

class OuterCls{

  public static class InnerCls{

    InnerCls(){

      System.out.println("InnerCls");

    }

   }

}

输出结果会如你所料：InnerCls

 

2.static方法

 

    静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。

示例代码：

class Simple{

   static void go(){

     System.out.println("Go...");

   }

}

public class Cal{

  public static void main(String[] args){

    Simple.go();

  }

}

调用一个静态方法就是“类名.方法名”,静态方法的使用很简单如上所示。一般来说，静态方法常常为应用程序中的其它类提供一些实用工具所用，在Java的类库中大量的静态方法正是出于此目的而定义的。     

     声明为static的方法有以下几条限制：

     ◆它们仅能调用其他的static 方法。 

     ◆它们只能访问static数据。 

     ◆它们不能以任何方式引用this 或super

     ◆静态方法中不能定义静态变量

 

3.static代码块

 

    static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个,JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。静态代码块没有名字，因此不能显式调用，而只有在类加载的时候由虚拟机来调用。它主要用来完成一些初始化操作。

 

4、static和final一块用表示什么 

static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！ 

对于变量，表示一旦给值就不可修改，并且通过类名可以访问。 

对于方法，表示不可覆盖，并且可以通过类名直接访问。

同时被final和static修饰的类的属性变量只能在两种情况下初始化:（必须初始化）

 a.在它被定义的时候,例: 

   public class Test{

       public final static int a=5;

       private Test(){

       }

   }

 b.在类的静态块里初始化,例: 

   public class Test{

       public final static int a;

       static{

         a=0;

       }

   }

 c、特别对于初始化时候调用抛出异常的构造函数，初始时候注意，特别是在实现单例模式时(只能这么初始化）

如：

   class A { 

       private final static A a;

       static {

         try {

            a=new A();

         }catch(Exception e){

            throws new RuntimeException(e);  //必须有，不然不能完成常量的正确初始化

         }

       }

       private A() throws Exception{}

    }

解释：

当类的属性被同时被修饰为static和final的时候，他属于类的资源（类常量）,那么就是类在被加载进内存的时候(也就是应用程 序启动的时候)就要已经为此属性分配了内存,所以此时属性已经存在,它又被final修饰,所以必须在属性定义了以后就给其初始化值.而构造函数是在当类 被实例化的时候才会执行,所以用构造函数,这时候这个属性没有被初始化.程序就会报错.而static块是类被加载的时候执行,且只执行这一次,所以在 static块中可以被初始化.

 

 

static特殊讲解：

　　请先看下面这段程序：

 

  public class Hello{

    public static void main(String[] args){ //(1)

      System.out.println("Hello,world!");   //(2)

    }

  }

 

　　看过这段程序，对于大多数学过Java 的从来说，都不陌生。即使没有学过Java，而学过其它的高级语言，例如C，那你也应该能看懂这段代码的意思。它只是简单的输出“Hello,world”，一点别的用处都没有，然而，它却展示了static关键字的主要用法。

 

    在1处，我们定义了一个静态的方法名为main，这就意味着告诉Java编译器，我这个方法不需要创建一个此类的对象即可使用。你还记得你是怎么运行这个程序吗？一般，我们都是在命令行下，打入如下的命令：

javac Hello.java

java Hello

Hello,world!

　　这就是你运行的过程，第一行用来编译Hello.java这个文件，执行完后，如果你查看当前，会发现多了一个Hello.class文件，那就是第一行产生的Java二进制字节码。第二行就是执行一个Java程序的最普遍做法。执行结果如你所料。在2中，你可能会想，为什么要这样才能输出。好，我们来分解一下这条语句。（如果没有安装Java文档，请到Sun的官方网站浏览J2SE API）首先，System是位于java.lang包中的一个核心类，如果你查看它的定义，你会发现有这样一行：public static final PrintStream out;接着再进一步，点击PrintStream这个超链接，在METHOD页面，你会看到大量定义的方法，查找println，会有这样一行：

 

public void println(String x)。

好了，现在你应该明白为什么我们要那样调用了，out是System的一个静态变量，所以可以直接使用，而out所属的类有一个println方法。

 

通常一个普通类不允许声明为静态的，只有一个内部类才可以。这时这个声明为静态的内部类可以直接作为一个普通类来使用，而不需实例一个外部类。如下代码所示：

 

public class StaticCls{

  public static void main(String[] args){

    OuterCls.InnerCls oi=new OuterCls.InnerCls();

  }

}

class OuterCls{

  public static class InnerCls{

    InnerCls(){

      System.out.println("InnerCls");

    }

   }

}

 

输出结果会如你所料：InnerCls

 

 

 

static，final初始化总结：

1、被final修饰而没有被static修饰的类的属性变量只能在两种情况下初始化:(必须初始化）

   a.在它被声明的时候赋值;b.在构造函数里初始化;c .在非静态块里

2、被static修饰而没有被final修饰的类的属性变量只能在两种情况下初始化:(可以不初始化）

   a.在它被声明的时候赋值;b.在静态或非静态快里初始化;

3、同时被final和static修饰的类的属性变量只能在两种情况下初始化:（必须初始化）

   a.在它被定义的时候;b.在类的静态块里初始化

 

 

 

 

1.final变量：

 

      当你在类中定义变量时，在其前面加上final关键字，那便是说，这个变量一旦被初始化便不可改变，这里不可改变的意思对基本类型来说是其值不可变，而对于对象变量来说其引用不可再变。其初始化可以在两个地方，一是其定义处，也就是说在final变量定义时直接给其赋值，二是在构造函数中。这两个地方只能选其一，要么在定义时给值，要么在构造函数中给值，不能同时既在定义时给了值，又在构造函数中给另外的值。另外也可以在非静态块里初始化

   public class Test{

       private final int a;

          {

             a=3;  //在非静态块里初始化 

          }

   }

解释：当这个属性被修饰为final,而非static的时候,它属于类的实例对象的资源(实例常量）,当类被加载进内存的时候这个属性并没有给其分配内存空间,而只是 定义了一个变量a,只有当类被实例化的时候这个属性才被分配内存空间,而实例化的时候同时执行了构造函数,所以属性被初始化了,也就符合了当它被分配内存 空间的时候就需要初始化,以后不再改变的条件.

 

     当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。

 

     另外方法中的内部类在用到方法中的参变量时，此参变也必须声明为final才可使用

 

2.final方法

 

     如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。 

使用final方法的原因有二： 

    第一、把方法锁定，防止任何继承类修改它的意义和实现。 

    第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。

 

3.final类

 

     final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。

 

由于学习需要找了半天找到了这篇文章，发现作者写的很不错，就转载给大家