Static final关键字

static 可以修饰:

1. 语句块

2. 成员变量(但是不能修饰局部变量)

3. 方法

4. 接口(内部接口)

5. 类(只能修饰在类中的类, 即静态内部类)

6. jdk 1.5 中新增的静态导入

那么static 修饰的表示什么呢? 当创建一个类时, 就是在创建一个新类型,描述这个类的对象的外观和行为,除非用new创建出那个类的对象, 数据存储空间才被分配, 其方法才供外界调用.

那么当声明一个事物为static时,就意味着这个域或者方法不会与包含它的那个类的任何对象关联在一起, 也就是说, 它不依赖类特定的实例, 被类的所有实例共享, 只要这个类被加载,  Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们. 因此, static对象可以在它的任何对象创建之前访问, 无需引用任何对象…

1. static 修饰语句块:

static{}  可以有多处, 执行顺序按照他们的声明顺序.  当JVM加载这个类的时候, 就会执行此语句块, 并且只执行一次.

2. static 变量:

static的变量, 可以被类的对象共享, 并且它只有一份存储空间,JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配  那么在引用static变量的时候, 使用类名.变量名是首选的方式,  因为他不仅强调它是static结构, 而且在某些情况下会为编译器进行优化提供更好的机会.

使用类名直接引用static变量是我们力荐的，这样就很明确的告诉大家该变量或属性是static结构的或是static修饰的。
但是我想说一个更重要的知识点。static 在类中当变量的重要使用方法，首先楼主先运行一下下面代码试试：

代码如下

复制代码

public class Person {  static int[] arr=new int[3];  public static void main(String[] args){   Person per1=new Person();   Person per2=new Person();   Person per3=new Person();   System.out.println("----改变之前-----");   System.out.print("per1-->");   per1.show();   System.out.print("per2-->");   per2.show();   System.out.print("per3-->");   per3.show();   //现在我改变它的值   Person.arr[2]=10;//这种方法是建议的   per1.arr[0]=1;//一般不用这种方法   System.out.println("----改变之后-----");   System.out.print("per1-->");   per1.show();   System.out.print("per2-->");   per2.show();   System.out.print("per3-->");   per3.show();     }  //为了方便，封装一个方法，来解释  public  void show(){   for(int i=0;i<arr.length;i++){    System.out.print(arr[i] + "t");   }   System.out.println("");  } }

如果是不加static的arr[]我们应该很好理解吧。就是per1如果改变的话不会影响到per2的值。

 

   类似的形式同样应用在使用static修饰的方法上面(称为静态方法)。它可以像普通方法一样使用对象来引用，也可以通过特殊的语法形式来调用如：“类名”+“ . ”+“方法”，();   定义静态方法的方式与定义静态变量一样：

 

  

代码如下	复制代码
public class StaticTest2 {         static void method(){ ("这是静态方法"); }      }

   普通的调用方法：StaticTest2 st = new StaticTest2();   ();

 

   因为method是static修饰的(静态方法)，所以可以这样调用：();

 

3. static方法:

static的方法与非static的方法的区别在于: 可以用类名直接访问.在static方法内部, 不能引用非static的变量或者方法，但是你可以通过传递参数的方式传递一个引用，让这个引用去调用非静态数据

4. static 接口:

内部接口（inner interface)本身就默认是static,所以static关键词加与不加都是一样的, 如此例中的接口:TestInInterface , TestInClass 实现此接口, 以下语句

代码如下	复制代码
StaticDescription.TestInInterface a = new StaticDescription.TestInClass();    a.print();

我们去掉static关键字也是一样的, 但还是受访问权限控制TestInterface和FF。

5. static 修饰类:(后部分会详细说明)

表示他是一个静态内部类, 他在引用外部类的事物时, 必须也是static的                而且, 静态内部类在创建自己的对象时, 是不需要外围类的存在. 就好像下面的部分:

实例

代码如下

复制代码

class Member {  static int classVar = 0; //类变量  int instanceVar;  //实例变量  Member(int instanceVar) {  this.instanceVar = instanceVar;  }  static void setClassVar(int i) {   classVar=i;   instanceVar=i;    // 类方法不能访问实例变量，只能访问类变量  }  static int getClassVar() //类方法  { return classVar; }  void setInstanceVar(int i){   classVar=i;     //实例方法不但可以访问类变量，也可以实例变量      instanceVar=i;  }  int getInstanceVar( )   { return instanceVar; } ｝

