Java 常用修飾符

飞仔FeiZai發表於2024-03-19

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

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

相關文章