2. 程式人生 > >java中final的意義

java中final的意義

阿新 • • 發佈：2018-11-15

轉載自 https://blog.csdn.net/hikvision_java_gyh/article/details/8964541

1、如果一個數據既是static又是final，那麼它會擁有一塊無法改變的儲存空間。

2、final data: 當final用於基本資料型別時，final讓其值(value)保持不變，但是當用於object reference時，final僅讓reference保持不變。也就是說當reference一旦被初始化用於代表某個物件時，便再也不能改變指向另一個物件，但物件本身的內容確實可以改變的。final對array的作用和對reference的作用一樣。參考以下例子：

public class Test1{
    private final int li_int=12;
    private final InClass inClass1=new InClass(5);
    private final InClass inClass2=new InClass(8);
    public void modifiedFinal(int a){
    //下面語句出現編譯錯誤，不能修改final基本型別的值
    //li_int = a; 
    //下面語句出現編譯錯誤，不能將已經初始化的final變數指向另一個物件
    //inClass1=inClass2;
    //下面語句成功，雖然引用不能改變但final變數引用的物件本身內容是可以改變的
    inClass1.mod(a);
 }
 class InClass{
  int li_a=0;
  public InClass(int a){
   li_a=a; 
  } 
  public int mod(int b){
   li_a=b; 
   return li_a;
  }
 }
 public static void main(String args[]){
  Test1 test1=new Test1();
  test1.modifiedFinal(100);
  System.out.println(test1.inClass1.li_a);
 }
}

3、blank finals：java允許將資料成員宣告為final，卻不賦初值。但是，blank finals必須在使用之前初始化，且必須在建構函式中初始化。請參考以下例子：

public class Test2{
 //final變數一開始允許不賦值
 private final int li_int;
 public Test2(int a){
  //下面語句編譯通過，對定義為空的final變數的賦值必須在構造方法中進行，而且必須要賦值，不賦值也報錯
  li_int = a; 
 }
 public int mod(int a){
  //下面語句編譯出錯，對定義為空的final變數的賦值必須在構造方法中進行
  //li_int = a; 
  return li_int;
 } 
}

4、final arguments: 宣告arguments為final，可以保證該argument不能再被指向它處，當argment是基本資料型別時，就意味著值不能改變。參考以下例子：

public class Test3{
 private  int li_int=12;
 private  InClass inClass1=new InClass(5);
 private  InClass inClass2=new InClass(8);
 public void modifiedFinal(final int a,final InClass in){
  //下面語句出現編譯錯誤，不能修改final基本型別的值
  //a = 15; 
  //下面語句出現編譯錯誤，不能將已經初始化的final變數指向另一個物件
  //in=inClass2;
  //下面語句成功，雖然引用不能改變但final變數引用的物件本身內容是可以改變的
  in.mod(a);
 }
 class InClass{
  int li_a=0;
  public InClass(int a){
   li_a=a; 
  } 
  public int mod(int b){
   li_a=b; 
   return li_a;
  }
 }
 public static void main(String args[]){
  int a=100;
  //內部類初始化
  Test3 test3=new Test3();
  Test3.InClass in=test3.new InClass(30);
  System.out.println(in.li_a);
  test3.modifiedFinal(a,in);
  System.out.println(in.li_a);
 } 
}

5、final methods: 可以鎖住該method，不讓繼承類改變其意義（不允許子類覆寫）；允許編譯器對此method作為inline method呼叫。參考以下例子：

public class Test4{
 private final int li_int=0;
 public final int pub_fi_mod(){
  return li_int;
 }
 protected final int pro_fi_mod(){
  return li_int;
 } 
 private final int pri_fi_mod(){
  return  li_int; 
 }
 private int pri_mod(){
  return li_int; 
 }
}

public class Test5 extends Test4{
 private int li_i=100;
 //下面的方法編譯出錯，不能覆蓋final方法，只針對public和protected，子類中方法與父類中private的方法名相同不是覆蓋，與父類中同方法名的方法沒有任何關係（除了名字相同）。
 /*
 public int pub_fi_mod(){
  return li_i; 
 }
 protected int pro_fi_mod(){
  return li_i; 
 }*/
 private final int pri_fi_mod(){
  return  li_i; 
 }
 private int pri_mod(){
  return li_i; 
 }
 public static void main(String args[]){
  System.out.println(new Test5().pri_mod()); 
 }
}

