final修饰符：

知识点：

1、final关键字用于修饰类、变量和方法

2、有点类似C#里的 sealed 关键字，用于表示它修饰的方法、变量和类不可以再被改变

3、final修饰变量时，表示该变量一旦获取了初始值，就不可以再被改变

4、final可以修饰成员变量（包括类变量、实例变量），也可修饰局部变量、形参

5、有的书上说final修饰的变量不能被赋值，这是错误的，严格的说，fanal修饰的变量，一旦被赋值就不可再次赋值改变

6、因为final修饰的变量赋值后不可再被改变，所以final修饰的成员变量和局部变量有一些不同

一、final修饰成员变量：

1、成员变量是随类的初始化（类变量）或类对象实例的初始化（实例变量）而初始化的

2、当类初始化时，系统会为类变量分配内存，并赋初始值；当类对象初始化时，系统会为实例变量分配内存，并赋初始值

3、当执行类静态初始化块时，系统可以为类变量赋初始值，当执行类普通初始化块、构造器时，系统可以为实例变量赋初始值

4、因此，成员变量可以在定义变量时赋初始值，也可以在静态初始化快、普通初始化块、构造器内给赋初始值

5、对于final修饰的成员变量而言，一旦有了初始值，就不可再次赋值

6、如果既没有在定义成员变量时赋初始值，也没有在初始化块、构造器中赋初始值，那么这些成员变量就失去了意义，因为不能在普通方法中为final修饰的成员变量赋值

7、因此Java规定，final修饰的成员变量必须由程序员显示的赋初始值

final修饰成员变量赋初始值归纳如下：

类变量：必须在静态初始化块中赋初始值，或在声明该类变量时赋初始值，而且只能在这两个地方其中一个进行

实例变量：必须在普通初始化块、声明该实例变量时、构造器中赋初始值，而且只能在这三个地方其中的一个进行

实例变量不能在静态初始化块中赋初始值，原因参上

类变量不能在普通初始化块、构造器中赋初始值，原因参上

代码示例：

public class FinalVariableTest{

	//-定义实例变量时赋初始值，合法
	public final int a=6;

	//-定义实例变量时，先不赋初始值，放在普通初始化块或构造器中赋初始值，合法
	public final String str;
	public final int c;

	//-定义类变量时，先不赋初始值，放到静态初始化块中赋初始值，合法
	public final static double d;

	//-定义实例变量，先不赋初始值，但是后面的普通初始化块、构造器中都没有赋初始值，不合法
	//public final char ch;

	static{
		//-静态初始化块内，给类变量赋初始值，合法
		d=5.5;
	}

	{
		//-普通初始化块内，给未付初始值的实例变量赋初始值，合法
		str="hello";

		//-普通初始化块内，给已经赋初始值的实例变量赋值，不合法
		//a=9;
	}

	public FinalVariableTest(){

		//-构造器内，对已经在普通初始化快内赋值的实例变量再次赋值，不合法
		//str="java";

		//-构造器内，给未赋初始值的实例变量赋初始值，合法
		c=5;
	}

	public void changFinal(){

		//-普通方法内，给final修饰符修饰过的成员变量赋值，违法
		//d=1.2;
		//ch='A';
	}

	public static void main(String[] args){
		FinalVariableTest fin=new FinalVariableTest();
		System.out.println(fin.a);
		System.out.println(fin.c);
		System.out.println(fin.d);
		System.out.println(fin.str);
	}
}

运行结果：

如果要在初始化块或构造器中给final成员变量赋初始值，则不能在初始化之前就访问该成员变量，否则会报错：

public class FinalErrorTest{

	//-定义一个final修饰的实例变量，未付初始值，合法
	//-而且系统不会为final修饰的变量赋初始值
	public final int age;

	{
		//-age实例变量未赋初始值，直接输出不合法，会报错
		//-如果把修饰符final去掉，则下面输出就合法了
		//System.out.println(age);

		//-在普通初始化块中，给未赋初始值的、final修饰的实例变量赋初始值，合法
		age=3;

		//-已经赋初始值，输出合法
		System.out.println(age);
	}

	public 	FinalErrorTest(){

	}

	public static void main(String[] args){
		FinalErrorTest fin=new FinalErrorTest();
	}
}

二、final修饰局部变量：

1、系统不会为局部变量进行初始化

2、局部变量必须由程序员显式初始化

3、final修饰的局部变量，可以在声明时赋初始值，也可以在后面赋值，但只能赋值一次。

4、final修饰的形参，不能被赋值、修改，因为形参是方法在调用的时候，根据传入的参数来完成初始化，所以不能再次赋值

