[Java]"final"关键字的用法和知识点总结(下半部分)

 

• final参数

Java允许你在参数列表以声明的方式将参数指明为final. 这意味着你无法在方法中更改参数引用所指向的对象.  

 看例子:

1. //: FinalArguments.java
2. 
   
3. class Gizmo {
4.     public void spin() {}
5. }
6. 
   
7. public class FinalArguments {
8.     void with (final Gizmo g) {
9.         //! g = new Gizmo();  //错误:g不能被更改
10.     }
11.     
12.     void without(Gizmo g) {
13.         g = new Gizmo();     //没问题
14.         g.spin();
15.     }
16.     
17.     //void f(final int i) {i++;} //错误:i不能更改
18.     //final是只读的
19.     int g(final int i) {return i + 1;}
20.     
21.     public static void main(String[] args) {
22.         FinalArguments bf = new FinalArguments();
23.         bf.without(null);
24.         bf.with(null);
25.     }
26. }

   方法f()和g()展示了当原始类型的参数被指明为final时所出现的结果:你可以读参数,却无法修改参数. 这一特性看起来仅有微不足道的用处,而且你可能还用不到!呵呵!

来看下一种使用final的情况:

• final方法

    使用final方法的原因有二:

    1. 将方法锁定,以防任何继承类修改它的意义,这是出于设计的考虑: 你想要确保在继承中方法行为保持不变,并且不会被重载.

        2. 效率. 如果你将一个方法指明为final,就是同意编译器将对该方法的所有调用都转为内嵌(inline)调用. 当编译器发现一个final方法调用命令时,它会根据自己的谨慎判断,跳过插入程序代码的正常方法而执行方法调用机制(将参数压入栈,跳至方法代码处并执行,然后跳回并清除栈中的参数,并处理返回值.), 并且以方法体中的实际代码的副本来代替方法调用.这将消除方法调用的开销. 当然,如果一个方法很大,你的程序代码就会膨胀,你可能看不到内嵌带来的任何性能提高,因此,你所取得的性能提高会因为花费于方法内的时间总量而被缩减. 这意味着Java编译器能够观察到这些情况并明智地抉择是否对final方法执行内嵌动作. 然而,最好是让编译器和JVM仅在你明确表示要阻止重载时,在处理效率事项,并将方法指明为final.


   final和private

        类中所有的private方法都被隐含是final的. 由于你无法取用private方法,所以你无法重载之.你可以对private方法增加final修饰符,但这并不能给该方法增加任何额外的意义

        这个问题会造成混淆. 因为如果你试图重载一个private方法(隐含是final的),看起来是奏效的,而且编译器不会给出错误信息.

        比如:

1. //: FinalOverridingIllusion.java
2. 
   
3. class WithFinals {
4.     private final void f() {
5.         System.out.println("WithFinals.f()");
6.     }
7.     private void g() {
8.         System.out.println("WithFinals.g()");
9.     }
10. }
11. 
    
12. class OverridingPrivate extends WithFinals {
13.     private final void f() {
14.         System.out.println("OverridingPrivate.f()");
15.     }
16.     private void g() {
17.         System.out.println("OverridingPrivate.g()");
18.     }
19. }
20. 
    
21. class OverridingPrivate2 extends OverridingPrivate {
22.     public final void f() {
23.         System.out.println("OverridingPrivate2.f()");
24.     }
25.     public void g() {
26.         System.out.println("OverridingPrivate2.g()");
27.     }
28. }
29. 
    
30. public class FinalOverridingIllusion {
31.     public static void main(String[] args) {
32.         OverridingPrivate2 op2 = new OverridingPrivate2();
33.         op2.f();
34.         op2.g();
35.         //向上转型一下
36.         OverridingPrivate op = op2;  //基类引用指向了导出类对
37.                                             //象,实现向上转型
38.         //但是你不能调用op的方法
39.         //! op.f();
40.         //! op.g();
41.         WithFinals wf = op2;    //向上转型至WithFinals类型,那
42.                                //么对象wf就只看到了op2的WithFinals部分
43.         //! wf.f();
44.         //! wf.g();
45.     }
46. }

    "重载"只有在某方法是基类的接口的一部分时才会出现.即,你必须能将一个对象向上转型为它的基本类型并调用相同的方法.如果某方法为private,他就不是基类的接口的一部分. 它仅是一些隐藏于类中的程序代码,不过具有相同的名称而已.但你 如果在导出类以相同的名称生成一个public,protected或包访问权限方法的话,该方法就不会产生在基类中出现的"仅具有相同名称"的情况. 此时你并没有重载,你仅是生成了一个新的方法.由于private方法无法触及又不能有效隐藏,所以仅仅是因为考虑到定义它的类的程序代码组织,它们才有存在的意义,除此之外,其他任何事物都不需要将它纳入考虑的范畴.
<script type="text/javascript"> </script> <script type="text/javascript" src="http://pagead2.googlesyndication.com/pagead/show_ads.js"> </script>

• final 类

   当你将某各类的整体定义为final时(通过将关键字至于它的定义之前),你就声明了你打算继承该类,而且不允许别人这么做. 换句话说,出于某种考虑,你对该类的设计用不需要做任何变动,或者出于安全的考虑,你不希望它有子类.

      例子:

1. //! Jurassic.java
2. 
   
3. class SmallBrain {}
4. 
   
5. final class Dinosaur {
6.     int i = 7;
7.     int j = 1;
8.     SmallBrain x = new SmallBrain();
9.     void f() {}
10. }
11. 
    
12. //!class Further extends Dinosaur {}
13. //错误:Dinosaur是final的,所以不能继承,但是其类成员可以改变
14. 
    
15. public class Jurassic {
16.     public static void main(String[] args) {
17.         Dinosaur n = new Dinosaur();
18.         n.f();
19.         n.i = 40;
20.         n.j++;
21.     }
22. }

  请注意,根据你的选择,final类的数据成员可以是final,同样可以不是. 不论类是否被定义为final,相同的规则都适用于final的数据成员. 然而,由于final类禁止继承,所以final类中所有的方法都被隐含是final的,因为他们是不会被重载的. 在final类中你可以给方法添加final修饰符,但不会添加任何意义.

--------------------未完待续---------------------