6、fianl(method) vs private(method): class所有的private methods自然而然都是final，private methods僅僅是隱藏class中的某段程式程式碼而已，不能被overrid，即使子類中恰好有同名的method，也不會產生什麼效果;其中兩者的區別是在子類中可以出現與private方法有相同簽名的方法，而public或protected的final方法不能被重寫，但允許方法名相同但引數列表不同的重構方法出現。借用以上例子，將Test5修改後編譯通過：

public class Test5 extends Test4{
 private int li_i=100;
 //下面的方法編譯出錯，不能覆蓋final方法
 /*
 public int pub_fi_mod(){
  return li_i; 
 }
 protected int pro_fi_mod(){
  return li_i; 
 }
 */
 //但允許引數列表不同的重構方法出現
 public int pub_fi_mod(int a){
  return li_i; 
 }
 protected int pro_fi_mod(int a){
  return li_i; 
 }
 private final int pri_fi_mod(){
  return  li_i; 
 }
 private int pri_mod(){
  return li_i; 
 }
 public static void main(String args[]){
  System.out.println(new Test5().pri_mod()); 
 }
}

7、final classes: 當把一個class宣告為final時，也就決定了此class將不能被繼承（比如String類，此類為final類，具體可以參見其實現java.lang.String）。final classes的methods可以是final，也可以是非final的；其中的資料成員可以是final的也可以不是，他們將服從final data的原則。參考以下例子：

public final class Test6{
 private final int li_int=0;
 public int li_a=123;
 public final int mod(){
  return li_int;
 } 
 public int pri_mod(){
  return li_a; 
 }
 public static void main(String args[]){
  System.out.println(new Test6().pri_mod()); 
 }
}

//Test6是final類，所以Test7不能繼承
public class Test7 extends Test6{
 private int li_int=0;
}

 

PS：從以上可以看出，final是將一個物件的地址不變，對基本型別的值保持不變（因為基本型別變數指向的實體地址存放value而物件變數指向的實體地址存放物件內容的地址）。

PS：以前讀書時老師說java中final定義常量，只說對了一半，對基本型別是對的，對String也是對的，因為String雖然是物件，但不會出現String變數地址不變而其內容發生改變的情況（String是一個整體不能只改變其中的一個字元），所以也是對的，但對其他的物件只能保持其引用地址不變不能保證其內容不變，所以是錯的。

再補充一些內容：

1、對final屬性在宣告時就賦值，而且賦的值是常量的話，那編譯器會將所有用到此屬性的地方都替換成常量，這個請參考下面的程式碼：

 

package com.xx.dryr.test1;

import java.lang.reflect.Field;

public class Test1Class1{

public final int x = 100;

public int f(Test1Class1 t1c11,Test1Class1 t1c12) throws Exception{

int i = t1c11.x;

System.out.println("i's value is "+i);

changeX(t1c11);

int j = t1c12.x;

System.out.println("j's value is "+j);

return j - i;

}

public static void changeX(Test1Class1 t1c1) throws Exception{

Class clazz = t1c1.getClass();

Field fieldX = clazz.getDeclaredField("x");

fieldX.setAccessible(true);

fieldX.setInt(t1c1, 300);

 

System.out.println("fieldX's vlaue is "+fieldX.getInt(t1c1));

}

public int test() throws Exception{

return f(this,this);

}

public static void main(String[] args) throws Exception{

Test1Class1 t1c1 = new Test1Class1();

System.out.println(t1c1.test());

}

}

執行結果是：

 

i's value is 100

fieldX's vlaue is 300

j's value is 100

0

雖然在changeX方法中，已經將x的值修改為300，但因為編譯時所有使用到x的地方都使用100替換了，所以在執行時再怎麼修改x的值都不會對使用到x的地方產生影響。

2、否則，對不是在編譯時確定final屬性值的情況下，final屬性的值是可以改變的。請參考如下程式碼，對上面的程式碼稍微做了修改，讓final屬性x在構造方法中初始化：

 

