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 标准来执行，即使在不同平台上也会得到一致的结果。

这些修饰符可以根据需要组合使用，以实现更精细的控制和设计类、方法和变量的行为。