疯狂Java之学习笔记(27)-------------final

举报
brucexiaogui 发表于 2021/12/30 00:23:46 2021/12/30
【摘要】 疯狂Java之学习笔记(27)-------------final 一、final  根据程序上下文环境,Java关键字final有“这是无法改变的”或者“终态的”含义,它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变:设计或效率。final类不能被继承,没有子类,final类中的方法默认是fin...

疯狂Java之学习笔记(27)-------------final

一、final 
 根据程序上下文环境,
Java关键字final有“这是无法改变的”或者“终态的”含义,它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变:设计或效率。
final类不能被继承,没有子类,final类中的方法默认是final的。 
final方法不能被子类的方法覆盖,但可以被继承。 
final成员变量表示常量,只能被赋值一次,赋值后值不再改变。 
final不能用于修饰构造方法。 
注意:父类的private成员方法是不能被子类方法覆盖的,因此private类型的方法默认是final类型的。 

1、final类 
 final类不能被继承,因此final类的成员方法没有机会被覆盖,默认都是final的。在设计类时候,如果这个类不需要有子类,类的实现细节不允许改变,并且确信这个类不会载被扩展,那么就设计为final类。

2、final方法 
如果一个类不允许其子类覆盖某个方法,则可以把这个方法声明为final方法。 
使用final方法的原因有二: 
第一、把方法锁定,防止任何继承类修改它的意义和实现。 
第二、高效。编译器在遇到调用final方法时候会转入内嵌机制,大大提高执行效率。 
例如:


  
  1. public class Test1 {
  2. public static void main(String[] args) {
  3. // TODO 自动生成方法存根
  4. }
  5. public void f1() {
  6. System.out.println("f1");
  7. }
  8. //无法被子类覆盖的方法
  9. public final void f2() {
  10. System.out.println("f2");
  11. }
  12. public void f3() {
  13. System.out.println("f3");
  14. }
  15. private void f4() {
  16. System.out.println("f4");
  17. }
  18. }
  19. public class Test2 extends Test1 {
  20. public void f1(){
  21. System.out.println("Test1父类方法f1被覆盖!");
  22. }
  23. public static void main(String[] args) {
  24. Test2 t=new Test2();
  25. t.f1();
  26. t.f2(); //调用从父类继承过来的final方法
  27. t.f3(); //调用从父类继承过来的方法
  28. //t.f4(); //调用失败,无法从父类继承获得
  29. }
  30. }
3、final变量(常量)  
 用final修饰的成员变量表示常量,值一旦给定就无法改变! 
 final修饰的变量有三种:静态变量、实例变量和局部变量,分别表示三种类型的常量。 
 从下面的例子中可以看出,一旦给final变量初值后,值就不能再改变了。 
 另外,final变量定义的时候,可以先声明,而不给初值,这中变量也称为final空白,无论什么情况,编译器都确保空白final在使用之前必须被初始化。但是,final空白在final关键字final的使用上提供了更大的灵活性,为此,一个类中的final数据成员就可以实现依对象而有所不同,却有保持其恒定不变的特征。

 


  
  1. package org.leizhimin;
  2. public class Test3 {
  3. private final String S="final实例变量S";
  4. private final int A=100;
  5. public final int B=90;
  6. public static final int C=80;
  7. private static final int D=70;
  8. public final int E; //final空白,必须在初始化对象的时候赋初值
  9. public Test3(int x){
  10. E=x;
  11. }
  12. /**
  13. * @param args
  14. */
  15. public static void main(String[] args) {
  16. Test3 t=new Test3(2);
  17. //t.A=101; //出错,final变量的值一旦给定就无法改变
  18. //t.B=91; //出错,final变量的值一旦给定就无法改变
  19. //t.C=81; //出错,final变量的值一旦给定就无法改变
  20. //t.D=71; //出错,final变量的值一旦给定就无法改变
  21. System.out.println(t.A);
  22. System.out.println(t.B);
  23. System.out.println(t.C); //不推荐用对象方式访问静态字段
  24. System.out.println(t.D); //不推荐用对象方式访问静态字段
  25. System.out.println(Test3.C);
  26. System.out.println(Test3.D);
  27. //System.out.println(Test3.E); //出错,因为E为final空白,依据不同对象值有所不同.
  28. System.out.println(t.E);
  29. Test3 t1=new Test3(3);
  30. System.out.println(t1.E); //final空白变量E依据对象的不同而不同
  31. }
  32. private void test(){
  33. System.out.println(new Test3(1).A);
  34. System.out.println(Test3.C);
  35. System.out.println(Test3.D);
  36. }
  37. public void test2(){
  38. final int a; //final空白,在需要的时候才赋值
  39. final int b=4; //局部常量--final用于局部变量的情形
  40. final int c; //final空白,一直没有给赋值.
  41. a=3;
  42. //a=4; 出错,已经给赋过值了.
  43. //b=2; 出错,已经给赋过值了.
  44. }
  45. }
