JAVA中的“final”关键字

最新推荐文章于 2024-03-31 12:33:01 发布

ECH00O00

最新推荐文章于 2024-03-31 12:33:01 发布

阅读量249

点赞数

分类专栏： JAVA 文章标签： java final

本文链接：https://blog.csdn.net/ECH00O00/article/details/75218181

版权

JAVA 专栏收录该内容

34 篇文章 0 订阅

订阅专栏

在JAVA中，“final”的含义在不同的上下文环境中存在着细微的差别，但总体上指的是“这是无法改变的”。可能使用到“final”的三种情况为：数据、方法和类。

一、final数据：

1.一个永不改变的编译时常量。

2.一个在运行时被初始化的值，而我们不希望改变它。

对于编译期常量的情况来说，编译器可以将该常量值代入任何可能用到它的计算式中，也就是说，可以在编译时执行计算式，这样做减轻了一些运行时的负担。在JAVA中，这类常量必须是基本数据类型，并以关键字“final”表示，在堆这个常量进行定义的时候，必须对其进行赋值。一个既是static又是final的域只占据一段不能改变的存储空间。

当对对象引用运用final时，含义会发生一些变化。首先对于基本数据类型来说，final使数值恒定不变；而对于对象引用来说，final使引用恒定不变。一旦引用被初始化指向一个对象，就无法再将它改为指向另一个对象。然而对象其本身却是可以被修改的，JAVA并未提供使任何对象恒定不变的途径，这一限制同样适用于数组，它也是对象。下面给出一段代码：

package access;
import java.util.*;
class Value{
	int i;
	public Value(int i){
		this.i = i;
	}
}
public class FinalData {
	private static Random rand = new Random(47);
	private String id;
	public FinalData(String id){
		this.id = id;
	}
	private final int valueOner = 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);
	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};
	public String toString(){
		return id + ": " + "i4 = " + i4 + ", INT_5 = " + INT_5; 
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		FinalData fd1 = new FinalData("fd1");
		//! fd1.valueOner++;  //Error: can't change value
		fd1.v2.i++;
		fd1.v1 = new Value(9);
		for(int i = 0;i < fd1.a.length;i++)
			fd1.a[i]++;
		//! fd1.v2 = new Value(0);   //Error: can't
		//! fd1.VAL_3 =new Value(1); //change reference
		//! fd1.a = new int[3];
		System.out.println(fd1);
		System.out.println("Creating new FinalData");
		FinalData fd2 = new FinalData("fd2");
		System.out.println(fd1);
		System.out.println(fd2);
	}

}

此程序运行结果为：

由于valuOne和VAL_TWO都是带有编译时数值的final基本类型，所以二者均可用作编译期常量，并没有什么区别。VAL_THREE是一种更加典型的对常量进行定义的方式，定义为了public，可以被用于包外；定义为static，则强调只有一份；定义为final，说明它是一个常量。值得注意的是常量的命名方式，带有恒定初始值的final static 基本类型全用大写字母命名，并且字与字直接用下划线隔开。

另外我们不能因某个数据是final就认为在编译时可以准确知道它的值，如上述例子中的使用随机生成的数值来初始化i4和INT_5就说明了这一点。

将final数值定义为静态和非静态的区别只有在当数值运行时内被初始化才会显示，在fd1和fd2中，i4的值是唯一的，但INT_5的值是不可以通过创建第二个FinalData对象而加以改变的，因为其是static的，在装载时已经被初始化，而不是每次创建新对象时都初始化。

v1到VAL_3这些变量说明了final引用的意义，不能因为v2是final的就无法改变它的值，由于它是一个引用，final意味着无法将v2再次指向另一个新的对象，数组同样如此。

二、空白final：

JAVA允许生成“空白final”，指的是被声明为final但又未给定初值的域，但这并不意味着不需要初始化，我们必须自己编译构建器来使空白final初始化，空白final在关键字final的使用上提供了较大的灵活性，一个类中的final域可以做到根据对象而有所不同却又保持其恒定不变的特性，看下面一段代码：

package access;
class Poppet{
	private int i;
	Poppet(int ii){
		i = ii;
	}
}
public class BlankFinal {
	private final int i = 0;
	private final int j;
	private final Poppet p;
	public BlankFinal(){
		j = 1;
		p = new Poppet(1);
	}
	public BlankFinal(int x){
		j = x;
		p = new Poppet(x);
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		new BlankFinal();
		new BlankFinal(47);
	}

}