代码示例：

public class FinalLocalVariableTest{
	public void test(final int a){
		//-final修饰的形参，不能被赋值、修改
		//-因为形参是方法在调用的时候，根据传入的参数来完成初始化，所以不能再次赋值,下面代码编译会报错
		//a=5;
	}

	public static void main(String[] args){
		final String str="hello";
		//-final 修饰的 str 变量声明时已经赋值，不能再次被赋值，下面代码编译会报错
		//str="java";

		final double b;
		b=3.6;

		//-final 修饰的 b 变量已经赋值，不能再次被赋值，下面代码编译会报错
		//b=6.5;
		System.out.println(str);
	}
}

运行结果：

final修饰基本类型变量，和引用类型变量的区别：

1、final修饰基本类型变量时，不能对基本类型变量重新赋值，因为基本类型变量不能被改变

2、对于引用类型变量而言，保存的仅仅是一个引用地址，final只是保证这个引用地址不被改变，而引用指向的对象完全可以改变

import java.util.Arrays;
class Penson{
	private int age;

	public Penson(){

	}

	public Penson(int age){
		this.age=age;
	}

	public void setAge(int age){
		this.age=age;
	}

	public int getAge(){
		return this.age;
	}
}

public class FinalReferenceVariable{
	public static void main(String[] args){
		//-final 修饰的 array 引用变量是一个数组
		final int[] array={5,69,8,6};

		//-输出数组
		System.out.println(Arrays.toString(array));

		//-给数组重新排序，没改变array引用的地址，还是指向这个数组对象，所以合法
		Arrays.sort(array);
		System.out.println(Arrays.toString(array));

		//-改变数组内的某个值，没改变array引用的地址，还是指向这个数组对象，所以合法
		array[2]=-8;
		System.out.println(Arrays.toString(array));

		//-改变了array引用变量的地址，所以非法，编译报错
		//array=null;

		//-final修饰的p对象，是一个Penson实例对象
		final Penson p=new Penson(23);

		//-修改了p对象中的age变量，但是p对象引用没改变，还是指向p对象，所以合法
		p.setAge(30);
		System.out.println(p.getAge());

		//-修改了p对象的引用地址，所以非法，编译报错
		//p=null;
	}
}

运行结果：

总结：final 修饰的引用变量不能被重新赋值，但是引用变量所指向的对象内容完全可以改变

可执行宏替换的 final 变量：

1、final修饰的变量，不管是类变量、实例变量、局部变量，只要满足3个条件，该变量就不再是一个变量，而是一个直接量：

　　.1、使用final 修饰符修饰

　　.2、定义该 final 变量时使用了初始值

　　.3、该初始值可以在编译时就确定下来

public class FinalLocalVariable{
	public static void main(String[] args){
		//-定义一个final局部变量 并赋初始值
		final int a=3;
		System.out.println(a);
	}
}

运行结果：

如上代码所示：对于这个程序来说，变量 a 根本不存在，当执行 System.out.println(a); 代码时，实际转换为执行：System.out.println(5);

由此产生了一个名字：宏变量：

1、final 修饰符的一个重要用途，就是定义 宏变量

2、当定义final变量的时候给定了初始值，并且该初始值在编译的时候就能确定下来，该变量实质上就是一个 宏变量

3、编译器会把程序中所有用到该变量的地方，直接替换成该变量的值

宏变量 的另一种情况：

public class FinalReplaceVariable{
	public static void main(String[] args){
		//-定义了 4个 final 局部变量,都是 宏变量
		final int a=3+5;
		final double b=1.5/3;
		final String str1="张三"+"李四";
		final String str2="张三"+"李四"+99.0;

		//-final 修饰的 局部变量 str3 因为调用了方法，无法在编译的时候 把值确定下来 所以不是宏变量
		final String str3=str1+	String.valueOf(99.0);

		System.out.println(str1=="张三李四");
		System.out.println(str2=="张三李四99.0");
		System.out.println(str3=="张三李四99.0");

	}
}

如上代码所示：

1、final变量赋值，如果被赋值的表达式只是基本的算术表达式，或基本的字符串连接运算，没有访问普通变量、调用方法，JVM在编译时依然可以把值确定下来，该变量依然可以当做 宏变量

2、当做宏变量的变量，在参与运算时，将直接用后面的值来代替 宏变量，关于这一点，原理其实就是 java 的常量池

宏替换：

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

		String a="张三李四";
		String b="张三"+"李四";

		String c="张三";
		String d="李四";

		//-将字符串直接量 c、d 进行连接运算
		//-e变量的值，无法在编译时就确定下来，所以变量e无法指向常量池中缓存的 字符串直接量
		String e=c+d;

		//-true
		System.out.println(a==b);
		//-false
		System.out.println(a==e);
	}
}

