总结关键字final的用法。
 
在Java中声明属性、方法和类时，可使用关键字final来修饰。final变量即为常量，只能赋值一次；final方法不能被子类重写；final类不能被继承。
1．final成员
声明 final 字段有助于优化器作出更好的优化决定，因为如果编译器知道字段的值不会更改，那么它能安全地在寄存器中高速缓存该值。final 字段还通过让编译器强制该字段为只读来提供额外的安全级别。
1.1关于final成员赋值
1）在java中，普通变量可默认初始化。但是final类型的变量必须显式地初始化。
2）final 成员能且只能被初始化一次。
3）final成员必须在声明时（在final变量定义时直接给其赋值）或者在构造函数中被初始化，而不能在其它的地方被初始化。
示例1 Bat.java
public class Bat {
    final double PI = 3.14; // 在定义时赋值
    final int i; // 因为要在构造函数中进行初始化，所以此处便不可再赋值
    final List<Bat> list; // 因为要在构造函数中进行初始化，所以此处便不可再赋值
    Bat() {
       i = 100;
       list = new LinkedList<Bat>();
    }
    Bat(int ii, List<Bat> l) {
       i = ii;
       list = l;
    }
    public static void main(String[] args) {
       Bat b = new Bat();
       b.list.add(new Bat());
       // b.i=25;
       // b.list=new ArrayList<Bat>();
       System.out.println("I=" + b.i + " List Type:" + b.list.getClass());
       b = new Bat(23, new ArrayList<Bat>());
       b.list.add(new Bat());
       System.out.println("I=" + b.i + " List Type:" + b.list.getClass());
    }
}
结果：
I=100 List Type:class java.util.LinkedList
I=23 List Type:class java.util.ArrayList
在main方法中有两行语句注释掉了，如果你去掉注释，程序便无法通过编译，这便是说，不论是i的值或是list的类型，一旦初始化，确实无法再更改。然而b可以通过重新初始化来指定i的值或list的类型。
1.2 final引用字段的无效初始化
要正确使用final字段有点麻烦，对于其构造子能抛出异常的对象引用来说尤其如此。因为 final 字段在每个构造器中必须只初始化一次，如果 final 对象引用的构造器可能抛出异常，编译器可能会报错，说该字段没有被初始化。编译器一般比较智能化，足以发现在两个互斥代码分支（比如，if...else 块）的每个分支中的初始化恰好只进行了一次，但是它对 try...catch 块通常不会如此“宽容”。
下面这段代码通常会出现问题。
class Thingie {
    public static Thingie getDefaultThingie() {
       return new Thingie();
    }
}
public class Foo {
    private final Thingie thingie;
    public Foo() {
       try {
           thingie = new Thingie();
       } catch (Exception e) {
           thingie = Thingie.getDefaultThingie();//Error:The final field thingie may already have been assigned
       }
    }
}
你可以这样修改。
public class Foo {
    private final Thingie thingie;
    public Foo() {
       Thingie tempThingie;
       try {
           tempThingie = new Thingie();
       } catch (Exception e) {
           tempThingie = Thingie.getDefaultThingie();
       }
       thingie = tempThingie;
    }
}
1.3关于final成员使用
当你在类中定义变量时，在其前面加上final关键字，那便是说，这个变量一旦被初始化便不可改变，这里不可改变的意思对基本类型来说是其值不可变，而对于对象变量来说其引用不可再变。然而，对象其本身却是可以被修改的，Java并未提供使任何对象恒定不变的途径。这一限制同样适合数组，它也是对象。
示例2
private final int VAL_ONE=9;
private static final int VAL_TWO=99;
public static final int VAL_THREE=999;
由于VAL_ONE 和VAL_TOW 是带有编译期数值的final 原始类型，所以它们二者均可以用作编译期常量，并且没有重大区别。VAL_THREE是一种更加典型的对常量进行定义的方式：定义为 public，则可以被用于包之外；定义为 static 来强调只有一份；定义为 final 来说明它是一个常量。
final标记的变量即成为常量，但这个“常量”也只能在这个类的内部使用，不能在类的外部直接使用。但是当我们用public static final 共同标记常量时，这个常量就成为全局的常量（一个既是static又是final的字段只占据一段不能改变的存储空间）。而且这样定义的常量只能在定义时赋值，其他地方都不行。
示例3
class Value {
    int i;
    public Value(int i) {
       this.i = i;
    }
}
public class FinalData {
    private static Random rand = new Random();
    private String id;
    public FinalData(String id) {
       this.id = id;
    }
    private final int i4 = rand.nextInt(20);
    static final int i5 = rand.nextInt(20);
    public String toString() {
       return id + ":" + "i4:" + i4 + ", i5=" + i5;
    }
    public static void main(String[] args) {
       FinalData fd1 = new FinalData("fd1");
       System.out.println(fd1);
       System.out.println("Creating new FinalData");
       FinalData fd2 = new FinalData("fd2");
       System.out.println(fd1);
       System.out.println(fd2);
    }
}
结果
fd1:i4:6, i5=3
Creating new FinalData
fd1:i4:6, i5=3
fd2:i4:17, i5=3
示例部分展示了将final 数值定义为static（i5） 和非static（i4） 的区别。此区别只有在数值在运行期内被初始化时才会显现，这是因为编译器对编译期数值一视同仁。（并且它们可能因优化而消失。）当你运行程序时，就会看到这个区别。请注意，在fd1 和fd2 中， i5 的值是不可以通过创建第二个FinalData 对象而加以改变的。这是因为它是 static，在装载时已被初始化，而不是每次创建新对象时都初始化。
示例4
class Value {
    int i;
    public Value(int i) {
       this.i = i;
    }
}
public class … {
    private Value v1=new Value(11);
    private final Value v2=new Value(22);
    private static final Value v3=new Value(33);
   …
}
public static void main(String[] args) {
    …
    fd1.v2.i++;// OK--Object isn't constant!
    fd1.v1=new Value(9);//OK--not final
    fd1.v2=new Value(0);//Error:Can't change reference
    fd1.v3=new Value(1);//Error:Can't change reference
    …
}
从v1 到v3 的变量说明了final 引用的意义。正如你在main( )中所看到的，不能因为v2 是final 的，就认为你无法改变它的值。由于它是一个引用，final 意味着你无法将v2 再次指向另一个新的对象。
示例5
public class … {
    private final int[] a={1,2,3,4,5,6};
    …
}
public static void main(String[] args) {
    …
    for(int i=0;i<fd1.a.length;i++)
 fd1.a[i]++;// OK--Object isn't constant!
    fd1.a=new int[3];//Error:Can't change reference    …
}
对数组具有同样的意义（可以改变它的值，但不能指向一个新的对象），数组是另一种引用。
1.4解决final数组的局限性
尽管数组引用能被声明成 final，但是该数组的元素却不能。这意味着暴露 public final 数组字段的或者通过它们的方法将引用返回给这些字段的类都不是不可改变的。
// Not immutable -- the states array could be modified by a malicious
// callerpublic
class DangerousStates {
    private final String[] states = new String[] { "Alabama", "Alaska", "ect" };
    public String[] getStates() {
       return states;
    }
}
同样，尽管对象引用可以被声明成 final 字段，而它所引用的对象仍可能是可变的。如果想要使用 final 字段创建不变的对象，必须防止对数组或可变对象的引用“逃离”你的类。要不用重复克隆该数组做到这一点，一个简单的方法是将数组转变成 List。
// Immutable -- returns an unmodifiable List insteadpublic
class SafeStates {
    private final String[] states = new String[] { "Alabama", "Alaska", "ect" };
    private final List statesAsList = new AbstractList() {
       public Object get(int n) {
           return states[n];
       }
       public int size() {
           return states.length;
       }
    };
    public List getStates() {
       return statesAsList;
    }
}
1.5关于final参数使用
还有一种用法是定义方法中的参数为final，对于基本类型的变量，这样做并没有什么实际意义，因为基本类型的变量在调用方法时是传值的，也就是说你可以在方法中更改这个参数变量而不会影响到调用语句，然而对于对象变量，却显得很实用，因为对象变量在传递时是传递其引用，这样你在方法中对对象变量的修改也会影响到调用语句中的对象变量，当你在方法中不需要改变作为参数的对象变量时，明确使用final进行声明，会防止你无意的修改而影响到调用方法。
1.6关于内部类中的参数变量
另外方法中的内部类在用到方法中的参变量时，此参数变量必须声明为final才可使用。
示例6 INClass.java
public class INClass {
    void innerClass(final String str) {
       class IClass {
           IClass() {
              System.out.println(str);
           }
       }
       IClass ic = new IClass();
    }
    public static void main(String[] args) {
       INClass inc = new INClass();
       inc.innerClass("Hello");
    }
}
2．final方法
2.1final方法用途
1）为了确保某个函数的行为在继承过程中保持不变，并且不能被覆盖（overridding），可以使用final方法。
2）class中所有的private和static方法自然就是final。
2.2 final与private关键字
类中所有的private方法都隐式地指定是final的。由于无法取用private方法，所以也就无法覆盖它。
“覆盖”只有在某方法是基类的接口的一部分时才会出现。即，必须能将一个对象向上转型为它的基本类型并调用相同的方法。如果某方法为private，它就不是基类的接口的一部分。它仅是一些隐藏于类中的代码，只不过是具有相同的名称而已。但如果在导出类以相同的方法生成一个public、protected或包访问权限方法的话，该方法就不会产生在基类中出现的“仅具有相同名称”的情况。此时，你并没有覆盖该方法，仅是生成了一个新的方法。由于private方法无法触及而且能有效隐藏，所以除了把它看成是因为它所归属的类的组织结构的原因而存在外，其他任何事物都不需要考虑它。
3．final类
将某个类的整体定义为final 时，该类无法被继承。而且由于final类禁止继承，所以final类中所有的方法都隐式指定为final的，因为无法覆盖它们。
final 用于类或方法是为了防止方法间的链接被破坏。例如，假定类 X 的某个方法的实现假设了方法 M 将以某种方式工作。将 X 或 M 声明成 final 将防止派生类以这种方式重新定义 M，从而导致 X 的工作不正常。尽管不用这些内部相关性来实现 X 可能会更好，但这不总是可行的，而且使用 final 可以防止今后这类不兼容的更改。
4．参考资料
[1]Thinking in Java 3rd
[2] 关于java中final方法，类，成员变量的讨论
http://www.cublog.cn/u/11794/showart.php?id=117818
[3] java中的final
2006/02/20/603878.aspx

