一.final关键字的基本用法
在Java中,final关键字可以用来修饰类、方法和变量(包括成员变量和局部变量)。下面就从这三个方面来了解一下final关键字的基本用法。
1.修饰类
当用final修饰一个类时,表明这个类不能被继承。也就是说,如果一个类你永远不会让他被继承,就可以用final进行修饰。final类中的成员变量可以根据需要设为final,但是要注意final类中的所有成员方法都会被隐式地指定为final方法。
在使用final修饰类的时候,要注意谨慎选择,除非这个类真的在以后不会用来继承或者出于安全的考虑,尽量不要将类设计为final类。
2.修饰方法
下面这段话摘自《Java编程思想》第四版第143页:
“使用final方法的原因有两个。第一个原因是把方法锁定,以防任何继承类修改它的含义;第二个原因是效率。在早期的Java实现版本中,会将final方法转为内嵌调用。但是如果方法过于庞大,可能看不到内嵌调用带来的任何性能提升。在最近的Java版本中,不需要使用final方法进行这些优化了。“
因此,如果只有在想明确禁止该方法在子类中被覆盖的情况下才将方法设置为final的。
注:类的private方法会隐式地被指定为final方法。
3.修饰变量
修饰变量是final用得最多的地方,也是本文接下来要重点阐述的内容。首先了解一下final变量的基本语法:
对于一个final变量,如果是基本数据类型的变量,则其数值一旦在初始化之后便不能更改;如果是引用类型的变量,则在对其初始化之后便不能再让其指向另一个对象。
举个例子:
上面的一段代码中,对变量i和obj的重新赋值都报错了。
二.深入理解final关键字
在了解了final关键字的基本用法之后,这一节我们来看一下final关键字容易混淆的地方。
1.类的final变量和普通变量有什么区别?
当用final作用于类的成员变量时,成员变量(注意是类的成员变量,局部变量只需要保证在使用之前被初始化赋值即可)必须在定义时或者构造器中进行初始化赋值,而且final变量一旦被初始化赋值之后,就不能再被赋值了。
那么final变量和普通变量到底有何区别呢?下面请看一个例子:
1 2 3 4 5 6 7 8 9 10 11 | public class Test { public static void main(String[] args) { String a = "hello2"; final String b = "hello"; String d = "hello"; String c = b + 2; String e = d + 2; System.out.println((a == c)); System.out.println((a == e)); } } |
true
false
大家可以先想一下这道题的输出结果。为什么第一个比较结果为true,而第二个比较结果为fasle。这里面就是final变量和普通变量的区别了,当final变量是基本数据类型以及String类型时,如果在编译期间能知道它的确切值,则编译器会把它当做编译期常量使用。也就是说在用到该final变量的地方,相当于直接访问的这个常量,不需要在运行时确定。这种和C语言中的宏替换有点像。因此在上面的一段代码中,由于变量b被final修饰,因此会被当做编译器常量,所以在使用到b的地方会直接将变量b 替换为它的 值。而对于变量d的访问却需要在运行时通过链接来进行。想必其中的区别大家应该明白了,不过要注意,只有在编译期间能确切知道final变量值的情况下,编译器才会进行这样的优化,比如下面的这段代码就不会进行优化:
1 2 3 4 5 6 7 8 9 10 11 12 13 | public class Test { public static void main(String[] args) { String a = "hello2"; final String b = getHello(); String c = b + 2; System.out.println((a == c));
}
public static String getHello() { return "hello"; } } |
这段代码的输出结果为false。
2.被final修饰的引用变量指向的对象内容可变吗?
在上面提到被final修饰的引用变量一旦初始化赋值之后就不能再指向其他的对象,那么该引用变量指向的对象的内容可变吗?看下面这个例子:
1 2 3 4 5 6 7 8 9 10 11 | public class Test { public static void main(String[] args) { final MyClass myClass = new MyClass(); System.out.println(++myClass.i);
} }
class MyClass { public int i = 0; } |
这段代码可以顺利编译通过并且有输出结果,输出结果为1。这说明引用变量被final修饰之后,虽然不能再指向其他对象,但是它指向的对象的内容是可变的。
3.final和static
很多时候会容易把static和final关键字混淆,static作用于成员变量用来表示只保存一份副本,而final的作用是用来保证变量不可变。看下面这个例子:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | public class Test { public static void main(String[] args) { MyClass myClass1 = new MyClass(); MyClass myClass2 = new MyClass(); System.out.println(myClass1.i); System.out.println(myClass1.j); System.out.println(myClass2.i); System.out.println(myClass2.j);
} }
class MyClass { public final double i = Math.random(); public static double j = Math.random(); } |
运行这段代码就会发现,每次打印的两个j值都是一样的,而i的值却是不同的。从这里就可以知道final和static变量的区别了。
5.关于final参数的问题
关于网上流传的”当你在方法中不需要改变作为参数的对象变量时,明确使用final进行声明,会防止你无意的修改而影响到调用方法外的变量“这句话,我个人理解这样说是不恰当的。
因为无论参数是基本数据类型的变量还是引用类型的变量,使用final声明都不会达到上面所说的效果。
看这个例子就清楚了:
上面这段代码好像让人觉得用final修饰之后,就不能在方法中更改变量i的值了。殊不知,方法changeValue和main方法中的变量i根本就不是一个变量,因为java参数传递采用的是值传递,对于基本类型的变量,相当于直接将变量进行了拷贝。所以即使没有final修饰的情况下,在方法内部改变了变量i的值也不会影响方法外的i。
再看下面这段代码:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | public class Test { public static void main(String[] args) { MyClass myClass = new MyClass(); StringBuffer buffer = new StringBuffer("hello"); myClass.changeValue(buffer); System.out.println(buffer.toString()); } }
class MyClass {
void changeValue(final StringBuffer buffer) { buffer.append("world"); } } |
运行这段代码就会发现输出结果为helloworld。很显然,用final进行修饰并没有阻止在changeValue中改变buffer指向的对象的内容。有人说假如把final去掉了,万一在changeValue中让buffer指向了其他对象怎么办。有这种想法的朋友可以自己动手写代码试一下这样的结果是什么,如果把final去掉了,然后在changeValue中让buffer指向了其他对象,也不会影响到main方法中的buffer,原因在于java采用的是值传递,对于引用变量,传递的是引用的值,也就是说让实参和形参同时指向了同一个对象,因此让形参重新指向另一个对象对实参并没有任何影响。
所以关于网上流传的final参数的说法,我个人不是很赞同。
Java和AS3.0关键字final有“这是无法改变的”或者“终态的”含义,它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变:设计或效率。
可以修饰的对象: final 类 final方法 final变量
1、final类
final类不能被继承,因此final类的成员方法没有机会被覆盖,默认都是final的。在设计类时候,如果这个类不需要有子类,类的实现细节不允许改变,并且确信这个类不会再被扩展,那么就设计为final类。
2、final方法
如果一个类不允许其子类覆盖某个方法,则可以把这个方法声明为final方法。
final不能用于修饰构造方法。
使用final方法的原因有二: 第一、把方法锁定,防止任何继承类修改它的意义和实现。
第二、高效。编译器在遇到调用final方法时候会转入内嵌机制,大大提高执行效率。
3、final变量(常量)
用final修饰的成员变量表示常量,值一旦给定就无法改变!能被赋值一次,赋值后值不再改变。 final修饰的变量有三种:静态变量、实例变量和局部变量,分别表示三种类型的常量。 从下面的例子中可以看出,一旦给final变量初值后,值就不能再改变了。
另外,final变量定义的时候,可以先声明,而不给初值,这种变量也称为final空白,无论什么情况,编译器都确保空白final在使用之前必须被初始化。但是,final空白在final关键字的使用上提供了更大的灵活性,为此,一个类中的final数据成员就可以实现依对象而有所不同,却有保持其恒定不变的特征。
4、final参数
当函数参数为final类型时,你可以读取使用该参数,但是无法改变该参数的值。 示例: public voidf1(f
inal int i){ } //i是final类型的,值不允许改变的
介绍一下使用到fianl的三中情况:数据,方法,类。
final数据
许多编程语言都有某种方法,来向编译器告知一块数据是恒定不变的。有时数据的恒定不变是很有用的,例如:
1,一个编译时恒定不变的常量
2,一个在运行时初始化,而你不希望它被改变。
对于编译期常量的这种情况,编译器可以将该常量值代入任何可能用到它的计算式中,也就是说,可以在编译期就执行计算式,这减轻了一些运行时的负担。在java中,这类常量必须是基本类型,并且以final表示。在对这个常量定义时,必须进行赋值。
一个即是static又是fianl的域只占一段不能改变的存储空间。
当final应用于对象引用时,而不是基本类型时,其含义有些让人疑惑。对基本类型使用fianl不能改变的是他的数值。而对于对象引用,不能改变的是他的引用,而对象本身是可以修改的。一旦一个final引用被初始化指向一个对象,这个引用将不能在指向其他对象。java并未提供对任何对象恒定不变的支持。这一限制也通用适用于数组,它也是对象。
下面的事例示范fianl域的情况。注意,根据惯例,即是static又是fianl的域(即编译器常量)将用大写表示,并用下划分割个单词:
- package reusing;
- //: reusing/FinalData.java
- // The effect of final on fields.
- import java.util.*;
- import static net.mindview.util.Print.*;
- class Value {
- int i; // Package access
- 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; }
- // Can be compile-time constants:
- private final int valueOne = 9;
- private static final int VALUE_TWO = 99;
- // Typical public constant:
- public static final int VALUE_THREE = 39;
- // Cannot be compile-time constants:
- 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);
- // Arrays:
- 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) {
- FinalData fd1 = new FinalData("fd1");
- //! fd1.valueOne++; // Error: can't change value
- fd1.v2.i++; // Object isn't constant!
- fd1.v1 = new Value(9); // OK -- not final
- for(int i = 0; i < fd1.a.length; i++)
- fd1.a[i]++; // Object isn't constant!
- //! fd1.v2 = new Value(0); // Error: Can't
- //! fd1.VAL_3 = new Value(1); // change reference
- //! fd1.a = new int[3];
- print(fd1);
- print("Creating new FinalData");
- FinalData fd2 = new FinalData("fd2");
- print(fd1);
- print(fd2);
- }
- }
- /* Output:
- fd1: i4 = 15, INT_5 = 18
- Creating new FinalData
- fd1: i4 = 15, INT_5 = 18
- fd2: i4 = 13, INT_5 = 18
- */
由于valueOne和VALUE_TWO都是带有编译时数值的fianl基本类型,所以它们二者均可以用作编译期常量,并且没有重大区别。VALUE_THREE是一种更加典型的对常量进行定义的方式:定义为public,可以被任何人访问;定义为static,则强调只有一份;定义为fianl,这说明它是个常量。请注意带有恒定初始值(即,编译期常量)的final static基本类型全用大写字母命名,并且字母与字母之间用下划线隔开。
我们不能因为某些数据是fianl的就认为在编译时可以知道它的值。在运行时使用随机数来初始化i4和INT_5的值叫说明了这一点。事例部分也展示了将fianl数据定义为static和非static的区别。此区别只有当数值在运行时内被初始化时才会显现,这是因为在编译器对编译时的数值一视同仁(并且他们可能因为优化而消失)。当运行时会看见这个区别。请注意,在此fd1和fd2中i4的值是唯一的,每次都会被初始化为15,13。INT_5的值是不可以通过创建第二个FinalData对象加以改变的。这是因为他是static的,在装载类时(也就是第一次创建这个类对象时)已经被初始化,而不是每次创建都初始化。
如果看上面的事例来理解我标记颜色的的部分有点困难的话,请看下面的事例:
- public class B3 {
- static Random r =new Random(12);
- final int int1= r.nextInt(100);//产生0-99的随机数
- static final int INT_2= r.nextInt(100);
- public static void main(String[] args) {
- B3 b1=new B3();
- System.out.println("int1:"+b1.int1+" INT_2:"+b1.INT_2);
- B3 b2=new B3();
- //b2.INT_2=100;//错误的赋值
- System.out.println("int1:"+b2.int1+" INT_2:"+b2.INT_2);
- }
- }
启动main()先执行的是B3 b1=new B3();,创建B3的第一个对象,这将会先初始化static final int INT_2= r.nextInt(100);,然后是初始化finalint int1= r.nextInt(100);,所以第一条输出语句的结果是int1:12 INT_2:66。接下来创建B3的第二个对象,这也会导致B3类中成员的初始化,但staticfinal int INT_2= r.nextInt(100);不会在被初始化,为什么前面已经提过。输出的结果是int1:56 INT_2:66。两次的输出INT_2的值都是一样的。
在说回我们的第一个事例,V1到VAL_3说明final引用的意义。正如在main()方法中看见的,可以改变对象数组a的值,但不能将a的引用指向另一个对象。看起来使基本类型成为fianl比引用类型成为final的用处大。
java也许生成"空白final",所谓空白final是指被声明为final但又未给初值的域。无论什么情况下编译器都会保证final域在使用前初始化。但空白final在fianl的使用上提供了很大的灵活性,为此,一个fianl域可以根据某些对象有所不同,却又保持恒定不变的特性。下面的事例说明了一点。
- class Poppet {
- private int i;
- Poppet(int ii) { i = ii; }
- }
- public class BlankFinal {
- private final int i = 0; // Initialized final
- private final int j; // Blank final
- private final Poppet p; // Blank final reference
- // Blank finals MUST be initialized in the constructor:
- public BlankFinal() {
- j = 1; // Initialize blank final
- p = new Poppet(1); // Initialize blank final reference
- }
- public BlankFinal(int x) {
- j = x; // Initialize blank final
- p = new Poppet(x); // Initialize blank final reference
- }
- public static void main(String[] args) {
- new BlankFinal();
- new BlankFinal(47);
- }
- } //
final 参数
java中也许将参数列表中的参数以声明的方式声指明为final。这意味着你无发改变参数所指向的对象。
- class Gizmo {
- public void spin() {}
- }
- public class FinalArguments {
- void with(final Gizmo g) {
- //! g = new Gizmo(); // Illegal -- g is final
- }
- void without(Gizmo g) {
- g = new Gizmo(); // OK -- g not final
- g.spin();
- }
- // void f(final int i) { i++; } // Can't change
- // You can only read from a final primitive:
- int g(final int i) { return i + 1; }
- public static void main(String[] args) {
- FinalArguments bf = new FinalArguments();
- bf.without(null);
- bf.with(null);
- }
- } //
方法f()g()展示了基本类型的参数被指定为final是所出现的结果:你可以读参数,但不能修改参数。这一特性只要用来向匿名内部类传递数据。
final 方法
使用final方法有两个原因。第一个原因是把方法锁定,以防止任何继承它的类修改它的含义。这是出于设计的考虑:想要确保在继承中使用的方法保持不变,并且不会被覆盖。
过去建议使用final方法的第二个原因是效率。在java的早期实现中,如果将一个方法指明为fianl,就是同意编译器将针对该方法的所有调用都转为内嵌调用。当编译器发现一个final方法调用命令时,它会根据自己的谨慎判断,跳过插入程序代码这种正常的调用方式而执行方法调用机制(将参数压入栈,跳至方法代码处执行,然后跳回并清理栈中的参数,处理返回值),并且以方法体中的实际代码的副本来代替方法调用。这将消除方法调用的开销。当然,如果一个方法很大,你的程序代码会膨胀,因而可能看不到内嵌所带来的性能上的提高,因为所带来的性能会花费于方法内的时间量而被缩减。
上面标颜色的地方不太懂。不知道那位看过Java编程思想和知道的高人给解释解释。
在最进的java版本中,虚拟机(特别是hotspot技术)可以探测到这些情况,并优化去掉这些效率反而降低的额外的内嵌调用,因此不再需要使用final方法来进行优化了。事实上,这种做法正逐渐受到劝阻。在使用java se5/6时,应该让编译器和JVM去处理效率问题,只有在想明确禁止覆盖式,才将方法设置为fianl的。
final和private关键字
类中的所有private方法都是隐式的制定为final的。由于你无法访问private方法你也就无法覆盖它。可以对private方法添加final修饰词,但这毫无意义。
- class WithFinals {
- // Identical to "private" alone:
- private final void f() { print("WithFinals.f()"); }
- // Also automatically "final":
- private void g() { print("WithFinals.g()"); }
- }
- class OverridingPrivate extends WithFinals {
- private final void f() {
- print("OverridingPrivate.f()");
- }
- private void g() {
- print("OverridingPrivate.g()");
- }
- }
- class OverridingPrivate2 extends OverridingPrivate {
- public final void f() {
- print("OverridingPrivate2.f()");
- }
- public void g() {
- print("OverridingPrivate2.g()");
- }
- }
"覆盖"只有在某方法是基类接口的一部分时才会发生。即,必须将一个对象向上转型为它的基类并条用相同的方法。如果某方法是private的,它就不是基类接口的一部分。它仅是一些隐藏于类中的程序代码,如果一个基类中存在某个private方法,在派生类中以相同的名称创建一个public,protected或包访问权限方法的话,该方法只不过是与基类中的方法有相同的名称而已,并没有覆盖基类方法。由于private方法无法触及且有很好的隐藏性,所以把它看成是因为他所属类的组织结的原因而存在外,其他任何事物都不用考虑。
final 类
当将类定义为final时,就表明了你不打算继承该类,而且也不也许别人这样做。换句话说,出于某种考虑,你对该类的设计永不需要做任何变动,或者出于安全的考虑,你不希望他有子类。
- class SmallBrain {}
- final class Dinosaur {
- int i = 7;
- int j = 1;
- SmallBrain x = new SmallBrain();
- void f() {}
- }
- //! class Further extends Dinosaur {}
- // error: Cannot extend final class 'Dinosaur'
- public class Jurassic {
- public static void main(String[] args) {
- Dinosaur n = new Dinosaur();
- n.f();
- n.i = 40;
- n.j++;
- }
- }
请注意,final类的域可以根据个人的意愿选择是或不是final。不论类是否被定义为final,相同的规则同样适用于定义为final的域。然而,由于final是无法继承的,所以被final修饰的类中的方法都隐式的制定为fianl,因为你无法覆盖他们。在fianl类中可以给方法添加final,但这不会产生任何意义。