可以看到，必须在域的定义处或者每个构建器中用表达式对final进行赋值。
三、final参数：

JAVA允许在参数列表中以声明的方式将参数指明为final，这样做意味着我们无法在方法中更改参数引用所指向的对象，看以下代码段：

package access;
class Gizmo{
	public void spin(){
		
	}
}
public class FinalArguments {
	void with(final Gizmo g){
		//! g = new Gizmo();  //不能对其进行new操作
	}
	void without(Gizmo g){
		g = new Gizmo();
		g.spin();
	}
	//! void f(final int i){ i++; } //不能改变i的值
	int g(final int i){
		return i +1;
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		FinalArguments bf = new FinalArguments();
		bf.without(null);
		bf.with(null);
	}

}

四、final方法：

使用final方法的原因有两个。其一是将方法锁定，以防止任何继承类修改它的含义，确保在继承中方法行为保持不变并且不会被覆盖。其二是效率，如果将方法声明为final，那么也就是说同意了编译器可以针对该方法的所有调用都转换为内嵌调用，当编译器发现一个final方法调用命令时，它会自行判断，跳过插入程序代码这种正常方式而执行方法调用机制将参数压入栈，跳至方法代码处并执行，然后跳回并清理栈中参数，处理返回值，并且以方法体重的实际代码的副本来代替方法调用。这样做可以消除方法调用的开销，但是如果一个方法很大，我们的程序代码就会膨胀，因而可能看不到内嵌带来的任何性能的提高，因为所带来的性能提高会因花费于方法内的时间量而被缩减。在最近的JAVA版本中，虚拟机可以探测到这些情况并优化去掉这些效率反而降低的额外内嵌调用，因此不再需要使用final方法进行优化了，只有在想要明确禁止覆盖是，才将方法设置为final。

五、final和private关键字：

类中所有的private方法都隐式的指定为是final的，由于无法取用private方法，所以也就无法覆盖它，可以对private方法添加final修饰词，但这毫无意义，并且还可能造成混淆。看下面一段代码：

package access;
class WithFinals{
	private final void f(){
		System.out.println("WithFinals.f()");
	}
	private void g(){
		System.out.println("WithFinals.g()");
	}
}
class OverridingPrivate extends WithFinals{
	private final void f(){
		System.out.println("OverridingPrivate.f()");
	}
	private void g(){
		System.out.println("OverridingPrivate.g()");
	}
}
class OverridingPrivate2 extends OverridingPrivate{
	public final void f(){
		System.out.println("OverridingPrivate2.f()");
	}
	public void g(){
		System.out.println("OverridingPrivate2.g()");
	}
}
public class FinalOverridingIllusion {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		OverridingPrivate2 op2 = new OverridingPrivate2();
		op2.f();
		op2.g();
		OverridingPrivate op = op2;
		//!op.f();
		//!op.g();
		WithFinals wf = op2;
		//!wf.f();
		//!wf.g();
	}

}

“覆盖”只有在某方法是基类的接口的一部分是才会出现，也就是说必须能将一个对象向上转型为它的基本类型并调用相同的方法，如果某方法为private，它就不是基类的接口的一部分，它仅是一些隐藏于类中的程序代码，只不过具有相同的名称而已，但如果在导出类中以相同的名称生成一个public、protected或包权限方法的话，该方法就不会产生在基类中的出现的“仅具有相同名称”的情况，此时我们并没有覆盖该方法，仅是生成了一个新的方法，由于private方法无法触及而且能有限隐藏，所以除了把它看成是因为它所归属得嘞的组织结构的原因而存在外，其他任何事物都不需要考虑到它。

六、final类：

当将某个类的整体定义为final时，就表明了我们不打算继承该类，而且也不允许别这样做，也就是说我们对该类的设计永不需要做任何变动，或者出于安全的考虑，我们不希望它有子类。final类的域可以根据个人的意愿选择为是或不是final，不论类是否被定义为final，相同的规则都适用于定义为final的域，然而由于final类禁止继承，所以final类中的所有方法都会隐式指定为是final的，因为无法覆盖它们。在final类中可以给方法添加final修饰词，但这不会增添任何意义。

有关final，在设计类时，将方法指明为final的，应该说是明智的，我们通常认为没有人会想要覆盖我们的方法，有时这是对的，但有时预见类如何被复用是很困难的一件事情，特别是对于通用类来说更是如此。所以在设计的过程中，需要我们多加考量，在适当的情况下使用好final。