java中的final

一、final类不能被继承 ,如

public final class Test1 {}

public class Test2 extends Test1{}这里会报错

因此final类就没有子类， 在设计类时候，若是这个类不须要有子类，类的实现细节不容许改变，而且确信这个类不会被扩展，那么就设计为final类。

二、 final方法不容许子类覆盖，也就是说不容许子类去修改父类的方法
        使用final方法的缘由有二：
        第1、把方法锁定，防止任何继承类修改它的意义和实现。
        第2、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提升执行效率。
        例如：

package Test;

public class Test1 {
public static void main(String[] args) {
}
public void f1() {
    System.out.println("f1public");
}
//没法被子类覆盖的方法
public final void f2() {
    System.out.println("f2final");
}
public static void f3() {
    
    System.out.println("f3public static");
}
private void f4() {
    System.out.println("private");
}
}

 

package Test;

public class Test2 extends Test1 {
    
public void f1(){    
    System.out.println("Test1父类方法f1被子类覆盖!");
}
public static void main(String[] args) {
    Test2 t=new Test2();
    t.f1();    
    t.f2(); //调用从父类继承过来的final方法
    t.f3(); //调用从父类继承过来的方法
 //   t.f4(); //调用失败，没法从父类继承得到，这个会报错
}
}

输出：

Test1父类方法f1被子类覆盖!
f2final
f3public static

三、final常量

package Test;

public class Test3 {
    private final String S = "final实例变量S";
    private final int A = 100;
    public final int B = 90;

    public static final int C = 80;
    private static final int D = 70;
    

    public final int E; //final空白,必须在初始化对象的时候赋初值
   // public final static int F; //出错，必须赋初值
    
    public  static int F;
    
    private  static int G;
    
 public  static String  H;
    
    private  static String I;
    
    public Test3(int x) {
            E = x;
            System.out.println("x="+x);
            System.out.println("E="+E);
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
            Test3 t = new Test3(2);
            //t.A=101;    //出错,final变量的值一旦给定就没法改变
            //t.B=91; //出错,final变量的值一旦给定就没法改变
            //t.C=81; //出错,final变量的值一旦给定就没法改变
            //t.D=71; //出错,final变量的值一旦给定就没法改变

            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.F);//不推荐用对象方式访问静态字段
            System.out.println(t.G);//不推荐用对象方式访问静态字段
            System.out.println(Test3.F);
            System.out.println(Test3.G);
            System.out.println(t.H);//不推荐用对象方式访问静态字段
            System.out.println(t.I);//不推荐用对象方式访问静态字段
            System.out.println(Test3.H);
            System.out.println(Test3.I);

            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; 出错,已经给赋过值了.
    }
}

输出结果：

x=2
E=2
100
90
80
70
80
70
0
0
0
0
null
null
null
null
x=3
E=3
3

四、final参数
        当函数参数为final类型时，你能够读取使用该参数，可是没法改变该参数的值。

 

public class Test4 {
        public static void main(String[] args) {
                new Test4().f1(2);
        }

        public void f1(final int i) {
                //i++;    //i是final类型的,值不容许改变的.
                System.out.print(i);
        }
}

输出：2

 

五、 static和final一块用

对于变量，表示一旦给值就不可修改，而且经过类名能够访问。
        对于方法，表示不可覆盖，而且能够经过类名直接访问。

对于一些容器类型（好比，ArrayList、HashMap）的实例变量，不能够改变容器变量自己，但能够修改容器中存放的对象，这一点在编程中用到不少。

 

package Test;

import java.util.ArrayList;

public class TestStaticFinal {

    private static final String strStaticFinalVar = "aaa";
    private static String strStaticVar = null;
    private final  String strFinalVar = null;
    private static final int intStaticFinalVar = 0;
    private static final Integer integerStaticFinalVar = new Integer(8);
    private static final ArrayList<String> alStaticFinalVar = new ArrayList<String>();

    private   void test() {
            System.out.println("-------------值处理前----------\r\n");
            System.out.println("strStaticFinalVar=" + strStaticFinalVar + "\r\n");
            System.out.println("strStaticVar=" + strStaticVar + "\r\n");
            System.out.println("strFinalVar=" + strFinalVar + "\r\n");
            System.out.println("intStaticFinalVar=" + intStaticFinalVar + "\r\n");
            System.out.println("integerStaticFinalVar=" + integerStaticFinalVar + "\r\n");
            System.out.println("alStaticFinalVar=" + alStaticFinalVar + "\r\n");

            //strStaticFinalVar="哈哈哈哈";        //错误，final表示终态,不能够改变变量自己.
            strStaticVar = "哈哈哈哈";                //正确，static表示类变量,值能够改变.
            //strFinalVar="呵呵呵呵";                    //错误, final表示终态，在定义的时候就要初值（哪怕给个null），一旦给定后就不可再更改。
            //intStaticFinalVar=2;                        //错误, final表示终态，在定义的时候就要初值（哪怕给个null），一旦给定后就不可再更改。
            //integerStaticFinalVar=new Integer(8);            //错误, final表示终态，在定义的时候就要初值（哪怕给个null），一旦给定后就不可再更改。
            alStaticFinalVar.add("aaa");        //正确，容器变量自己没有变化，但存放内容发生了变化。这个规则是很是经常使用的，有不少用途。
            alStaticFinalVar.add("bbb");        //正确，容器变量自己没有变化，但存放内容发生了变化。这个规则是很是经常使用的，有不少用途。

            System.out.println("-------------值处理后----------\r\n");
            System.out.println("strStaticFinalVar=" + strStaticFinalVar + "\r\n");
            System.out.println("strStaticVar=" + strStaticVar + "\r\n");
            System.out.println("strFinalVar=" + strFinalVar + "\r\n");
            System.out.println("intStaticFinalVar=" + intStaticFinalVar + "\r\n");
            System.out.println("integerStaticFinalVar=" + integerStaticFinalVar + "\r\n");
            System.out.println("alStaticFinalVar=" + alStaticFinalVar + "\r\n");
    }

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

输出：

-------------值处理前----------

strStaticFinalVar=aaa

strStaticVar=null

strFinalVar=null

intStaticFinalVar=0

integerStaticFinalVar=8

alStaticFinalVar=[]

-------------值处理后----------

strStaticFinalVar=aaa

strStaticVar=哈哈哈哈

strFinalVar=null

intStaticFinalVar=0

integerStaticFinalVar=8

alStaticFinalVar=[aaa, bbb]