4、final参数  

当函数参数为final类型时,你可以读取使用该参数,但是无法改变该参数的值。


  
  1. public class Test4 {
  2. public static void main(String[] args) {
  3. new Test4().f1(2);
  4. }
  5. public void f1(final int i){
  6. //i++; //i是final类型的,值不允许改变的.
  7. System.out.print(i);
  8. }
  9. }

根据上下文环境,java的关键字final也存在着细微的区别,但通常指的是“这是无法改变的。”不想改变的理由由两种:一种是效率,另一种是设计。由于两个原因相差很远,所以关键子final可能被吴用。

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

  

   final数据

   许多编程语言都有某种方法,来向编译器告知一块数据是恒定不变的。有时数据的恒定不变是很有用的,例如:

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

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

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

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

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

   下面的事例示范fianl域的情况。注意,根据惯例,即是static又是fianl的域(即编译器常量)将用大写表示,并用下划分割个单词:


  
  1. package reusing;
  2. //: reusing/FinalData.java
  3. // The effect of final on fields.
  4. import java.util.*;
  5. import static net.mindview.util.Print.*;
  6. class Value {
  7. int i; // Package access
  8. public Value(int i) { this.i = i; }
  9. }
  10. public class FinalData {
  11. private static Random rand = new Random(47);
  12. private String id;
  13. public FinalData(String id) { this.id = id; }
  14. // Can be compile-time constants:
  15. private final int valueOne = 9;
  16. private static final int VALUE_TWO = 99;
  17. // Typical public constant:
  18. public static final int VALUE_THREE = 39;
  19. // Cannot be compile-time constants:
  20. private final int i4 = rand.nextInt(20);
  21. static final int INT_5 = rand.nextInt(20);
  22. private Value v1 = new Value(11);
  23. private final Value v2 = new Value(22);
  24. private static final Value VAL_3 = new Value(33);
  25. // Arrays:
  26. private final int[] a = { 1, 2, 3, 4, 5, 6 };
  27. public String toString() {
  28. return id + ": " + "i4 = " + i4 + ", INT_5 = " + INT_5;
  29. }
  30. public static void main(String[] args) {
  31. FinalData fd1 = new FinalData("fd1");
  32. //! fd1.valueOne++; // Error: can't change value
  33. fd1.v2.i++; // Object isn't constant!
  34. fd1.v1 = new Value(9); // OK -- not final
  35. for(int i = 0; i < fd1.a.length; i++)
  36. fd1.a[i]++; // Object isn't constant!
  37. //! fd1.v2 = new Value(0); // Error: Can't
  38. //! fd1.VAL_3 = new Value(1); // change reference
  39. //! fd1.a = new int[3];
  40. print(fd1);
  41. print("Creating new FinalData");
  42. FinalData fd2 = new FinalData("fd2");
  43. print(fd1);
  44. print(fd2);
  45. }
  46. }
  47. /* Output:
  48. fd1: i4 = 15, INT_5 = 18
  49. Creating new FinalData
  50. fd1: i4 = 15, INT_5 = 18
  51. fd2: i4 = 13, INT_5 = 18
  52. */

由于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的,在装载类时(也就是第一次创建这个类对象时)已经被初始化,而不是每次创建都初始化。

   


