final 关键字

目录

1.基本介绍

2.final 使用注意事项和细节讨论

3.final应用实例

1.基本介绍

1. final中文意思:最后的,最终的.
2. final可以修饰类、属性、方法和局部变量
3. 在某些情况下,程序员可能有以下需求，就会使用到final:
   （1）当不希望类被继承时,可以用final修饰.【案例演示】
   （2）当不希望父类的某个方法被子类覆盖/重写(override)时,可以用final关键字修饰。【案例演示: 访问修饰符final返回类型方法名】
   （3）当不希望类的的某个属性的值被修改,可以用final修饰。【案例演示:; publicfinal double TAXRATE=0.08】
   （4）当不希望某个局部变量被修改，可以使用final修饰【案例演示: final doubleTAX RATE=0.08 】

代码:
public class Final01 {
public static void main(String[] args) {
E e = new E();
//e.TAX_RATE = 0.09;
}
}

//如果我们要求 A 类不能被其他类继承
//可以使用 final 修饰 A 类
final class A { }
	//class B extends A {}

class C {
	//如果我们要求 hi 不能被子类重写
	//可以使用 final 修饰 hi 方法
	public final void hi() {}
}

class D extends C {
	// @Override
	// public void hi() {
	// System.out.println("重写了 C 类的 hi 方法..");
	// }
}

//当不希望类的的某个属性的值被修改,可以用 final 修饰
class E {
	public final double TAX_RATE = 0.08;//常量
}

//当不希望某个局部变量被修改，可以使用 final 修饰
class F {
	public void cry() {
		//这时，NUM 也称为 局部常量
		final double NUM = 0.01;
		//NUM = 0.9;
		System.out.println("NUM=" + NUM);
	}
}

2.final 使用注意事项和细节讨论

1. final修饰的属性又叫常量,一般用XX_XX_XX来命名（字母全部大写，词与词之间用下划线隔开）
2. final修饰的属性在定义时,必须赋初值,并且以后不能再修改，赋值可以在如下位置之一【选择一个位置赋初值即可】:
   ①定义时:如public final double TAX_RATE=0.08;
   ②在构造器中
   ③在代码块中。
3. 如果final修饰的属性是静态的，则初始化的位置只能是
   ①定义时
   ②在静态代码块 不能在构造器中赋值。（因为构造器只会在创建实例的时候触发，而static在类加载的时候就要给值）
4. final类不能继承,但是可以实例化对象。[A2类]
5. 如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承。[A3类]
6. 一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法。（因为该类都无法被继承了，根本没有重写的机会）
7. final不能修饰构造方法(即构造器)
8. final和static往往搭配使用，效率更高，不会导致类加载.底层编译器做了优化处理。（如果静态的final属性在静态代码块中初始化，则通过类名访问此属性会导致类的加载）

class Demo{
    public static final int i=16; 
    static{
         System.out.println(“java教育~"); 
    }
}

    9.包装类(Integer,Double,Float,Boolean等都是final),String也是final类。

代码:
public class FinalDetail01 {
	public static void main(String[] args) {
		CC cc = new CC();
		new EE().cal();
	}
}

class AA {
	/*定义时：如 public final double TAX_RATE=0.08;在构造器中在代码块中
	*/
	public final double TAX_RATE = 0.08;//1.定义时赋值
	public final double TAX_RATE2 ;
	public final double TAX_RATE3 ;
	public AA() {//构造器中赋值
	TAX_RATE2 = 1.1;
	}
	{//在代码块赋值
	TAX_RATE3 = 8.8;
	}
	}
	class BB {
	/*
	如果 final 修饰的属性是静态的，则初始化的位置只能是
	1 定义时 2 在静态代码块 不能在构造器中赋值。
	*/
	public static final double TAX_RATE = 99.9;
	public static final double TAX_RATE2 ;
	
	static {
		TAX_RATE2 = 3.3;
	}
}

//final 类不能继承，但是可以实例化对象
final class CC { }
	//如果类不是 final 类，但是含有 final 方法，则该方法虽然不能重写，但是可以被继承
	//即，仍然遵守继承的机制.
 class DD {
	public final void cal() {
		System.out.println("cal()方法");
	}
}

class EE extends DD {}

代码:
public class FinalDetail02 {
	public static void main(String[] args) {
		System.out.println(BBB.num);
		//包装类,String 是 final 类，不能被继承
	}
}

//final 和 static 往往搭配使用，效率更高，不会导致类加载.底层编译器做了优化处理
class BBB {
	public final static int num = 10000;
		static {
		System.out.println("BBB 静态代码块被执行");
	}
}

final class AAA{
//一般来说，如果一个类已经是 final 类了，就没有必要再将方法修饰成 final 方法
//public final void cry() {}
}

3.final应用实例

题1：请编写一个程序，能够计算圆形的面积。要求圆周率为3.14。赋值的位置 3个方式都写一下.

代码:
public class FinalExercise01 {
	public static void main(String[] args) {
		Circle circle = new Circle(5.0);
		System.out.println("面积=" + circle.calArea());
	}
}

class Circle {
	private double radius;
	private final double PI;// = 3.14;
	//构造器
	public Circle(double radius) {
		this.radius = radius;
		//PI = 3.14;
	}

	{
		PI = 3.14;
	}

	public double calArea() {
		return PI * radius * radius;
	}
}

题 2：下面的代码是否有误，为什么?

public class Something {
	public int addOne(final int x) { 
		++x; //错误,原因是不能修改 final x 的值
		return x + 1; //这里是可以. 
	}
}