java final keyword

   依据上下文环境，java的keywordfinal也存在着细微的差别，但通常指的是“这是无法改变的。”不想改变的理由由两种：一种是效率，还有一种是设计。因为两个原因相差非常远，所以关键子final可能被吴用。

   接下来介绍一下使用到fianl的三中情况：数据，方法，类。

   final数据

   很多编程语言都有某种方法，来向编译器告知一块数据是恒定不变的。有时数据的恒定不变是非常实用的，比如：

1，一个编译时恒定不变的常量

2，一个在执行时初始化，而你不希望它被改变。

   对于编译期常量的这样的情况，编译器能够将该常量值代入不论什么可能用到它的计算式中，也就是说，能够在编译期就执行计算式，这减轻了一些执行时的负担。在java中，这类常量必须是基本类型，而且以final表示。在对这个常量定义时，必须进行赋值。

   一个即是static又是fianl的域仅仅占一段不能改变的存储空间。

   当final应用于对象引用时，而不是基本类型时，其含义有些让人疑惑。对基本类型使用fianl不能改变的是他的数值。而对于对象引用，不能改变的是他的引用，而对象本身是能够改动的。一旦一个final引用被初始化指向一个对象，这个引用将不能在指向其它对象。java并未提供对不论什么对象恒定不变的支持。这一限制也通用适用于数组，它也是对象。

   以下的事例示范fianl域的情况。注意，依据惯例，即是static又是fianl的域(即编译器常量)将用大写表示，并用下划切割个单词：