本文出自 “子 孑” 博客，http://zhangjunhd.blog.51cto.com/113473/20664

转载于:https://www.cnblogs.com/adamzuocy/archive/2009/09/25/1573779.html

Java关键字介绍之final相关推荐

  1. Java 关键字—— static 与 final

      static表示"全局"或者"静态"的意思,用来修饰成员变量和成员方法,也可以形成静态static代码块,但是Java语言中没有全局变量的概念. 被stat ...

  2. Java关键字介绍之this与super

    1．什么是super?什么是this? super关键字表示超(父)类的意思.this变量代表对象本身. 2．使用super&this调用成员变量和方法 可以使用super访问父类被子类隐藏的 ...

  3. Java关键字this、super使用总结

    2019独角兽企业重金招聘Python工程师标准>>> 一.this关键字 Java关键字this只能用于成员方法体内,它是一个系统隐含的指针且被自动附加在非静态的成员方法参数列表中 ...

  4. Java关键字final、static、this、super使用总结

    一.final 根据程序上下文环境,Java关键字final有"这是无法改变的"或者"终态的"含义,它可以修饰非抽象类.非抽象类成员方法和变量.你可能出于两种理 ...

  5. 转！Java关键字final、static使用总结

    Java关键字final.static使用总结 一.final 根据程序上下文环境,Java关键字final有"这是无法改变的"或者"终态的"含义,它可以修饰非 ...

  6. [Java] 关键字final、static使用总结

    一.final 根据程序上下文环境,Java关键字final有"这是无法改变的"或者"终态的"含义,它可以修饰非抽象类.非抽象类成员方法和变量.你可能出于两种理 ...

  7. Java关键字final使用详解

    2019独角兽企业重金招聘Python工程师标准>>> http://docs.oracle.com/javase/tutorial/java/IandI/final.html Wr ...

  8. Java提高篇 —— Java关键字之final的几种用法

    一.前言 在java的关键字中,static和final是两个我们必须掌握的关键字.不同于其他关键字,他们都有多种用法,而且在一定环境下使用,可以提高程序的运行性能,优化程序的结构.下面我们来了解一下 ...

  9. 【java】java 关键字: final详解

    1.概述 转载:java 关键字: final详解