如果看上面的事例来理解我标记颜色的的部分有点困难的话,请看下面的事例:


  
  1. public class B3 {
  2. static Random r =new Random(12);
  3. final int int1= r.nextInt(100);//产生0-99的随机数
  4. static final int INT_2= r.nextInt(100);
  5. public static void main(String[] args) {
  6. B3 b1=new B3();
  7. System.out.println("int1:"+b1.int1+" INT_2:"+b1.INT_2);
  8. B3 b2=new B3();
  9. //b2.INT_2=100;//错误的赋值
  10. System.out.println("int1:"+b2.int1+" INT_2:"+b2.INT_2);
  11. }
  12. }

启动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域可以根据某些对象有所不同,却又保持恒定不变的特性。下面的事例说明了一点。


  
  1. class Poppet {
  2. private int i;
  3. Poppet(int ii) { i = ii; }
  4. }
  5. public class BlankFinal {
  6. private final int i = 0; // Initialized final
  7. private final int j; // Blank final
  8. private final Poppet p; // Blank final reference
  9. // Blank finals MUST be initialized in the constructor:
  10. public BlankFinal() {
  11. j = 1; // Initialize blank final
  12. p = new Poppet(1); // Initialize blank final reference
  13. }
  14. public BlankFinal(int x) {
  15. j = x; // Initialize blank final
  16. p = new Poppet(x); // Initialize blank final reference
  17. }
  18. public static void main(String[] args) {
  19. new BlankFinal();
  20. new BlankFinal(47);
  21. }
  22. } //

final 参数

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


  
  1. class Gizmo {
  2. public void spin() {}
  3. }
  4. public class FinalArguments {
  5. void with(final Gizmo g) {
  6. //! g = new Gizmo(); // Illegal -- g is final
  7. }
  8. void without(Gizmo g) {
  9. g = new Gizmo(); // OK -- g not final
  10. g.spin();
  11. }
  12. // void f(final int i) { i++; } // Can't change
  13. // You can only read from a final primitive:
  14. int g(final int i) { return i + 1; }
  15. public static void main(String[] args) {
  16. FinalArguments bf = new FinalArguments();
  17. bf.without(null);
  18. bf.with(null);
  19. }
  20. } //

方法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修饰词,但这毫无意义。


  
  1. class WithFinals {
  2. // Identical to "private" alone:
  3. private final void f() { print("WithFinals.f()"); }
  4. // Also automatically "final":
  5. private void g() { print("WithFinals.g()"); }
  6. }
  7. class OverridingPrivate extends WithFinals {
  8. private final void f() {
  9. print("OverridingPrivate.f()");
  10. }
  11. private void g() {
  12. print("OverridingPrivate.g()");
  13. }
  14. }
  15. class OverridingPrivate2 extends OverridingPrivate {
  16. public final void f() {
  17. print("OverridingPrivate2.f()");
  18. }
  19. public void g() {
  20. print("OverridingPrivate2.g()");
  21. }
  22. }

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

    final 类

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


  
  1. class SmallBrain {}
  2. final class Dinosaur {
  3. int i = 7;
  4. int j = 1;
  5. SmallBrain x = new SmallBrain();
  6. void f() {}
  7. }
  8. //! class Further extends Dinosaur {}
  9. // error: Cannot extend final class 'Dinosaur'
  10. public class Jurassic {
  11. public static void main(String[] args) {
  12. Dinosaur n = new Dinosaur();
  13. n.f();
  14. n.i = 40;
  15. n.j++;
  16. }
  17. }
请注意,final类的域可以根据个人的意愿选择是或不是final。不论类是否被定义为final,相同的规则同样适用于定义为final的域。然而,由于final是无法继承的,所以被final修饰的类中的方法都隐式的制定为fianl,因为你无法覆盖他们。在fianl类中可以给方法添加final,但这不会产生任何意义。


转载自:https://blog.csdn.net/u011225629/article/details/45664841





文章来源: brucelong.blog.csdn.net,作者:Bruce小鬼,版权归原作者所有,如需转载,请联系作者。

原文链接:brucelong.blog.csdn.net/article/details/79993202

【版权声明】本文为华为云社区用户转载文章,如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。