package reusing;</p> <p>//: reusing/FinalData.java<br />// The effect of final on fields.<br />import java.util.*;<br />import static net.mindview.util.Print.*;</p> <p>class Value {<br /> int i; // Package access<br /> public Value(int i) { this.i = i; }<br />}</p> <p>public class FinalData {<br /> private static Random rand = new Random(47);<br /> private String id;<br /> public FinalData(String id) { this.id = id; }<br /> // Can be compile-time constants:<br /> private final int valueOne = 9;<br /> private static final int VALUE_TWO = 99;<br /> // Typical public constant:<br /> public static final int VALUE_THREE = 39;<br /> // Cannot be compile-time constants:<br /> private final int i4 = rand.nextInt(20);<br /> static final int INT_5 = rand.nextInt(20);<br /> private Value v1 = new Value(11);<br /> private final Value v2 = new Value(22);<br /> private static final Value VAL_3 = new Value(33);<br /> // Arrays:<br /> private final int[] a = { 1, 2, 3, 4, 5, 6 };<br /> public String toString() {<br /> return id + “: ” + “i4 = ” + i4 + “, INT_5 = ” + INT_5;<br /> }</p> <p> public static void main(String[] args) {<br /> FinalData fd1 = new FinalData(“fd1”);<br /> //! fd1.valueOne++; // Error: can’t change value<br /> fd1.v2.i++; // Object isn’t constant!<br /> fd1.v1 = new Value(9); // OK — not final<br /> for(int i = 0; i < fd1.a.length; i++)<br /> fd1.a[i]++; // Object isn’t constant!<br /> //! fd1.v2 = new Value(0); // Error: Can’t<br /> //! fd1.VAL_3 = new Value(1); // change reference<br /> //! fd1.a = new int[3];<br /> print(fd1);<br /> print(“Creating new FinalData”);<br /> FinalData fd2 = new FinalData(“fd2”);<br /> print(fd1);<br /> print(fd2);<br /> }<br />} </p> <p>/* Output:<br />fd1: i4 = 15, INT_5 = 18<br />Creating new FinalData<br />fd1: i4 = 15, INT_5 = 18<br />fd2: i4 = 13, INT_5 = 18<br />*/</p> <p>

     因为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 {<br /> static Random r =new Random(12);<br /> final int int1= r.nextInt(100);//产生0-99的随机数<br /> static final int INT_2= r.nextInt(100);</p> <p> public static void main(String[] args) {<br /> B3 b1=new B3();<br /> System.out.println(“int1:”+b1.int1+” INT_2:”+b1.INT_2);<br /> B3 b2=new B3();<br /> //b2.INT_2=100;//错误的赋值<br /> System.out.println(“int1:”+b2.int1+” INT_2:”+b2.INT_2);</p> <p> }</p> <p>}

启动main()先运行的是B3 b1=new B3();，创建B3的第一个对象，这将会先初始化static final int INT_2= r.nextInt(100);，然后是初始化final int int1= r.nextInt(100);，所以第一条输出语句的结果是int1:12    INT_2:66。接下来创建B3的第二个对象，这也会导致B3类中成员的初始化，但static final 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 {<br /> private int i;<br /> Poppet(int ii) { i = ii; }<br />}</p> <p>public class BlankFinal {<br /> private final int i = 0; // Initialized final<br /> private final int j; // Blank final<br /> private final Poppet p; // Blank final reference<br /> // Blank finals MUST be initialized in the constructor:<br /> public BlankFinal() {<br /> j = 1; // Initialize blank final<br /> p = new Poppet(1); // Initialize blank final reference<br /> }<br /> public BlankFinal(int x) {<br /> j = x; // Initialize blank final<br /> p = new Poppet(x); // Initialize blank final reference<br /> }<br /> public static void main(String[] args) {<br /> new BlankFinal();<br /> new BlankFinal(47);<br /> }<br />} //

final 參数

      java中或许将參数列表中的參数以声明的方式声指明为final。这意味着你无发改变參数所指向的对象。

class Gizmo {<br /> public void spin() {}<br />}</p> <p>public class FinalArguments {<br /> void with(final Gizmo g) {<br /> //! g = new Gizmo(); // Illegal — g is final<br /> }<br /> void without(Gizmo g) {<br /> g = new Gizmo(); // OK — g not final<br /> g.spin();<br /> }<br /> // void f(final int i) { i++; } // Can’t change<br /> // You can only read from a final primitive:<br /> int g(final int i) { return i + 1; }<br /> public static void main(String[] args) {<br /> FinalArguments bf = new FinalArguments();<br /> bf.without(null);<br /> bf.with(null);<br /> }<br />} //

方法f()g()展示了基本类型的參数被指定为final是所出现的结果：你能够读參数，但不能改动參数。这一特性仅仅要用来向匿名内部类传递数据。

final 方法

   使用final方法有两个原因。第一个原因是把方法锁定，以防止不论什么继承它的类改动它的含义。这是出于设计的考虑：想要确保在继承中使用的方法保持不变，而且不会被覆盖。

   过去建议使用final方法的第二个原因是效率。在java的早期实现中，假设将一个方法指明为fianl，就是允许编译器将针对该方法的全部调用都转为内嵌调用。当编译器发现一个final方法调用命令时，它会依据自己的慎重推断，跳过插入程序代码这样的正常的调用方式而运行方法调用机制（将參数压入栈，跳至方法代码处运行，然后跳回并清理栈中的參数，处理返回值），而且以方法体中的实际代码的副本来取代方法调用。这将消除方法调用的开销。当然，假设一个方法非常大，你的程序代码会膨胀，因而可能看不到内嵌所带来的性能上的提高，由于所带来的性能会花费于方法内的时间量而被缩减。

    上面标颜色的地方不太懂。不知道那位看过Java编程思想和知道的高人给解释解释。

    在最进的java版本号中，虚拟机(特别是hotspot技术)能够探測到这些情况，并优化去掉这些效率反而减少的额外的内嵌调用，因此不再须要使用final方法来进行优化了。其实，这样的做法正逐渐受到劝阻。在使用java se5/6时，应该让编译器和JVM去处理效率问题，仅仅有在想明白禁止覆盖式，才将方法设置为fianl的。

    final和privatekeyword

   类中的全部private方法都是隐式的制定为final的。因为你无法訪问private方法你也就无法覆盖它。能够对private方法加入�final修饰词，但这毫无意义。

class WithFinals {<br /> // Identical to “private” alone:<br /> private final void f() { print(“WithFinals.f()”); }<br /> // Also automatically “final”:<br /> private void g() { print(“WithFinals.g()”); }<br />}</p> <p>class OverridingPrivate extends WithFinals {<br /> private final void f() {<br /> print(“OverridingPrivate.f()”);<br /> }<br /> private void g() {<br /> print(“OverridingPrivate.g()”);<br /> }<br />}</p> <p>class OverridingPrivate2 extends OverridingPrivate {<br /> public final void f() {<br /> print(“OverridingPrivate2.f()”);<br /> }<br /> public void g() {<br /> print(“OverridingPrivate2.g()”);<br /> }<br />}<br />

     “覆盖”仅仅有在某方法是基类接口的一部分时才会发生。即，必须将一个对象向上转型为它的基类并条用同样的方法。假设某方法是private的，它就不是基类接口的一部分。它仅是一些隐藏于类中的程序代码，假设一个基类中存在某个private方法，在派生类中以同样的名称创建一个public，protected或包訪问权限方法的话，该方法仅仅只是是与基类中的方法有同样的名称而已，并没有覆盖基类方法。由于private方法无法触及且有非常好的隐藏性，所以把它看成是由于他所属类的组织结的原因而存在外，其它不论什么事物都不用考虑。

    final 类

    当将类定义为final时，就表明了你不打算继承该类，并且也不或许别人这样做。换句话说，出于某种考虑，你对该类的设计永不须要做不论什么变动，或者出于安全的考虑，你不希望他有子类。

class SmallBrain {}</p> <p>final class Dinosaur {<br /> int i = 7;<br /> int j = 1;<br /> SmallBrain x = new SmallBrain();<br /> void f() {}<br />}</p> <p>//! class Further extends Dinosaur {}<br />// error: Cannot extend final class ‘Dinosaur’</p> <p>public class Jurassic {<br /> public static void main(String[] args) {<br /> Dinosaur n = new Dinosaur();<br /> n.f();<br /> n.i = 40;<br /> n.j++;<br /> }<br />}<br />

    请注意，final类的域能够依据个人的意愿选择是或不是final。不论类是否被定义为final，相同的规则相同适用于定义为final的域。然而，由于final是无法继承的，所以被final修饰的类中的方法都隐式的制定为fianl，由于你无法覆盖他们。在fianl类中能够给方法加入�final，但这不会产生不论什么意义。