Java 常用修飾符

Java 常用修飾符

有哪些常用修飾符

在 Java 中，修飾符（modifiers）用於修改類、方法、變數等的行為或屬性。以下是 Java 中常用的修飾符：

1. 訪問修飾符（Access Modifiers）：

   • public: 可以被任何類訪問。
   • protected: 可以被同一包內的類訪問，以及其子類（即使子類在不同的包中）。
   • default（不使用任何修飾符，也稱為包私有）: 只能被同一包內的類訪問。
   • private: 只能被同一類內部訪問。

2. 非訪問修飾符（Non-access Modifiers）：

   • static: 表示類成員（方法、變數）屬於類本身，而不是屬於例項。
   • final: 表示變數的值一旦被初始化後就不能再改變，方法一旦被宣告為 final，則該方法不能被子類重寫，類一旦被宣告為 final，則該類不能被繼承。
   • abstract: 用於類和方法。抽象類不能被例項化，方法宣告為抽象方法時，子類必須實現該方法。
   • synchronized: 用於方法或程式碼塊，確保在同一時刻最多隻有一個執行緒執行該方法或程式碼塊，以避免競態條件（race condition）。
   • volatile: 用於變數，表示該變數可能被多個執行緒同時訪問，因此不會被快取到執行緒工作記憶體中。
   • transient: 用於變數，表示該變數不參與序列化過程，即在物件序列化時，該變數的值不會被儲存。
   • native: 表示方法在原生代碼中實現，通常與 JNI（Java Native Interface）一起使用。
   • strictfp: 用於類、介面、方法，表示使用嚴格的浮點計算規則。

以上是 Java 中常用的修飾符，它們可以用於不同的場景來改變類、方法、變數的行為和屬性。

常用修飾符詳細說明

訪問修飾符

在 Java 中，public、private、static 和 final 是四種不同的訪問修飾符和關鍵字，用於控制類、方法和變數的訪問許可權、行為和狀態。

1. public: public 是 Java 中最常見的訪問修飾符之一。它表示公共的，任何其他類都可以訪問 public 修飾的類、方法或變數。在物件導向程式設計中，public 關鍵字常用於宣告類的成員（方法和變數），使它們能夠被其他類使用。例如：

   public class MyClass {
       public void myMethod() {
           // 程式碼邏輯
       }
   }
   

   上面的示例中，myMethod()方法被宣告為 public，因此其他類可以訪問和呼叫這個方法。

2. protected: protected 修飾符用於指定成員的訪問範圍，可以被同一包內的類訪問，以及子類（即使子類在不同的包中）。protected 成員對於包外部的類是不可見的。通常用於提供對類的繼承的控制，允許子類訪問父類的成員。例如：

   public class MyClass {
       protected int myVariable;
   }
   

3. default (package-private): 沒有顯式修飾符的成員具有預設訪問修飾符，也稱為 package-private。它們只能被同一個包內的其他類訪問，對於包外部的類是不可見的。如果不指定訪問修飾符，預設就是 package-private。例如：

   class MyClass {
       int myVariable;
   }
   

4. private: private 是另一種訪問修飾符，它表示私有的。私有成員只能在宣告它們的類內部訪問，其他類無法直接訪問私有成員。private 關鍵字通常用於隱藏類的實現細節，提供封裝性，防止外部類直接訪問和修改類的內部狀態。例如：

   public class MyClass {
       private int myVariable;
   
       public void setMyVariable(int value) {
           myVariable = value;
       }
   
       public int getMyVariable() {
           return myVariable;
       }
   }
   

   在上面的示例中，myVariable 被宣告為 private，因此只能透過 setMyVariable()和 getMyVariable()方法間接訪問和修改。

非訪問修飾符

1. static: static 關鍵字用於宣告靜態成員，靜態成員屬於類而不是物件，因此可以直接透過類名訪問，無需例項化物件。靜態成員在記憶體中只有一份複製，所有例項共享。常用於定義工具類、常量等。例如：

   public class MyClass {
       public static int myStaticVariable;
   
       public static void myStaticMethod() {
           // 程式碼邏輯
       }
   }
   

   在上面的示例中，myStaticVariable 和 myStaticMethod()都是靜態的，可以透過 MyClass.myStaticVariable 和 MyClass.myStaticMethod()來訪問。

