关闭

final总结

标签: final性能优化
14人阅读 评论(0) 收藏 举报
分类:

java中final 与效率

原创 2012年03月16日 18:26:44

 关于final关键字,总是那么些疑惑,今天就总结一下。 

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

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

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

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

二、final的用法 
1、final 对于常量来说,意味着值不能改变,例如 final int i=100。这个i的值永远都是100。 
但是对于变量来说又不一样,只是标识这个引用不可被改变,例如 final File f=new File("c:\\test.txt");那么这个f一定是不能被改变的,如果f本身有方法修改其中的成员变量,例如是否可读,是允许修改的。有个[/size][size=medium][size=large][/size]形象的比喻:一个女子定义了一个final的老公,这个老公的职业和收入都是允许改变的,只是这个女人不会换老公而已。 

2、关于空白final 
final修饰的变量有三种:静态变量、实例变量和局部变量,分别表示三种类型的常量。  
 另外,final变量定义的时候,可以先声明,而不给初值,这中变量也称为final空白,无论什么情况,编译器都确保空白final在使用之前必须被初始化。但是,final空白在final关键字final的使用上提供了更大的灵活性,为此,一个类中的final数据成员就可以实现依对象而有所不同,却有保持其恒定不变的特征。 
public class FinalTest { 
final int p; 
final int q=3; 
FinalTest(){ 
p=1; 

FinalTest(int i){ 
p=i;//可以赋值,相当于直接定义p 
q=i;//不能为一个final变量赋值 



3、final内存分配 
刚提到了内嵌机制,现在详细展开。 
要知道调用一个函数除了函数本身的执行时间之外,还需要额外的时间去寻找这个函数(类内部有一个函数签名和函数地址的映射表)。所以减少函数调用次数就等于降低了性能消耗。 

final修饰的函数会被编译器优化,优化的结果是减少了函数调用的次数。如何实现的,举个例子给你看: 
public class Test{ 
final void func(){System.out.println("g");}; 
public void main(String[] args){ 
for(int j=0;j<1000;j++)   
func(); 
}} 
经过编译器优化之后,这个类变成了相当于这样写: 
public class Test{ 
final void func(){System.out.println("g");}; 
public void main(String[] args){ 
for(int j=0;j<1000;j++)  
{System.out.println("g");} 
}} 
看出来区别了吧?编译器直接将func的函数体内嵌到了调用函数的地方,这样的结果是节省了1000次函数调用,当然编译器处理成字节码,只是我们可以想象成这样,看个明白。 
不过,当函数体太长的话,用final可能适得其反,因为经过编译器内嵌之后代码长度大大增加,于是就增加了jvm解释字节码的时间。

 

 

 

在使用final修饰方法的时候,编译器会将被final修饰过的方法插入到调用者代码处,提高运行速度和效率,但被final修饰的方法体不能过大,编译器可能会放弃内联,但究竟多大的方法会放弃,我还没有做测试来计算过。 

本文是通过两个疑问来继续阐述的:

1、使用final修饰方法会提高速度和效率吗; 
见下面的测试代码,我会执行五次:

Java代码 复制代码
  1. public class Test   
  2. {   
  3.     public static void getJava()   
  4.     {   
  5.         String str1 = "Java ";   
  6.         String str2 = "final ";   
  7.         for (int i = 0; i < 10000; i++)   
  8.         {   
  9.             str1 += str2;   
  10.         }   
  11.     }   
  12.     public static final void getJava_Final()   
  13.     {   
  14.         String str1 = "Java ";   
  15.         String str2 = "final ";   
  16.         for (int i = 0; i < 10000; i++)   
  17.         {   
  18.             str1 += str2;   
  19.         }   
  20.     }   
  21.     public static void main(String[] args)   
  22.     {   
  23.         long start = System.currentTimeMillis();   
  24.         getJava();   
  25.         System.out.println("调用不带final修饰的方法执行时间为:" + (System.currentTimeMillis() - start) + "毫秒时间");   
  26.         start = System.currentTimeMillis();   
  27.         String str1 = "Java ";   
  28.         String str2 = "final ";   
  29.         for (int i = 0; i < 10000; i++)   
  30.         {   
  31.             str1 += str2;   
  32.         }   
  33.         System.out.println("正常的执行时间为:" + (System.currentTimeMillis() - start) + "毫秒时间");   
  34.         start = System.currentTimeMillis();   
  35.         getJava_Final();   
  36.         System.out.println("调用final修饰的方法执行时间为:" + (System.currentTimeMillis() - start) + "毫秒时间");   
  37.     }   
  38. }  
[java] view plaincopy
  1. public class Test { public static void getJava() { String str1 = "Java "; String str2 = "final "for (int i = 0; i < 10000; i++) { str1 += str2; } } public static final void getJava_Final() { String str1 = "Java "; String str2 = "final "for (int i = 0; i < 10000; i++) { str1 += str2; } } public static void main(String[] args) { long start = System.currentTimeMillis(); getJava(); System.out.println("调用不带final修饰的方法执行时间为:" + (System.currentTimeMillis() - start) + "毫秒时间"); start = System.currentTimeMillis(); String str1 = "Java "; String str2 = "final "for (int i = 0; i < 10000; i++) { str1 += str2; } System.out.println("正常的执行时间为:" + (System.currentTimeMillis() - start) + "毫秒时间"); start = System.currentTimeMillis(); getJava_Final(); System.out.println("调用final修饰的方法执行时间为:" + (System.currentTimeMillis() - start) + "毫秒时间"); } }  
[java] view plain copy
  1. public class Test { public static void getJava() { String str1 = "Java "; String str2 = "final "for (int i = 0; i < 10000; i++) { str1 += str2; } } public static final void getJava_Final() { String str1 = "Java "; String str2 = "final "for (int i = 0; i < 10000; i++) { str1 += str2; } } public static void main(String[] args) { long start = System.currentTimeMillis(); getJava(); System.out.println("调用不带final修饰的方法执行时间为:" + (System.currentTimeMillis() - start) + "毫秒时间"); start = System.currentTimeMillis(); String str1 = "Java "; String str2 = "final "for (int i = 0; i < 10000; i++) { str1 += str2; } System.out.println("正常的执行时间为:" + (System.currentTimeMillis() - start) + "毫秒时间"); start = System.currentTimeMillis(); getJava_Final(); System.out.println("调用final修饰的方法执行时间为:" + (System.currentTimeMillis() - start) + "毫秒时间"); } }  


结果为: 
第一次: 
调用不带final修饰的方法执行时间为:1732毫秒时间 
正常的执行时间为:1498毫秒时间 
调用final修饰的方法执行时间为:1593毫秒时间 
第二次: 
调用不带final修饰的方法执行时间为:1217毫秒时间 
正常的执行时间为:1031毫秒时间 
调用final修饰的方法执行时间为:1124毫秒时间 
第三次: 
调用不带final修饰的方法执行时间为:1154毫秒时间 
正常的执行时间为:1140毫秒时间 
调用final修饰的方法执行时间为:1202毫秒时间 
第四次: 
调用不带final修饰的方法执行时间为:1139毫秒时间 
正常的执行时间为:999毫秒时间 
调用final修饰的方法执行时间为:1092毫秒时间 
第五次: 
调用不带final修饰的方法执行时间为:1186毫秒时间 
正常的执行时间为:1030毫秒时间 
调用final修饰的方法执行时间为:1109毫秒时间 

    由以上运行结果不难看出,执行最快的是“正常的执行”即代码直接编写,而使用final修饰的方法,不像有些书上或者文章上所说的那样,速度与效率与“正常的执行”无异,而是位于第二位,最差的是调用不加final修饰的方法。 
观点:加了比不加好一点。 


1、使用final修饰变量会让变量的值不能被改变吗; 
见代码:

Java代码 复制代码
  1. public class Final   
  2. {   
  3.     public static void main(String[] args)   
  4.     {   
  5.         Color.color[3] = "white";   
  6.         for (String color : Color.color)   
  7.             System.out.print(color+" ");   
  8.     }   
  9. }   
  10.   
  11. class Color   
  12. {   
  13.     public static final String[] color = { "red""blue""yellow""black" };   
  14. }  
[java] view plaincopy
  1. public class Final { public static void main(String[] args) { Color.color[3] = "white"for (String color : Color.color) System.out.print(color+" "); } } class Color { public static final String[] color = { "red""blue""yellow""black" }; }  
[java] view plain copy
  1. public class Final { public static void main(String[] args) { Color.color[3] = "white"for (String color : Color.color) System.out.print(color+" "); } } class Color { public static final String[] color = { "red""blue""yellow""black" }; }  


执行结果: 
red blue yellow white 
看!,黑色变成了白色。 
    在使用findbugs插件时,就会提示public static String[] color = { "red", "blue", "yellow", "black" };这行代码不安全,但加上final修饰,这行代码仍然是不安全的,因为final没有做到保证变量的值不会被修改!原因是:final关键字只能保证变量本身不能被赋与新值,而不能保证变量的内部结构不被修改。例如在main方法有如下代码Color.color = new String[]{""};就会报错了。那可能有的同学就会问了,加上final关键字不能保证数组不会被外部修改,那有什么方法能够保证呢?答案就是降低访问级别,把数组设为private。这样的话,就解决了数组在外部被修改的不安全性,但也产生了另一个问题,那就是这个数组要被外部使用的。 
解决这个问题见代码:

Java代码 复制代码
  1. import java.util.AbstractList;   
  2. import java.util.List;   
  3.   
  4. public class Final   
  5. {   
  6.     public static void main(String[] args)   
  7.     {   
  8.         for (String color : Color.color)   
  9.             System.out.print(color + " ");   
  10.         Color.color.set(3"white");   
  11.     }   
  12. }   
  13.   
  14. class Color   
  15. {   
  16.     private static String[] _color = { "red""blue""yellow""black" };   
  17.     public static List<String> color = new AbstractList<String>()   
  18.     {   
  19.         @Override  
  20.         public String get(int index)   
  21.         {   
  22.             return _color[index];   
  23.         }   
  24.         @Override  
  25.         public String set(int index, String value)   
  26.         {   
  27.             throw new RuntimeException("为了代码安全,不能修改数组");   
  28.         }   
  29.         @Override  
  30.         public int size()   
  31.         {   
  32.             return _color.length;   
  33.         }   
  34.     };  
[java] view plaincopy
  1. import java.util.AbstractList; import java.util.List; public class Final { public static void main(String[] args) { for (String color : Color.color) System.out.print(color + " "); Color.color.set(3"white"); } } class Color { private static String[] _color = { "red""blue""yellow""black" }; public static List<String> color = new AbstractList<String>() { @Override public String get(int index) { return _color[index]; } @Override public String set(int index, String value) { throw new RuntimeException("为了代码安全,不能修改数组"); } @Override public int size() { return _color.length; } };  
[java] view plain copy
  1. import java.util.AbstractList; import java.util.List; public class Final { public static void main(String[] args) { for (String color : Color.color) System.out.print(color + " "); Color.color.set(3"white"); } } class Color { private static String[] _color = { "red""blue""yellow""black" }; public static List<String> color = new AbstractList<String>() { @Override public String get(int index) { return _color[index]; } @Override public String set(int index, String value) { throw new RuntimeException("为了代码安全,不能修改数组"); } @Override public int size() { return _color.length; } };  


}这样就OK了,既保证了代码安全,又能让数组中的元素被访问了。

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:3273次
    • 积分:127
    • 等级:
    • 排名:千里之外
    • 原创:5篇
    • 转载:22篇
    • 译文:0篇
    • 评论:0条