java的final关键字

本文主要讲述java的final关键字和相关细节。

　　老韩知识介绍：

　　示例代码如下：

 1 public class FinalTest {
 2     public static void main(String[] args) {
 3 
 4     }
 5 }
 6 
 7 /**
 8  * (4) final修饰类时，不能被继承
 9  */
10 final class A {
11     private String name;
12     /**
13      * (1) final修饰成员变量，不能修改
14      */
15     public final int id =100;
16 
17     public void updateId(){
18 //        id = 104;
19         System.out.println(id);
20     }
21 
22     /**
23      * (2) final修饰局部变量，不能修改
24      */
25     public void fun(){
26         final int num = 10;
27 //        num = 100;
28         System.out.println(num);
29     }
30 
31     /**
32      * (3) final修饰方法，不能被重写【继承相关】
33      */
34     public final void show(){
35         System.out.println(\"name: \"+name);
36     }
37 }
38 
39 //class B extends A{
40 //    public final void show(){
41 //        System.out.println(\"name: \"+name);
42 //    }
43 //}

　　老韩final关键字细节讨论

　　2）代码示例如下：

 1 public class FinalDetail {
 2     public static void main(String[] args) {
 3 
 4         System.out.println(new AA().NUM4);
 5     }
 6 }
 7 
 8 /**
 9  * 含有final关键字的变量，赋值方式：
10  * (1) 定义时，赋值
11  * (2) 构造器，赋值
12  * (3) 普通代码块，赋值
13  * (4) 普通方法，赋值
14  */
15 class AA {
16     private final int NUM1 = 10;
17     private final int NUM2;
18     private final int NUM3;
19     public final int NUM4 = getNum();
20 
21     public int getNum(){
22         return 10;
23     }
24 
25     public AA() {
26         NUM2 = 10;
27     }
28     {
29         NUM3 = 10;
30     }
31 }

　　3）示例代码如下：

 1 public class FinalDetail01 {
 2     public static void main(String[] args) {
 3         System.out.println(AAA.NUM3);
 4     }
 5 }
 6 
 7 class AAA {
 8     /**
 9      * static的final变量赋值方式:
10      * (1) 定义，赋值
11      * (2) static代码块，赋值
12      * (3) static方法，赋值
13      * 注意，此时final变量是静态变量，不能在构造器赋值。
14      */
15     private static final int NUM1 = 10;
16     private static final int NUM2;
17     public static final int NUM3 = getNum();
18 //    private static final int NUM4;
19 //
20 //    public AAA(){
21 //        NUM4 = 10;
22 //    }
23 
24     public static int getNum(){
25         return 10;
26     }
27 
28     static{
29         NUM2 = 10;
30     }
31 }

　　7）代码示例如下：

 1 public class FinalDetail02 {
 2     public static void main(String[] args) {
 3         System.out.println(Aa.NUM);
 4     }
 5 }
 6 class Aa {
 7     public static int NUM = 10;
 8     static {
 9         System.out.println(\"static的代码块被执行\");
10     }
11 }

　　运行结果如下：

　　在static的NUM加了final关键字，

 1 public class FinalDetail02 {
 2     public static void main(String[] args) {
 3         System.out.println(Aa.NUM);
 4     }
 5 }
 6 class Aa {
 7     public final static int NUM = 10;
 8     static {
 9         System.out.println(\"static的代码块被执行\");
10     }
11 }

　　运行结果如下：

　　由此可以看出，静态变量，若加了final关键字，在main中使用该静态变量时，无需加载类，直接使用。

来源：https://www.cnblogs.com/zwgitOne123/p/16993770.html
本站部分图文来源于网络，如有侵权请联系删除。