解析Java中final关键字的各种用法

首先，我们可以从字面上理解一下final这个英文单词的中文含义：“最后的，最终的; 决定性的; 不可更改的；”。显然，final关键词如果用中文来解释，“不可更改的”更为合适。当你在编写程序，可能会遇到这样的情况：我想定义一个变量，它可以被初始化，但是它不能被更改。

例如我现在想要定义一个变量保存圆周率的值，作为一个客观的、正确性有保障的值，如果在后序程序中更改它，可能会造成结果的错误，甚至程序的崩溃。那么这个时候final关键字就可以发挥它的用处了。不过，final不仅仅可以用来修饰数值，它还有其他的用法，看过下面的实例应该会有个基本的了解。

如有错误，欢迎批评指正。

1.用final来修饰数据

1.1用final来修饰数值：

//例1
public class Demo{
    public static void main(String[]args){
        final double PI=3.14;
        System.out.println(PI);
        PI=3.1;
        System.out.println(PI);
    }
}

如例1所示，如果修改final修饰的变量PI，会发生什么呢？

好吧，编译都不能通过，说明final修饰过后的数值变量是不能改变的。

现在又有一个疑问，如果final定义的变量，没有初始化，会不会报错？见例2：

//例2
public class Demo{
    public static void main(String[]args){
        final double PI;
        System.out.println(PI);
    }
}

还是会报错，其实这个和fina的关系不大，仅仅因为没有赋值，就算没有final，也是会报错（亲测）。

1.2上面说的是数值，如果final修饰的是对象呢？

//例3
public class Demo{
    public static void main(String[]args){
        final Cat cat1=new Cat(1);
        Cat cat2=new Cat(2);
        cat1=cat2;
    }
}

class Cat{
    private int id=0;
    private int age=0;
    Cat(int id){this.id=id;}
    public void setAge(int age){
        this.age=age;
    }
}

编译依然通不过。

但是cat1长大一岁了，我想修改一下他的年龄，可不可以呢，贴一段测试代码：

//例4
public class Demo{
    public static void main(String[]args){
        final Cat cat1=new Cat(1);
        //Cat cat2=new Cat(2);
        cat1.setAge(1);
        System.out.println(cat1.getAge());
    }
}

class Cat{
    private int id=0;
    private int age=0;
    Cat(int id){this.id=id;}
    public void setAge(int age){
        this.age=age;
    }
    public int getAge(){
        return age;
    }
}

运行结果：

编译运行都毫无障碍。说明什么呢？当用final来修饰对象时，不能改变对象的引用，但是可以修改对象的属性值。cat1只能指向id为1的猫，如果让它指向cat2所指的猫，编译器会报错（例3）。

1.3用final来修饰参数

当final来修饰形参时，形参也是不能被更改的，例如我在获取年龄的时候，偷偷地改一下ID：

 

public class Demo{
    public static void main(String[]args){
        Cat cat1=new Cat(1);
        System.out.println(cat1.getAge(1));
    }
}

class Cat{
    private int id=0;
    private int age=0;
    Cat(int id){this.id=id;}
    public void setAge(int age){
        this.age=age;
    }
    public int getAge(final int id){
        id++;
        return this.age;
    }
}

果然报错了！

2.final修饰方法（函数）的时候

一般用final修饰方法的目的是：锁住方法，防止继承它的类来修改（覆盖）它。例如Cat类是动物，所以它继承了动物类Animal，但是每个动物都有规定：不能伤害人类，所以Animal的rule方法用final修饰一下，不允许继承者们修改，代码如下：

public class Demo{
    public static void main(String[]args){
        Cat cat1=new Cat(1);
        cat1.rule();
        //System.out.println(cat1.getAge());
    }
}
class Animal{
    public final void rule(){
        System.out.println("do not hurt people!");
    }
}
class Cat extends Animal{
    private int id=0;
    private int age=0;
    Cat(int id){this.id=id;}
    public void setAge(int age){
        this.age=age;
    }
    public int getAge(){
        return age;
    }
    public final void rule(){
        System.out.println("I want to hurt people!");
    }
}

当我尝试覆盖基类方法时，失败了。当然，例子举的是public修饰的方法，但如果是private修饰的方法，本身对子类就不可见，更别说覆盖了。

3. 用final来修饰类：

用final来修饰类的时，说明这个类从设计之初，就不打算用来被继承，换句话说，也不允许其他人来继承这个类，从而保证安全性。例如我在Animal类前加个final

编译报出的错误很明确：无法被继承。

4.final 和 static的区别

用final修饰，主要是为了表现“不可修改性”，从而提高安全性 。而static重点在于共享，方便。在类里创建一个static修饰的函数，则可以直接通过类名访问，该类new出来的对象，也可以共享static函数，或者static修饰的共有属性。

static的具体用法，可参考：http://www.cnblogs.com/dolphin0520/p/3799052.html。