2. final: final 關鍵字用於宣告不可變的常量、方法和類。對於不可變的常量，它們的值在初始化後不能被修改。對於方法，final 表示方法不能被子類重寫。對於類，final 表示類不能被繼承。例如：

   public class MyClass {
       public static final int MY_CONSTANT = 10;
   
       public final void myFinalMethod() {
           // 程式碼邏輯
       }
   }
   

   在上面的示例中，MY_CONSTANT 被宣告為 final，其值不能被修改。同時，myFinalMethod()被宣告為 final，不能被子類重寫。

3. abstract: abstract 修飾符用於宣告抽象類和抽象方法。抽象類是不能被例項化的類，它通常包含至少一個抽象方法，而抽象方法是沒有方法體的方法，需要由子類實現。例如：

   public abstract class MyAbstractClass {
       public abstract void myAbstractMethod();
   }
   

4. synchronized: synchronized 關鍵字用於保護多個執行緒同時訪問共享資源時的一致性。當一個方法或一個程式碼塊被 synchronized 修飾時，它只允許一個執行緒訪問該方法或程式碼塊，其他執行緒則被阻塞，直到該執行緒執行完畢釋放鎖。

   class Counter {
       private int count = 0;
   
       // synchronized 方法
       public synchronized void increment() {
           count++;
       }
   
       // synchronized 程式碼塊
       public void decrement() {
           synchronized(this) {
               count--;
           }
       }
   
       public int getCount() {
           return count;
       }
   }
   

5. volatile: volatile 修飾符用於宣告變數是易變的，即可能被多個執行緒同時訪問和修改。使用 volatile 修飾的變數的值會被儲存在主記憶體中，而不是執行緒的本地記憶體中，這樣可以確保多個執行緒看到的是同一份最新的值。例如：

   public class MyThread extends Thread {
       private volatile boolean flag;
   
       public void run() {
           while (!flag) {
               // 程式碼邏輯
           }
       }
   
       public void stopThread() {
           flag = true;
       }
   }
   

6. transient: transient 修飾符用於指示變數不會被序列化。當物件被序列化時，被 transient 修飾的變數的值不會被儲存。這通常用於標記不需要持久化的敏感資料或臨時狀態。例如：

   public class MyClass implements Serializable {
       private transient int sensitiveData;
   }
   

7. native: native 關鍵字表示該方法的實現由本地非 Java 程式碼提供。這通常用於與本地系統庫進行互動，比如 C 或 C++程式碼。

   public class NativeExample {
       // 宣告本地方法
       public native void nativeMethod();
   
       // 載入動態連結庫
       static {
           System.loadLibrary("NativeLibrary");
       }
   
       public static void main(String[] args) {
           NativeExample example = new NativeExample();
           // 呼叫本地方法
           example.nativeMethod();
       }
   }
   

   在上面的示例中，nativeMethod() 是一個本地方法，其實現由本地庫提供。在呼叫該方法之前，需要載入包含該方法實現的本地庫。

8. native: strictfp 關鍵字用於確保浮點運算在不同平臺上的結果一致性。當一個類被宣告為 strictfp 時，該類中所有包含浮點運算的方法都會按照 IEEE 754 標準來執行，無論執行環境是否支援 IEEE 754 標準。

   public strictfp class StrictfpExample {
       public strictfp double calculate(double x, double y) {
           return x / y;
       }
   
       public static void main(String[] args) {
           StrictfpExample example = new StrictfpExample();
           double result = example.calculate(10.0, 3.0);
           System.out.println("Result: " + result);
       }
   }
   

   在上面的示例中，calculate() 方法中的浮點運算會嚴格按照 IEEE 754 標準來執行，即使在不同平臺上也會得到一致的結果。

這些修飾符可以根據需要組合使用，以實現更精細的控制和設計類、方法和變數的行為。