前言
在java中可以将实例域定义为final。在构建对象是必须初始化这样的值。必须确保在每个构造器执行之后，这个域的值被设置，并且在后面的操作中不再对其修改。使用final声明变量之后，这个值就不能修改，一般final类型的变量都被声明为静态变量，而且是公有类型的，它在内存中被放在一个特有的公共区域。
也就是说，在Java语法中规定，final修饰的成员变量必须有程序员显式地指定初始值。
定义格式为： public static final double pi = 3.1415926；
final修饰符大多应用于基本类型域，或不可变类的域（如果类中的每个方法都不会改变其对象，这种类成为不可变类。比如说Java中的String类就是一个不可变类。）
如果定义了两个相同的变量，都是final类型的，这两个相同的变量名有着不同的值，其实在内存中是开辟了两个内存空间，之前定义的变量的值会被后来定义的变量的值覆盖掉。原理是变量名指向后来定义的变量值的内存空间，之前定义的变量值会被Java虚拟机根据某种特定的算法在特定的时间处理掉。
在下面的代码中详细的介绍了final类型的变量如何进行定义和初始化：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
|
public class FinalVariableText { //定义成员变量是指定默认值，合法 final int a = 6; //下面变量将在构造器或初始化块中分配初始值 final String str; final int c ; final static double d; //既没有指定默认值，也没有在初始化块、构造器中指定初始值 //下面定义的ch实例变量是不合法的 //final char ch; { //在初始化块中只懂初始值，合法 str ="hello" ; //定义a实例变量已经有初始值了，不能为a重新赋值。下面的语句是不正确的 //a = 9; } //静态初始化块 static { // d是静态成员变量，必须在静态初始化块中为其指定初始值 d = 5.6; } //构造器，可对 没有设置初始值的成员变量设置初始值 //构造器必须与类名相同，这一点注意！ public FinalVariableText(){ //如果在初始化块中对str赋初值，在构造器中在为str重新赋值，是不合法的，程序会抛出错误。 c = 5; } public void changeFinal() { //普通方法不能为final修饰的成员变量赋值 //d = 1.3； //也不能在普通方法中为没有设置初始值的final类型的变量赋初值 //ch = 'ch'; } public static void main(String[] args) { FinalVariableText ff = new FinalVariableText(); System.out.println(ff.a); System.out.println(ff.c); System.out.println(ff.str); System.out.println(ff.d); } |
结果：
6
5
hello
5.6
注意：
如果打算在构造器、初始化块中对final类型的成员变量进行初始化，则不要在初始化之前访问成员变量的值，否则会引发程序报错。
final也存在局部变量的情况
系统不会对局部变量进行初始化，局部变量必须由程序员显式的进行初始化，因此使用final修饰局部变量的时候，既可以在定义是设定默认值，也可以不指定默认值。如果在定义是没有进行设定默认值，则可以在后面的代码中对该final变量赋初值，但只能一次，不可以重复赋值。当然如果在定义变量的时候就已经指定默认值，在后面的代码中就没有必要也不允许对该变量在进行赋值操作。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
public void text(final int a) {//不能对fianl修饰的形参进行赋值操作//a = 5; 该语句是不合法的}public static void main(String[] args) { //定义final局部变量时，指定初始值，则该变量再无法进行赋值了final String str = "str";//下面的语句会报错，不合法//str = "Java";//定义final变量没有指定默认值，则可以被赋值一次final int d;d = 5;//再对d进行新的赋值，不合法// d = 8;} |
Final修饰基本类型变量和引用类型的变量的区别
Final修饰基本类型变量上面已经讲述的很清楚了，那引用类型的变量会有什么不同呢？对于引用类型的变量而言，它仅仅是保存了一个引用关系，final只保证这个引用类型变量所引用的地址不会改变，即一直引用同一个对象，但这个对象完全可以发生改变。下面通过代码来验证一下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
class Person1{ private int age; //有一个参数的构造函数 public Person1(int age) { this.age = age; } public int getAge() { return age; } public void setAge(int age) { this.age = age; }} public class FinalReferenceText { public static void main(String[] args) { final int [] arr = {5,6,12,9}; System.out.println(Arrays.toString(arr)); Arrays.sort(arr); System.out.println(Arrays.toString(arr)); arr[2] = -8; System.out.println(Arrays.toString(arr)); //下面对arr重新赋值，非法 //arr = null; //final 修饰Person变量，p是一个引用变量 final Person1 p = new Person1(45); //改变Person对象的实例变量，合法 p.setAge(55); System.out.println(p.getAge()); //下面对p重新赋值，非法 //p = null; } } |
结果：
[5, 6, 12, 9]
[5, 6, 9, 12]
[5, 6, -8, 12]
55
final方法
Final修饰的方法不可被重写，如果处于某种原因，不希望子类重写父类的某个方法，则可以使用final关键字修饰该方法。
如果父类中的方法的是公有的，则子类中不能有一个一样方法名，一样参数的方法，但如果父类中的方法是私有的，那么子类中完全可以写一个一样的方法。
对于private类型的方法，由于其只能在当前类中可见，其子类无法访问到该方法，所以子类无法重写该方法，那么，如果子类中存在一个与父类private方法有相同方法名，一样的参数列表，相同的返回值的方法，也不是方法的重写，只是重新定义了一个新的方法。因此，final修饰一个private方法，依然可以在其子类中定义和父类private类型一样的方法，不会有程序错误。
|
1
2
3
4
5
6
7
8
9
10
11
|
public class PrivateFinalText{ //如果将访问修饰符改成public，则其子类中的方法定义在程序编译时会报错 private final void text(); } class Sub extends PrivateFinalText{ //下面的方法完全没有问题 public void text();} |
以上是我目前对Java中final关键字的总结，稍后会有补充！！！
总结
到此这篇关于Java中final关键字的文章就介绍到这了,更多相关Java的final关键字内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！
原文链接：https://blog.csdn.net/IBLiplus/article/details/81072264
