final可以修饰非抽象类、非抽象类成员方法和变量。
（1）final类：不能被继承，没有子类，final类中的方法默认是final的；
（2）final方法：不能被子类的方法覆盖，但可以被继承；
（3）final成员变量：表示常量，只能被赋值一次，赋值后值不再改变；
（4）final不能用于修饰构造方法。
（父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final的）
1.final类
final类不能被继承，因此final类的成员方法没有机会被覆盖，默认是final的，在设计类的时候，如果这个类不需要有子类，类的实现细节不允许变动，并且确定这个类不会再被扩展，可以将这个类设置为final类。
2.final方法
如果一个类不允许子类覆盖某个方法，可以将这个方法设置为final方法。
将方法声明为final的原因主要有两个：
①将方法锁定：防止任何子类修改它的意义和实现；
②高效：编译器遇到调用final方法的时候，会转入内嵌机制，大大提高执行效率。
父类Test1.java
package EmployeeTest_4_2;
public class Test1
{
public static void main(String[] args)
{
}
public void f1()
{
System.out.println("父类的f1");
}
public final void f2()
{
System.out.println("父类的f2");
}
public void f3()
{
System.out.println("父类的f3");
}
public void f4()
{
System.out.println("父类的f4");
}
}
子类Test2.java
package EmployeeTest_4_2;
public class Test2 extends Test1
{
public void f1()
{
System.out.println("父类的f1方法被覆盖！");
}
//这种声明f2的方法会报错，因为在Test1中已经将f2方法声明为final
// public void f2()
// {
// System.out.println("父类的f2方法被覆盖！");
// }
public void f3()
{
System.out.println("父类的f3方法被覆盖！");
}
public static void main(String[] args)
{
Test2 t = new Test2();
t.f1();
t.f2();
t.f3();
t.f4();
}
}
输出的结果为：
父类的f1方法被覆盖！ 父类的f2 父类的f3方法被覆盖！ 父类的f4
由于父类中f2方法已经被声明为final，所以如果在子类Test2中重写f2方法的时候，会报错，这时候会提示将父类Test1中的f2方法声明为“非final”方法。
Exception in thread "main" java.lang.VerifyError: class EmployeeTest_4_2.Test2 overrides final method f2.()V at java.lang.ClassLoader.defineClass1(Native Method) at java.lang.ClassLoader.defineClass(Unknown Source) at java.security.SecureClassLoader.defineClass(Unknown Source) at java.net.URLClassLoader.defineClass(Unknown Source) at java.net.URLClassLoader.access$100(Unknown Source) at java.net.URLClassLoader$1.run(Unknown Source) at java.net.URLClassLoader$1.run(Unknown Source) at java.security.AccessController.doPrivileged(Native Method) at java.net.URLClassLoader.findClass(Unknown Source) at java.lang.ClassLoader.loadClass(Unknown Source) at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source) at java.lang.ClassLoader.loadClass(Unknown Source) at sun.launcher.LauncherHelper.checkAndLoadMain(Unknown Source)
3.final变量
用final修饰的成员变量表示常量，值一旦给定就无法改变。
总共可以修饰三种变量：静态变量、实例变量和局部变量。
final变量定义的时候，可以先声明，而不给初值，这中变量也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须被初始化。但是，final空白在final关键字final的使用上提供了更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同，却有保持其恒定不变的特征。
package EmployeeTest_4_2;
public class Test3
{
private final String s = "final变量";
private final int A = 100;
public final int B = 90;
public static final int C = 80;
public static final int D = 70;
public final int E;//final空白，必须在初始化对象的时候赋初值
public Test3(int x)
{
E = x;
}
public static void main(String[] args)
{
Test3 t = new Test3(2);
// t.A = 101;//final变量的值一旦给定就无法改变
// t.B = 91;
// t.C = 81;
// t.D = 71;
System.out.println(t.A);
System.out.println(t.B);
System.out.println(t.C); //不推荐用对象方式访问静态字段
System.out.println(t.D);
System.out.println(Test3.C);
System.out.println(Test3.D);
//System.out.println(Test3.E);//出错,因为E为final空白,依据不同对象值有所不同.
System.out.println(t.E);
Test3 t1 = new Test3(3);
System.out.println(t1.E);//final空白变量E依据对象的不同而不同
}
private void test()
{
System.out.println(new Test3(1).A);
System.out.println(Test3.C);
System.out.println(Test3.D);
}
public void test2()
{
final int a;//final空白,在需要的时候才赋值
final int b = 4;//局部常量--final用于局部变量的情形
final int c;//final空白,一直没有给赋值.
a = 3;
//a=4; 出错,已经给赋过值了.
//b=2; 出错,已经给赋过值了.
}
}
输出结果：
100
90
80
70
80
70
2
3
4. final参数
当函数参数为final类型的时候，可以读取使用该参数，但是无法修改该参数的值。
package EmployeeTest_4_2;
public class Test4
{
public static void main(String[] args)
{
new Test4().f1(1);
}
public void f1(final int i)
{
System.out.println(i);
}
}
总结：
1、final修饰类
final修饰的类不允许被继承。一个类不能既是final的，又是abstract的，因为抽象类的目的就是为了让子类去实现其中的方法，而final修饰的类不能被继承，所以产生了矛盾。
2、final修饰方法
final修饰方法，表示该方法不能被子类重写Override。
3、final修饰变量
final成员变量表示常量，只能被赋值一次，赋值后的值不能改变。
