4.JAVA中static和final关键字

[size=large]static：
用来修饰成员变量和成员方法，也可以形成静态static代码块。 被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。
因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象.
当声明它类的对象时，不生成static变量的副本，而是类的所有实例共享同一个static变量.
static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以[color=blue]直接通过类名来访问[/color]，
访问语法为：
类名.静态方法名(参数列表...)
类名.静态属性

static方法：
静态方法不能直接访问所属类的非静态变量和非静态方法.
(如需使用必须先实例化对象 new XXX（） main方法也是静态方法）
只能访问所属类的静态成员变量和成员方法因为实例成员与特定的对象关联.
因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象abstract.静态方法可以被子类所继承,但静态方法不能被子类override.因此不支持多态性.
举一个例子： [/size]

class Base { 
   public static void someMethod() { 
        System.out.println("in static method of Base");
     }
 } 
class Derived extends Base {
   public static void someMethod() { 
        System.out.println("in static method of Derived");
     }
 } 
class Client { 
    public static void main(String[] args) {
        Derived.someMethod(); 
        Derived d = new Derived(); 
        d.someMethod(); 
        Base o = new Derived();
        o.someMethod(); 
} 
} 

[size=large]
执行时会打印出
in static method of Derived
in static method of Derived
in static method of Base
显然，到底执行哪一个静态方法，是由变量的明显类型决定的，而不是由对象的真实类型决定。这不是多态性的。

static代码块：
用static修饰的代码块表示静态代码块.是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次.同样不能直接访问所属类的非静态变量和非静态方法（如需使用必须先实例化对象 new XXX（）)


final：
根据程序上下文环境，Java关键字final有“这是无法改变的”或者“终态的”含义，
它可以修饰非抽象类、非抽象类成员方法和变量。

final类：
final类不能被继承，没有子类，final类中的方法默认是final的。
final方法不能被子类的方法覆盖，但可以被继承。
final成员变量表示常量，只能被赋值一次，赋值后值不再改变。 final不能用于修饰构造方法。一旦给final变量初值后，值就不能再改变了, 但一个类中的final数据成员就可以实现[color=blue]依不同实例而有所不同[/color]，却有保持其恒定不变的特征。[/size]

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; 
 } 
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(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; 出错,已经给赋过值了. 
} 

[size=large]final参数 当函数参数为final类型时，你可以赋值,使用该参数，但是[color=blue]无法二次修改该参数的值[/color]。 [/size]

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); 
} 
} 

[size=large]final只对引用的"值"(即内存地址)有效，它迫使引用只能指向初始指向的

那个对象，改变它的指向会导致编译期错误。[color=blue]至于它所指向的对象的变化，final是不负责

的[/color]。[/size]

final StringBuffer a = new StringBuffer("111");  

final StringBuffer b = new StringBuffer("222");  

a=b;//此句编译不通过  

final StringBuffer a = new StringBuffer("111");  

a.append("222");//编译通过

final ArrayList al=new ArrayList();

al.add("aa");

al.add("aa");

[size=large][b]static final：[/b] static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！ 对于变量，表示一旦给值就不可修改，并且通过类名可以访问。 对于方法，表示不可覆盖，并且可以通过类名直接访问 [/size]