最新文章

  1. 踩坑 ：vue2 ajax异步请求数据，层数太多，页面无法渲染
  2. c#写图像tif gdal_C# GDAL显示TIF
  3. Solr在Weblogic中部署遇到的问题
  4. 如何编写Hadoop调度器
  5. J2ME手机游戏引擎程序结构简述
  6. 你这么喜欢敲代码，那么技术的乐趣在哪里？
  7. PLSQL连接远程Oracle出现ORA-12541: 无监听程序
  8. 与继承相关的一些重构（一）
  9. pandas中size方法_eplot，在pandas中流畅的使用pyecharts！
  10. 在线选课网站用什么服务器,高校网上选课系统 PC服务器替代小型机
  11. 软件测试 | 测试计划包含什么内容
  12. 手机驱动工程师门，准备转行了吗
  13. 远程拨号换IP的方法
  14. 次氯酸钠phP,次氯酸钠
  15. Spring cloud config 配置文件加密
  16. 10.5日饿了么复活了，大家凑合用用吧~（偶尔更新~）
  17. 日语输入法键盘假名对应表
  18. 码元，码元速率，波特率，比特率（个人理解总结）
  19. 截止2021年4月最全全国2800多个学校的图标logo打包，全国大学校徽logo
  20. c语言标准输入输出ppt,C语言版输入输出.ppt

热门文章

  1. Docker+Selenium Grid+Python搭建分布式测试环境
  2. （转载）（官方）UE4--图像编程----Parallel Rendering Overview
  3. ListIterator特有的方法
  4. iframe引用页面中的js操作父窗口标签
  5. 开机时进入 grub rescue＞的解决方法
  6. 以ajax请求方式进行文件下载操作失败的原因及解决方案
  7. [JVM]线上CPU负载持续飙高的问题解决
  8. 解决IDEA中导入新的maven依赖后Language Level自动重置问题
  9. Struts2中采用Json返回List对象数据为空解决方案
  10. zsh:no matches found 问题解决