    Member未实例化：                                                                                                              Member实例化之后：

对于非静态数据成员，每个类对象都有自己的拷贝。而静态数据成员被当作是类的成员。无论这个类的对象被定义了多少个，静态数据成员在程序中也只有一份拷贝，由该类型的所有对象共享访问。也就是说，静态数据成员是该类的所有对象所共有的。对该类的多个对象来说，静态数据成员只分配一次内存，供所有对象共用。所以，静态数据成员的值对每个对象都是一样的，它的值可以更新；

代码如下	复制代码
Member m1 = new Member(); Member m2 = new Member();

内存分配

引用static变量有两种方法。如前例所示，可以通过一个对象去定位它，如m1.classVar;

也可以通过其类名直接引用，如Member.classVar,而对于非静态成员则不行。

尽管当static作用于某个字段市，肯定会改变数据的创建方式（因为一个static字段对每个类来说都只有一份存储空间，而非static字段则是对每个对象都有一个存储空间），但是如果static用于某个方法，差别却没有那么大。static方法的一个重要用法就是在不创建任何对象的前提下就可以调用它。这一点，对定义main()方法很重要，这个方法是运行一个应用时的入口点。

static方法就是没有this的方法。在static方法的内部不能调用非静态方法，反过来倒是可以的。而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途。它很像全局方法。Java中禁止使用全局方法，但你在类中置入static方法就可以访问其他static方法和static域。

和其他任何方法一样，static方法可以创建或使用与其类型相同的被命名对象，因此，static方法通常拿来做“牧羊人”的角色，负责看护与其奴隶同一类型的实例群。

不过，要是在代码中出现大量的static方法，就该重新考虑自己的设计了

一、final 
        根据程序上下文环境，Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。 
        final类不能被继承，没有子类，final类中的方法默认是final的。 
        final方法不能被子类的方法覆盖，但可以被继承。 
        final成员变量表示常量，只能被赋值一次，赋值后值不再改变。 
        final不能用于修饰构造方法。 
        注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。 

1、final类 
        final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。 
2、final方法 
        如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。 
      使用final方法的原因有二： 
        第一、把方法锁定，防止任何继承类修改它的意义和实现。 
        第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。 
        例如： 

Java code

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

public  class  Test1 {    public  static  void  main(String[] args) {  // TODO 自动生成方法存根  }    public  void  f1() {  System.out.println( "f1" );  }  //无法被子类覆盖的方法  public  final  void  f2() {  System.out.println( "f2" );  }    public  void  f3() {  System.out.println( "f3" );  }    private  void  f4() {  System.out.println( "f4" );  }  }    public  class  Test2  extends  Test1 {    public  void  f1(){  System.out.println( "Test1父类方法f1被覆盖!" );  }    public  static  void  main(String[] args) {  Test2 t= new  Test2();  t.f1();  t.f2();  //调用从父类继承过来的final方法  t.f3();  //调用从父类继承过来的方法  //t.f4(); //调用失败，无法从父类继承获得    }  }

3、final变量（常量） 
        用final修饰的成员变量表示常量，值一旦给定就无法改变！ 
        final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。 
        从下面的例子中可以看出，一旦给final变量初值后，值就不能再改变了。 
    另外，final变量定义的时候，可以先声明，而不给初值，这中变量也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须被初始化。但是，final空白在final关键字final的使用上提供了更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同，却有保持其恒定不变的特征。 

Java code

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

package  org.leizhimin;    public  class  Test3 {  private  final  String S= "final实例变量S" ;  private  final  int  A= 100 ;  public  final  int  B= 90 ;    public  static  final  int  C= 80 ;  private  static  final  int  D= 70 ;    public  final  int  E;  //final空白,必须在初始化对象的时候赋初值    public  Test3( int  x){  E=x;  }    /**  * @param args  */  public  static  void  main(String[] args) {  Test3 t= new  Test3( 2 );  //t.A=101; //出错,final变量的值一旦给定就无法改变  //t.B=91; //出错,final变量的值一旦给定就无法改变  //t.C=81; //出错,final变量的值一旦给定就无法改变  //t.D=71; //出错,final变量的值一旦给定就无法改变    System.out.println(t.A);  System.out.println(t.B);  System.out.println(t.C);  //不推荐用对象方式访问静态字段  System.out.println(t.D);  //不推荐用对象方式访问静态字段  System.out.println(Test3.C);  System.out.println(Test3.D);  //System.out.println(Test3.E); //出错,因为E为final空白,依据不同对象值有所不同.  System.out.println(t.E);    Test3 t1= new  Test3( 3 );  System.out.println(t1.E);  //final空白变量E依据对象的不同而不同  }    private  void  test(){  System.out.println( new  Test3( 1 ).A);  System.out.println(Test3.C);  System.out.println(Test3.D);  }    public  void  test2(){  final  int  a;  //final空白,在需要的时候才赋值  final  int  b= 4 ;  //局部常量--final用于局部变量的情形  final  int  c;  //final空白,一直没有给赋值.  a= 3 ;  //a=4; 出错,已经给赋过值了.  //b=2; 出错,已经给赋过值了.  }  }

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

Java code

?

1 2 3 4 5 6 7 8 9 10

public  class  Test4 {  public  static  void  main(String[] args) {  new  Test4().f1( 2 );  }    public  void  f1( final  int  i){  //i++; //i是final类型的,值不允许改变的.  System.out.print(i);  }  }

二、static 
        static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。 
  被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。 
        用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象时，不生成static变量的副本，而是类的所有实例共享同一个static变量。 
        static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用--废话），但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用，这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。 
        static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为： 
        类名.静态方法名(参数列表...) 
        类名.静态变量名 
        用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块（用处非常大，呵呵）。 
1、static变量 
        按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。两者的区别是： 
        对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。 
        对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。 

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

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

Java code

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

public  class  Test5 {  private  static  int  a;  private  int  b;    static {  Test5.a= 3 ;  System.out.println(a);  Test5 t= new  Test5();  t.f();  t.b= 1000 ;  System.out.println(t.b);  }  static {  Test5.a= 4 ;  System.out.println(a);  }  public  static  void  main(String[] args) {  // TODO 自动生成方法存根  }  static {  Test5.a= 5 ;  System.out.println(a);  }  public  void  f(){  System.out.println( "hhahhahah" );  }  }

                运行结果： 
                3 
                hhahhahah 
                1000 
                4 
                5 
        利用静态代码块可以对一些static变量进行赋值，最后再看一眼这些例子，都一个static的main方法，这样JVM在运行main方法的时候可以直接调用而不用创建实例。 
4、static和final一块用表示什么 
        static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！ 
        对于变量，表示一旦给值就不可修改，并且通过类名可以访问。 
        对于方法，表示不可覆盖，并且可以通过类名直接访问。