Java基础: 关键字 final

1. 修饰变量

 该变量既可以是局部变量也可以是成员变量，final关键字修饰的成员变量即常量，可以被继承或者覆盖和隐藏！主要从以下两方面来说明问题。

 <1> 修饰基本数据类型

 final修饰的该变量就是常量，一旦赋值不可以改变其值。

一般情况，final修饰成员变量的话与static结合，使该常量可以被类直接调用，而不必创建对象，节省空间。再者，如果该常量中不含不确定因素，就称之为编译时期常量，反之为运行期常量。编译时期常量被调用时不会加载该类。http://blog.youkuaiyun.com/AndroidBluetooth/archive/2011/05/30/6454135.aspx

 

注意：测试方法（main方法）写在该类中会加载该类的，所以测试方法放在单独一个类中。例子：

package mark.zhang; public class Linux { // 修饰成员变量 public static final String NAME = "LINUX"; static { System.out.println("--Linux---静态代码块"); } { System.out.println("--Linux---动态代码块"); } public Linux() { } public void getName() { // 修饰局部变量 final int i = 7; } } class Test { public static void main(String[] args) { System.out.println(Linux.NAME); } } 

结果：

LINUX 

还有这样一种情况，不想在声明常量的时候，给其赋值，那么怎么办？

我们知道，如果在声明常量的同时不将其赋值，编译器会给我们一个类似The blank final field NAME may not have been initialized的错误。

第一种办法，在静态代码块中给常量赋值。

package mark.zhang; public class Linux { // 修饰成员变量 public static final String NAME; static { System.out.println("--Linux---静态代码块"); NAME = "LINUX"; } { System.out.println("--Linux---动态代码块"); } public Linux() { } } class Test { public static void main(String[] args) { System.out.println(Linux.NAME); } } 

结果：

--Linux---静态代码块 LINUX 

分析：由于NAME是含有不确定因素，所以会加载静态代码块，从而将其初始化。

注意：动态代码块无法完成final变量的初始化

第二种方法，在构造方法中初始化

如果这样做，那么成员常量不可以被static修饰。

static无法修饰构造方法，因为构造方法是在创建对象时被调用的，而static修饰的，只会在加载该类时被加载一次。

package mark.zhang; public class Linux { // 修饰成员变量，这里没有static public final String NAME; static { System.out.println("--Linux---静态代码块"); } { System.out.println("--Linux---动态代码块"); } public Linux() { NAME = "LINUX"; } } class Test { public static void main(String[] args) { System.out.println(new Linux().NAME); } } 

结果：

--Linux---静态代码块 --Linux---动态代码块 LINUX 

那么，有人说了，现在只有一个构造方法，如果再加一个或者n个构造方法呢，难道还要初始化吗？？？yes，恭喜你，答对了。必须的，否则你得到类似这样一个错误：

The blank final field NAME may not have been initialized 

例子：

public Linux() { NAME = "LINUX"; } public Linux(String name) { NAME = "LINUX--LINUX"; } 

所以，正常情况下，不会使用这种方式。

<2> 修饰引用类型数据

注意：数组也是引用类型。

final修饰的引用不变指的是它的栈内存地址不变，即永远指向那个堆里的对象，但是堆里的对象(属性)是可变的！

示例：

package mark.zhang; public class Linux { private String name = "linux OS"; static { System.out.println("--Linux---静态代码块"); } { System.out.println("--Linux---动态代码块"); } public Linux() { } public void setName(String name) { this.name = name; } public String getName() { return name; } } 

测试方法：

class Test { public static void main(String[] args) { final Linux linux = new Linux(); System.out.println("linux's name : " + linux.getName()); // error: The final local variable linux cannot be assigned. It must be // blank and not using a compound assignment // linux = new Linux(); } } 

但是我们可以修改其属性值。

class Test { public static void main(String[] args) { final Linux linux = new Linux(); System.out.println("before--" + "linux's name : " + linux.getName()); linux.setName("ubuntu10.10"); System.out.println("after--" + "linux's name : " + linux.getName()); } } 

结果：

--Linux---静态代码块 --Linux---动态代码块 before--linux's name : linux OS after--linux's name : ubuntu10.10 

2. 修饰类

final关键字修饰的类，类中成员方法默认为final，无法被继承！Java提供的包中，String类就是一个用关键字final修饰的类，所以其他类无法继承他！但是final关键字修饰的类可以作为子类，即可以继承其他类！

3. 修饰方法

final关键字修饰的方法，可以被继承，但是不能被覆盖！这样可以保证代码的安全性。

注意：final和static一样不可以修饰构造方法。

package mark.zhang; public class Linux { static { System.out.println("--Linux---静态代码块"); } { System.out.println("--Linux---动态代码块"); } public Linux() { } /** * final修饰的方法可以被子类继承，但是不可以被子类重写 子类中也不可以与同名的该方法 */ public final void getInfo() { System.out.println("linux2.38"); } } class Ubuntu extends Linux { // 一下两种方式均会包类似下面的错误 // Cannot override the final method from Linux /* * public final void getInfo() { System.out.println("ubuntu10.10"); } */ /* * public void getInfo() { System.out.println("ubuntu10.10"); } */ } class Test { public static void main(String[] args) { Ubuntu ubuntu = new Ubuntu(); // 可以继承父类的final方法 ubuntu.getInfo(); } }  

4. final与abstract

final修饰的类不可以被继承，然而abstract修饰的类本意就是希望子类去继承。所以，在Java中不允许final修饰abstract，无论是abstract方法还是abstract类。

如果你这样子去修饰一个抽象类的话：

final abstract class Ubuntu { abstract void get(); } 

编译器毫不客气的给你一个错误信息：

The class Ubuntu can be either abstract or final, not both 

同样的道理，final也不可以修饰abstract方法，如：

abstract class Ubuntu { final public abstract void get(); } 

错误：

The abstract method get in type Ubuntu can only set a visibility modifier, one of public or protected 

从这句话中我们也可以得出结论：抽象方法不可以是private的，可以是default或者public或者protected。因为private方法子类不可见，更无法继承或者重写。

 

5. final与接口

final不能修饰interface接口 

6. final与构造方法

 

final不可以修饰构造方法