finla变量，方法和类

  filnal修饰的方法不能被重写；

  final修饰在属性上，属性的值不能被改变。

  final修饰的类不能被继承。

   1.finla变量关键字可用于变量声明，一旦该变量被设定，就不可以再改变该变量的值，通常，有final定义的变量为常量。

          final关键字定义的变量必须在声明时对其进行赋值定义，final除了可以修饰基本数据类型的常量，还可以修饰对象引用，由于数组也可以被看成一个对象的引用，所以final可以修饰数组，一旦一个对象引用被修饰成final后，它只能恒定指向一个对象，无法将其改变指定另一个对象，一个既是static又是final的字段只占据一段不能改变的存储空间，以下面的例子深入了解final：

例：

 1 import static java.lang.System.*;
 2 import java.util.*;
 3 class Test {
 4     int i = 0;
 5 }
 6 
 7 public class FinalData {
 8     static Random rand = new Random();
 9     private final int VALUE_1 = 9; // 声明一个final常量
10     private static final int VALUE_2 = 10; // 声明一个final、static常量
11     private final Test test = new Test(); // 声明一个final引用
12     private Test test2 = new Test(); // 声明一个不是final的引用
13     private final int[] a = { 1, 2, 3, 4, 5, 6 }; // 声明一个定义为final的数组
14     private final int i4 = rand.nextInt(20);  //随机数
15     private static final int i5 = rand.nextInt(20);
16     
17     public String toString() {
18         return i4 + " " + i5 + " ";
19     }
20     
21     public static void main(String[] args) {
22         FinalData data = new FinalData();
23         // data.test=new Test();
24         //可以对指定为final的引用中的成员变量赋值
25         //但不能将定义为final的引用指向其他引用
26         // data.value2++;
27         //不能改变定义为final的常量值
28         data.test2 = new Test(); // 可以将没有定义为final的引用指向其他引用
29         for (int i = 0; i < data.a.length; i++) {
30             // a[i]=9;
31             // //不能对定义为final的数组赋值
32         }
33         out.println(data);
34         out.println("data2");
35         out.println(new FinalData());
36         // out.println(data);
37     }
38 }

运行结果：

8 3
data2
6 3

分析：

在本实例子中，被定义成final的常量定义时需要使用大写字母命名，并且中间使用下划线进行连接，这是Java中的编码规则，同时，定义为final的数据无论是常量，对象，还是数组，在主函数中都不可以被修改。一个被定义为final的对象引用只能指向唯一一个对象，不可以将它再指向其他对象，但是一个对象本身的值却是可以改变的，那么为了使一个常量真正做到不可以更改，可以将常量声明为staticfinal。为了验证这个理论，看以下实例子：

 1 import static java.lang.System.*;
 2 
 3 import java.util.*;
 4 
 5 public class FinalStaticData {
 6     private static Random rand = new Random(); // 实例化一个Random类对象
 7     // 随机产生0~10之间的随机数赋予定义为final的a1
 8     private final int a1 = rand.nextInt(10);
 9     // 随机产生0~10之间的随机数赋予定义为static final的a2
10     private static final int a2 = rand.nextInt(10);
11     
12     public static void main(String[] args) {
13         FinalStaticData fdata = new FinalStaticData(); // 实例化一个对象
14         // 调用定义为final的a1
15         out.println("重新实例化对象调用a1的值：" + fdata.a1);
16         // 调用定义为static final的a2
17         out.println("重新实例化对象调用a1的值：" + fdata.a2);
18         // 实例化另外一个对象
19         FinalStaticData fdata2 = new FinalStaticData();
20         out.println("重新实例化对象调用a1的值：" + fdata2.a1);
21         out.println("重新实例化对象调用a2的值：" + fdata2.a2);
22     }
23 }

运行结果：

重新实例化对象调用a1的值：4
重新实例化对象调用a1的值：1
重新实例化对象调用a1的值：5
重新实例化对象调用a2的值：1

从实例的结果可以看出，定义为final的常量是恒定不变的，将随机数赋值定义为final的常量，可以做到每次运行程序时改变a1的值，但a1与a2不同，由于他被声明为static final的形式，所以在内存中为a2开辟了一个恒定不变的区域，当再次实例化一个finalstaticdata对象时，仍然指向a2这块内存区域，所以a2的值保持不变，a2是在装载时被初始化，而不是每次创建新对象时度被初始化，而a1会在重新实例化对象时被更改。

2.final方法

   首先说明一点，f定义为inal的的方法不能被重写

  例：

 1 class Parents {
 2     private final void doit() {
 3         System.out.println("父类.doit()");
 4     }
 5     
 6     final void doit2() {
 7         System.out.println("父类.doit2()");
 8     }
 9     
10     public void doit3() {
11         System.out.println("父类.doit3()");
12     }
13 } 
14 
15 class Sub extends Parents {
16     public final void doit() { // 在子类中定义一个doit()方法
17         System.out.println("子类.doit()");
18     }
19 //    final void doit2(){        //final方法不能覆盖
20 //        System.out.println("子类.doit2()");
21 //    }
22     public void doit3() {
23         System.out.println("子类.doit3()");
24     }
25 }
26 
27 public class FinalMethod {
28     public static void main(String[] args) {
29         Sub s = new Sub(); // 实例化
30         s.doit(); // 调用doit()方法
31         Parents p = s; // 执行向上转型操作
32         // p.doit(); //不能调用private方法
33         p.doit2();
34         p.doit3();
35     }
36 }

运行结果：

子类.doit()
父类.doit2()
子类.doit3()

分析：

从上例子中可以看出，final方法不能被覆盖。例如doit2()方法不能再子类中被重写，但是在父类中定义了一个private final的doit（）方法，同时在子类中也定义了一个doit（）方法，从表面上看，子类中的doit（）方法覆盖了父类的doit（）方法，但必须满足一个对象向上转型为它的基本类型并调用相同方法这样一个条件，在例子中，对象p不能调用doit（）方法，可见，子类中的doit（）方法并不是正常覆盖，而是生成一个新的方法。

3.final类

  在这只说明一点：如果将某个类设置为final类，则类中的所有方法都被隐式设置为final形式，但是final类中的成员变量可以被定义为final或非final形式，并且，其值可以被改变。

转载于:https://www.cnblogs.com/xyzyj/p/6131827.html