final,static关键字

1. static

当一个类初始化时，即执行new来创建对象时，数据存储空间才被分配，其方法才供外界调用。其属性与方法是依赖对象存在的。

当只想为某特定域分配单一存储空间，而不去考虑究竟要创建多少对象或依赖什么对象时，用static关键字：不依赖任何对象实例存在，在类加载的时候便已存在，所有对象实例公用一份存储空间。
非静态变量：对于每一对象有一个存储空间。

static可修饰成员变量，成员方法，或者静态代码块（如果静态代码块有多个，jvm按照顺序执行）。

调用方法：a:通过某个对象实例调用 b:通过类名直接引用。

声明为static的方法有以下几条限制：
· 它们仅能调用其他的static 方法。
· 它们只能访问static数据。
· 它们不能以任何方式引用this 或super。

（1）：静态方法和静态变量

public static void main(String[] args) {

        StaticTest test_one=new StaticTest();
        StaticTest test_two=new StaticTest();

        System.out.println();
        test_one.set();
        System.out.println("test_two:a:"+test_two.a);
    }

    private static int a;

    static{
        System.out.println("static num-first");
        a=3;
        System.out.println("a:"+a);
    }   
    static void set(){
        a=5;
        System.out.println("a:"+a);
    }

当该类开始加载时，其静态代码块开始执行，为静态变量分配存储位置。
result：

static num-first
a:3

a:5
test_two:a:5

（2）静态类
通常一个普通类不允许声明为静态的，只有一个匿名内部类才可以。这时这个声明为静态的内部类可以直接作为一个普通类来使用，而不需实例一个外部类。

---

2：final
在java中，final意味着：这是无法改变的（java编程思想）。致使如此的原因：效率或设计。

• 修饰变量

  一旦final修饰某基本数据并初始化之后，其值不能再被改变，即变为了常量。
  如果对对象的引用而不是对基本类型数据应用采用了final时，一旦引用被初始化指向一个对象，就无法再指向其他对象，但是，该对象本身是可以修改的。

package lls.java.test_1;

import java.util.Random;

import lls.java.test_1.Value.Num_Two;

public class FinalTest {

    public static void main(String[] args) {

        /*1:Test final static variable*/
        FinalTest ft1=new FinalTest("ft1");

//静态变量值不能改变
//ft1.valueOne++;error：The final field FinalTest.valueOne cannot be assigned

        ft1.v2.i++;

        ft1.v1=new Value(9);

//不能再指向其它对象 
//  ft1.v2=new Value(8);error：The final field FinalTest.v2 cannot be assigned

        for(int i=0;i<ft1.a.length;i++){
            ft1.a[i]++;

//不能再指向其它对象
//  ft1.a=new int[3];error：The final field FinalTest.a cannot be assigned       
    }

    private String id;
    public FinalTest(String id){
        this.id=id;
    }

    private static Random rand=new Random(47);

    private final int valueOne=9;
    private static final int VALUE_TWO=99;
    public static final int VALUE_THREE=39;//能被包外访问，却不能修改


    private final int i4=rand.nextInt(20);
    static final int INT_5=rand.nextInt(20);//static :在装载时已被初始化，在不同对象中其值还是一样的

    private Value v1=new Value(11);
    private final Value v2=new Value(22);//指向一个对象，不能再指向别的对象，但被指向的该对象内的值可以修改
    private static final Value VAL_3=new Value(33);

    private final int[] a={1,2,3,4,5,6};
    }
    class Value{
    int i;
    public Value(int i){
        this.i=i;
    }

    static final class Num_Two{
        int  i;
        Num_Two(int i){
            this.i=i;
        }
        void set(int j){
            this.i=j;
        }

    }

}

空白final：
“所谓空白final是指被声明为final但又未给定初值的域，无论什么情况，编译器都能确保final在使用前必须被初始化，空白final在final的使用上提供了更大的灵活性。”–《java编程思想》

final参数：java允许在参数列表中以声明的方式将参数指明为final，这表明你无法在方法中更改参数指向对象。

class Value{
    int i;
    public Value(int i){
        this.i=i;
    }
    void test(final Value v){
    //无法更改
    //v=new Value(2);
    //error：The final local variable v cannot be assigned. It must be blank and not using a compound assignment
    }

• 修饰方法
  “使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升。在最近的Java版本中，不需要使用final方法进行这些优化了。“–《java编程思想》
  而现在让编译器和JVM去处理效率问题，只有在想要明确禁止覆盖时，才将方法设置为final。

  类中的所有private方法都隐式的被制定为final的。

• 修饰类
  被final修饰的类不能被继承。并且final类中的所有方法隐式地指定为final方法。
  3：static,final 一起用
  static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！
  其所具备得到性质是两者都有的。

参考资料：
1：http://blog.csdn.net/anmei2010/article/details/4096131
2：http://www.cnblogs.com/dolphin0520/p/3736238.html
3：http://blog.sina.com.cn/s/blog_605f5b4f0100zbps.html
4：《java编程思想》

总结不全，再接再厉！