运行结果：

如上代码所示：

1、在编译时值就能确定下来的 变量，可以直接指向常量池中缓存的直接量，指向常量池缓存中同一个直接量的变量，程序可以执行 宏替换， 是相等的

2、在编译阶段值无法确定下来的变量，不可以共享常量池中缓存的直接量，程序不能执行 宏替换， 不能判断相等

3、让上面代码中 a与e相等，只需要把 c和d定义为final变量，使他们称为 宏变量，这样在编译阶段，系统将会执行 宏替换，把c和d都替换成常量池缓存中对应值，所以在编译阶段e的值就能确定下来

修改后代码如下：

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

		//-定义两个普通字符串直接量，编译时值就能确定下来
		String a="张三李四";
		String b="张三"+"李四";

		//-定义两个final 宏变量，在用到 这两个宏变量的地方，可以直接执行 宏替换
		final String c="张三";
		final String d="李四";

		//-e变量的值，在编译时就能确定下来，因为c和d是宏变量，编译时就可以执行 宏替换
		String e=c+d;

		//-true
		System.out.println(a==b);
		//-true
		System.out.println(a==e);
	}
}

运行结果：

总结：

1、对于实例变量而言，在声明时、普通初始化块中、构造器中，这三个地方赋初始值是一样的

2、对于final 实例变量而言，只有在定义该变量时赋初始值，才有 宏变量 的效果

上面代码在做修改，体会宏变量的本质：

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

		//-定义两个普通字符串直接量，编译时值就能确定下来
		String a="张三李四";
		String b="张三"+"李四";

		//-定义两个final 局部变量，未付初始值，合法
		final String c;
		final String d;

		//-给两个final局部变量 赋初始值，合法
		c="张三";
		d="李四";

		//-e变量的值，在编译时不能确定下来，因为c和d不再是宏变量，编译时不可以执行 宏替换
		String e=c+d;

		//-true
		System.out.println(a==b);
		//-false
		System.out.println(a==e);
	}
}

运行效果：

称为宏变量的条件总结：

1、必须 final 修饰符修饰

2、必须在声明时就赋初始值

3、必须在程序编译时，变量值就能确定下来

以上三个条件少一个，该变量就不是 宏变量 ，在后面的执行中，就不会执行宏替换

三、final修饰方法：

1、final修饰的方法不可被重写

2、如果不希望子类重写父类的某个方法，可以用 final 修饰该方法

3、Object类中的 getClass() 方法，就是 final 修饰的，不可被重写，toString()、equals()方法不是 final 修饰的，因此允许其子类 重写这两个方法

4、子类重写父类中 final 修饰的方法，编译会报错，如下代码就会编译报错：

class BaseClass{
	public final void test(){

	}
}

public class FinalMethodTest extends BaseClass{
	public void test(){

	}
}

编译时效果：

注意：

1、对于一个private方法，只在当前类中可见，子类中无法访问，所以子类也就无法重写该方法，这时如果子类中定义一个与父类private方法相同方法名、相同形参列表、相同返回类型的方法，这不算重写，只是子类自己新定义了一个方法而已

2、所以，即使使用 final 修饰了一个 private 的方法，其子类一样可以定义一个一样的方法，这不是重写，仅仅只是子类自己新定义的方法而已，如下代码：

class BaseClass{
	//-本类私有的，子类不可见，更不可重写
	private final void test(){
		System.out.println("BaseClass类的 test() 方法 ");
	}
}

public class PrivateFinalMethodTest extends BaseClass{

	//-不会报错，不是重写，只是本类自己定义的方法而已
	public void test(){
		System.out.println("PrivateFinalMethodTest类的 test() 方法，不是重写！ ");
	}

	public static void main(String[] args){
		new PrivateFinalMethodTest().test();
	}
}

运行结果：

5、final修饰的方法仅仅是不能被重写，但可以被重载，如下代码是合法的：

public class FinalOverloadMethod{
	public final void test(){

	}
	//-final修饰的方法，只是不能被重写，完全可以被重载
	public final void test(String str){

	}

	public static void main(String[] args){
		//-do sth
	}
}

四、final 修饰类：

1、final 修饰的类不可以有子类，java.lang.Math类就是 final 修饰的类，它不可以有子类

2、如果想保证某个类不被继承，可以用 final 修饰这个类

下面代码将会编译报错：

final class BaseClass{
	//-do sth
}

public class FinalOverrideClass extends BaseClass{
	//-do sth
}

编译结果：