package com.xx.dryr.test1;

import java.lang.reflect.Field;

public class Test1Class1{

public final int x ;

public Test1Class1(){

x = 100;

}

public int f(Test1Class1 t1c11,Test1Class1 t1c12) throws Exception{

int i = t1c11.x;

System.out.println("i's value is "+i);

changeX(t1c11);

int j = t1c12.x;

System.out.println("j's value is "+j);

return j - i;

}

public static void changeX(Test1Class1 t1c1) throws Exception{

Class clazz = t1c1.getClass();

Field fieldX = clazz.getDeclaredField("x");

fieldX.setAccessible(true);

fieldX.setInt(t1c1, 300);

System.out.println("fieldX's vlaue is "+fieldX.getInt(t1c1));

}

public int test() throws Exception{

return f(this,this);

}

public static void main(String[] args) throws Exception{

Test1Class1 t1c1 = new Test1Class1();

System.out.println(t1c1.test());

}

}

執行結果是：

 

i's value is 100

fieldX's vlaue is 300

j's value is 300

200

從上面的例子中可見，final屬性的值還是可以被改變的，但只有在特殊情況下（沒有在編譯時被替換），使用特殊的方式（像反射這樣的方式），final屬性的值才可以被改變。所以說一般情況下說final屬性的值是不允許被修改的還是可以說的，但必須得知道這些例外情況的。

相關推薦

java中final的意義

轉載自 https://blog.csdn.net/hikvision_java_gyh/article/details/8964541 1、如果一個數據既是static又是final，那麼它會擁有一塊無法改變的儲存空間。 2、final data: 當final用於基本資料型別時

java中final的作用

end 聯調 之前 ++ 遇到 編譯器 final類 執行 nbsp 1.修飾基礎數據成員的final: 這是final的主要用途，其含義相當於C/C++的const，即該成員被修飾為常量，意味著不可修改。如java.lang.Math類中的PI和E是final成員，其值為

java中final關鍵字

成員變量 子類 void color 需要 sta new 根據 基本用法 在Java中，final關鍵字可以用來修飾類、方法和變量（包括成員變量和局部變量）。下面就從這三個方面來了解一下final關鍵字的基本用法。 1.修飾類 　 當用final修飾一個類時，表明這個類

解析Java中final關鍵字的各種用法

col 後序 blog str 訪問 人類 依然 fin 可能 首先，我們可以從字面上理解一下final這個英文單詞的中文含義：“最後的，最終的; 決定性的; 不可更改的；”。顯然，final關鍵詞如果用中文來解釋，“不可更改的”更為合適。當你在編寫程序，可能

Java中final與 static final 修飾的常量的區別

評論 tin 產生 建立 dom code 隨機數 ren 使用 喵喵開車，新手上路，多多關照。有任何錯誤請在評論區指出。 ...........................................我是萬惡的分界線( ? ?ω?? )?.............

Java中final的用法總結

++ 標識符 ali 相同 即使 調用方法 理由 new 3.1 1. 修飾基礎數據成員的final 這是final的主要用途，其含義相當於C/C++的const，即該成員被修飾為常量，意味著不可修改。如java.lang.Math類中的PI和E是final

Java中Final修飾一個變數時，是引用不能變還是引用的物件不能變

Java中，使用Final修飾一個變數，是引用不能變，還是引用物件不能變？ 　　是引用物件的地址不能變，引用變數所指的物件的內容可以改變。 　　final變數永遠指向這個物件，是一個常量指標，而不是指向常量的指標。 　　比如： final StringBuffer sb=new Stri

java中final修飾方法傳入引數的含義

final型別修飾的引數分為兩種型別 基本型別 與引用型別  引數加final 1、斯坦福教授說的好，方法可以比喻成一臺機器(麵包機)，沒錯，在我的機器（方法）裡面，我要的引數加了final(要原料)，你給我傳過來的引數，機器裡面就無法改了，也就是說在機器裡的這個引數，一直指向的都

java中final關鍵字淺談

