Go语言视频零基础入门到精通

javalearner

一 概念
    在java中, 可以使用final关键字修饰类、方法以及成员变量。

1 final标记的类不能被继承
    在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。

2 final标记的方法不能被子类重写
① 把方法锁定，防止任何继承类修改它的意义和实现
② 高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率

3 final标记的变量即成为常量,只能被赋值一次

二 用法

1 对于引用类型和值类型来说
   final的变量一旦被赋值，就不能再此改变。但对于引用类型，其“不可改变”的是指其地址不能改变而其属性可以改变。   
  
   
   

     
   

     
   
  


2 对于成员变量和局部变量来说
对于final的成员变量，对其赋值有两种方式：① 声明时即赋值；②构造方法中赋值。
对于final的局部变量，对其赋值有两种方式：①声明时即赋值；②使用的时候赋值。

例子一

1. 
   
2. public class Test
   
3. {
   
4. final int a;
   
5. final int b = 0;//声明时赋值
   
6. public Test()
   
7. {
   
8.   a = 0;
   
9.   // b = 1;//编译不能通过
   
10. }
    
11. public Test(int i)
    
12. {
    
13.   a = 1;
    
14. }
    
15. public static void printFinal()
    
16. {
    
17.   final int m = 100;
    
18.   // m = 101;//编译不能通过
    
19.   final int n;
    
20.   n = 102;
    
21.   // n = 103;
    
22.   System.out.println("m + n=" + m + n);
    
23. }
    
24. }
    
25. 
    
26. 例子二
    
27. import cn.xy.model.Person;
    
28. public class Test2
    
29. {
    
30. final Person p = new Person("xy");
    
31. final Person p2;
    
32. public Test2()
    
33. {
    
34.   p2 = new Person("xy");
    
35.   p.setName("xyy");
    
36.   // p = new Person("Jim");//编译不能通过
    
37.   // p = null;
    
38. }
    
39. public Test2(int i)
    
40. {
    
41.   p2 = new Person("xy");
    
42. }
    
43. public static void printFinal()
    
44. {
    
45.   final Person p = new Person("xy");
    
46.   p.setName("xyy");
    
47.   // p = new Person("Jim");
    
48.   // p = null;
    
49. }
    
50. }
51. 
    
52. 3 关于final修饰类和方法的例子这里不举例，读者可以试一试。
    
53. 
    

复制代码

三 final内存分配

    调用一个函数除了函数本身的执行时间之外，还需要时间去寻找这个函数(类内部有一个函数签名和函数地址的映射表)。故减少函数调用次数就等于降低了性能消耗。final修饰的函数会被编译器优化，优化的结果是减少了函数调用的次数。

1. public class Test3
   
2. {
   
3. final void function()
   
4. {
   
5.   System.out.println("xy");
   
6. }
   
7. 
   
8. public static void main(String[] args)
   
9. {
   
10.   Test3 t = new Test3();
    
11.   for(int i = 0;i< 1000;i++)
    
12.   {
    
13.    t.function();
    
14.   }
    
15. }
    
16. }
    
17. 
    
18. 经过编译器优化之后，这个类变成了相当于这样写：
    
19. public class Test3
    
20. {
    
21. final void function()
    
22. {
    
23.   System.out.println("xy");
    
24. }
    
25. 
    
26. public static void main(String[] args)
    
27. {
    
28.   Test3 t = new Test3();
    
29.   for(int i = 0;i< 1000;i++)
    
30.   {
    
31.    System.out.println("xy");
    
32.   }
    
33. }
    
34. }
    

复制代码

优点：
   编译器直接将function的函数体内嵌到了调用函数的地方，这样的结果是节省了1000次函数调用，当然编译器处理成字节码，只是我们可以想象成这样，看个明白。

缺点：
   当函数体若太长时用final会适得其反，因为经过编译器内嵌之后代码长度大大增加，于是就增加了JVM解释字节码的时间。而且如果final修饰的方法体过大的话，编译器可能会放弃内联。



  
  
   
   

     
   

     
   
  

复制代码