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 標準來執行，即使在不同平臺上也會得到一致的結果。

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