【Java】final 修饰符（final修饰的类，方法和变量）_final修饰类

为什么需要使用final修饰符

继承关系最大的弊端是破坏封装。子类能访问父类的实现细节，而且可以通过方法覆盖的形式修改实现细节；

多个修饰符之间是没有先后关系的.:

public static final ; //推荐用这种
public final static ;
final static punlic;
1
2
3

final本身的含义：最终的，不可改变的。
可以修饰非抽象类，非抽象方法和变量。
注意：构造器不能使用final修饰，因为构造器不能被继承，肯定是最终的。

1. final修饰的类：表示最终的类，该类不能再有子类

final class SuperClass{}
class SubClass extends SuperClass{} // 编译报错，不能继承final修饰的类
class FianlDemo 
{
	public static void main(String[] args) {}
}
1
2
3
4
5
6

---------- 编译java ----------
FianlDemo.java:3: 错误: 无法从最终SuperClass进行继承
class SubClass extends SuperClass{}
                       ^
1 个错误

输出完成 (耗时 0 秒) - 正常终止
1
2
3
4
5
6
7

只要有以下条件之一就可以把一个类设置为final类：

a. 某类不是专门为继承而设计的；

b. 处于安全考虑，类的实现细节不允许改动；

c. 确信该类不会再被拓展；

面试题：列举5个Java中内置使用fianl修饰的类：

Java里final修饰的类有很多，比如八大基本数据类型类和String类；

2. final修饰的方法：最终方法，不能被子类覆盖

class SuperClass{
	final public void dowork(){}
}
class SubClass extends SuperClass{
	public void dowork(){} //编译报错，无法覆盖父类中使用fianl修饰的方法
}
1
2
3
4
5
6

---------- 编译java ----------
FianlDemo.java:7: 错误: SubClass中的dowork()无法覆盖SuperClass中的dowork()
	public void dowork(){}
	            ^
  被覆盖的方法为final
1 个错误

输出完成 (耗时 0 秒) - 正常终止
1
2
3
4
5
6
7
8

什么情况下方法需要使用final:

a.在父类中提供的统一的算法，不准子类通过方法覆盖来修改。【模板方法设计模式】

b. 在构造器中调用的方法（初始化方法），此时使用final修饰。

final修饰的方法，子类可以调用，但不能覆盖；

fianl类和final方法可以共存，但是没有太大意义

final class SuperClass{

	final public void dowork(){} //编译通过，但是无太大意义
}
1
2
3
4

3. final修饰的变量

常量分类:
（1）字面值常量(直接给出的数据值/直接量)。比如：整数常量1，2，3，小数常量3.14，布尔常量false，true等。

（2）定义的final变量: 表示常量，改变量只能赋值一次，不能再赋值。

final修饰的变量的特点：

（1）final变量必须显示地指定初始值，系统不会为final字段初始化，必须手动赋初值

class FianlDemo 
{
	final static String name;
	public static void main(String[] args) {	
		System.out.println(name);//final修饰的变量未赋初始值，编译报错
	}
}
1
2
3
4
5
6
7

---------- 编译java ----------
FianlDemo.java:13: 错误: 变量 name 未在默认构造器中初始化
	final static String name;
	                    ^
1 个错误

输出完成 (耗时 0 秒) - 正常终止
1
2
3
4
5
6
7

（2）final变量一旦赋予初始值，就不能被重新赋值。

class FianlDemo 
{
	final static String name = "AAA";
	public static void main(String[] args) {
		name = "BBB"; // 编译报错，无法再为name重新赋值
		System.out.println(name);
	}
}
1
2
3
4
5
6
7
8

---------- 编译java ----------
FianlDemo.java:15: 错误: 无法为最终变量name分配值
		name = "BBB";
		^
1 个错误

输出完成 (耗时 0 秒) - 正常终止
1
2
3
4
5
6
7

（3）常量名规范： 常量名符合标识符，单词全部使用大写字母，如果是多个单词组成,单词间使用下划线隔开。如int类型的最大值：

	final int MAX_VALUE = ....;
1

补充概念:

全局静态常量：public static final 修饰的变量，直接使用类名调用即可。

面试题:

1. final修饰的引用类型变量到底表示引用的地址不能改变，还是引用空间中的数据不能改变？

class SuperClass{
	public String name = "初始值";
}

class FianlDemo 
{
	public static void main(String[] args) {

		final SuperClass sup = new SuperClass();
		System.out.println(sup.name);
		sup.name = "修改后的值";
		System.out.println(sup.name);		
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

编译通过，打印的内容如下：

---------- 运行java ----------
初始值
修改后的值

输出完成 (耗时 0 秒) - 正常终止
1
2
3
4
5

再看以下代码，使用final修饰创建的对象sup之后，就无法再创建新的对象

class SuperClass{
	public String name = "初始值";
}
class FianlDemo 
{
	public static void main(String[] args) {

		final SuperClass sup = new SuperClass();
		sup = new SuperClass(); // 编译报错
	}
}
1
2
3
4
5
6
7
8
9
10
11

---------- 编译java ----------
FianlDemo.java:10: 错误: 无法为最终变量sup分配值
		sup = new SuperClass();
		^
1 个错误

输出完成 (耗时 0 秒) - 正常终止
1
2
3
4
5
6
7

这说明：

final修饰基本类型变量：表示该变量的值不能改变，即不能用“=”号重新赋值。

final修饰引用类型变量：表示该变量的引用的地址不能变，而不是引用地址里的内容不能变。（引用地址中的内容可以改变）

2. final是唯一可以修饰局部变量的修饰符，目的何在?

期待局部内部类，局部内部类只能访问final修饰的局部变量

什么时候使用常量？

当在程序中，多个地方使用到共同的数据，且该数据不会改变，此时我们专门定义全局的常量，一般的,我们在开发中会专门定义一个常量类，专门用来存储常量数据，如下代码：

class{
	public static final int X_SIZE = 100;
	public stativ final int Y_SIZE = 200;
	........
}
1
2
3
4
5