簡單隨筆 1. final關鍵字可以修飾類，表示此類不可被繼承，final類裡的成員方法隱飾final，final類裡的成員變數可以根據需要是否定義為final 2. final可以修飾方法，主要原因是防止此方法被子類修改，即子類可以繼承final方法但不能重寫（類的private方法會

Java中final finally finalize的區別

final、finally、finalize的區別 1、final修飾符（關鍵字）。被final修飾的類，就意味著不能再派生出新的子類，不能作為父類而被子類繼承。因此一個類不能既被abstract宣告，又被final宣告。將變數或方法宣告為final，可以保證他們在使用的過

Java中final關鍵字的使用

《Java程式設計思想》 final是Java的一個非訪問控制修飾符（non-access modifier），可以用於修飾變數、方法和類，有著“不可變”的作用。下面我們簡單看一下final有哪些用法。 1 final變數 當一個變數被final修飾時，它分為兩種情

Java中final修飾符(6.4)

final關鍵字可用於修飾類，變數和方法。當final修飾變數時，表示該變數一旦獲得初始值就不能重新被賦值。 1. final成員變數 對於final修飾的成員變數而言，一旦有了初始值，就不能被重賦值，如果既沒有在定義成員變數時指定初始值，也沒有在初始化塊，構造器中為成員變數指定初始值，

Java中final、finally、finalize的區別和用法

1.簡單區別 final用於宣告屬性，方法和類，分別表示屬性不可交變，方法不可覆蓋，類不可繼承。 finally是異常處理語句結構的一部分，表示總是執行。 finalize是Object類的一個方法，在垃圾收集器執行的時候會呼叫被回收物件的此方法，供垃圾收集時的其他資源回收，例

java中final關鍵字的使用及static final 和final的區別

java中final關鍵字可以用在類成員（是不是所謂的域），類的方法及類中。 一、final用在域中表示： 1，一個永不改變的編譯時常量。 2，一個在執行時被初始化的值，而你不希望它被改變。 static 關鍵字可以和final關鍵字結合使用，static強調只有一份，不管類被初始化多少次，static修

Java中final修飾符對不同變數的不同影響

final修飾符可以用來修飾類、方法和變數，用於表示它修飾的類、方法和變數不可改變。final修飾變數時，表示該變數一旦獲得了初始值就不可被改變。 由於final變數獲取初始值之後就不能重新賦值，所以final修飾成員變數和區域性變數時有一定程度的不同。 final

Java中final修飾符的初始化安全性的理解

今天看《Java併發程式設計實戰》看到安全釋出的問題中final修飾符的作用，一時半會沒有看明白，查了一些資料才懂了一些深層次的原因，所以做一些記錄。 首先我們來看一下書中的例子和描述 //不安全的釋出 public Holder holder; public void

java中final,finally,finalize三者的作用和區別

Final是一個修飾符： 當final修飾一個變數的時候，變數變成一個常量，它不能被二次賦值 當final修飾的變數為靜態變數（即由static修飾）時，必須在宣告這個變量的時候給它賦值 當final

Java中final、finally、finalize的區別

1.2 定義方法當final用來定義一個方法時，會有什麼效果呢？正如大家所知，它表示這個方法不可以被子類重寫，但是它這不影響它被子類繼承。我們寫段程式碼來驗證一下： Java程式碼public class ParentClass {     public final void TestFinal() { 

java中final關鍵字的編譯問題

之前我是沒有發現有這個噁心的問題的，從各種資料上看到final關鍵字的說明，都只是說此關鍵字是在程式中只允許賦值一次什麼的。而在正常的運用當中這個關鍵字基本上也不會發現什麼問題。 但是當我們把一個版本號用此關鍵字修飾的時候，問題就出現了。 我們在一個系統檔案（SystemV

java中final修飾符的使用方法

成員變數是隨類初始化或物件初始化的.當類初始化時,系統會為該類的類變數分配記憶體,並分配預設值;當建立物件時,系統會為該物件的例項變數分配記憶體,並分配預設值.也就是說.當執行靜態初始化塊時可以對類變數賦初始值;當執行普通初始化塊,構造時可對例項變數賦初始值.因此,成員變數的初始值可以在定義該變數時指定預