Java 修饰符有哪些 详解

在Java中，修饰符（Modifiers）是用于修饰类、方法、变量、构造方法或其他程序元素的关键词。它们可以控制元素的访问权限、行为特性或生命周期。Java修饰符主要分为两大类：访问修饰符（Access Modifiers）和非访问修饰符（Non-Access Modifiers）。以下是Java修饰符的详细解析：

1. 访问修饰符（Access Modifiers）

访问修饰符用于控制类、方法、变量或构造方法的访问权限，即哪些其他类可以访问这些元素。Java提供了四种访问修饰符：

1.1 public（公共访问）

  • 作用范围：对所有类可见，无论是否在同一个包内或是否有继承关系。
  • 适用对象：类、方法、变量、构造方法。
  • 示例：
  public class PublicClass {
      public int publicVar = 10;

      public void publicMethod() {
          System.out.println("This is a public method.");
      }
  }

1.2 private（私有访问）

  • 作用范围：仅在定义它的类内可见，其他类无法访问。
  • 适用对象：方法、变量、构造方法（类不能是private，除非是嵌套类）。
  • 示例：
  public class PrivateExample {
      private int privateVar = 20;

      private void privateMethod() {
          System.out.println("This is a private method.");
      }
  }

1.3 protected（受保护访问）

  • 作用范围：
  • 对定义它的类可见。
  • 对同一包内的其他类可见。
  • 对不同包中的子类可见。
  • 适用对象：方法、变量、构造方法（类不能是protected，除非是嵌套类）。
  • 示例：
  public class Parent {
      protected int protectedVar = 30;

      protected void protectedMethod() {
          System.out.println("This is a protected method.");
      }
  }

  // 不同包中的子类
  package other.package;
  public class Child extends Parent {
      public void accessProtected() {
          System.out.println(protectedVar); // 可以访问
          protectedMethod(); // 可以调用
      }
  }

1.4 默认（无修饰符，包级私有）

  • 作用范围：仅在定义它的包内可见，其他包中的类无法访问。
  • 适用对象：类、方法、变量、构造方法。
  • 示例：
  // 在同一个包内
  class DefaultClass {
      int defaultVar = 40;

      void defaultMethod() {
          System.out.println("This is a default method.");
      }
  }

访问修饰符的访问权限总结表

修饰符当前类同一包子类（不同包）其他包
public✔️✔️✔️✔️
protected✔️✔️✔️❌
默认（无）✔️✔️❌❌
private✔️❌❌❌

2. 非访问修饰符（Non-Access Modifiers）

非访问修饰符不控制访问权限，而是控制类、方法、变量或构造方法的其他特性，如是否可以继承、是否可以重写、是否是最终值等。Java提供了多种非访问修饰符，以下是常用的几种：

2.1 static（静态修饰符）

  • 作用：
  • 用于类成员（方法、变量、代码块、嵌套类），表示该成员属于类本身，而不是类的实例。
  • 静态变量：所有实例共享同一份值。
  • 静态方法：可以通过类名直接调用，无需创建对象。
  • 示例：
  public class StaticExample {
      static int staticVar = 100; // 静态变量

      static void staticMethod() { // 静态方法
          System.out.println("This is a static method.");
      }

      public static void main(String[] args) {
          StaticExample.staticMethod(); // 通过类名调用
          System.out.println(StaticExample.staticVar); // 通过类名访问
      }
  }

2.2 final（最终修饰符）

  • 作用：
  • 用于类：表示该类不能被继承。
  • 用于方法：表示该方法不能被子类重写。
  • 用于变量：表示该变量是常量，一旦赋值就不能再修改。
  • 示例：
  final class FinalClass { // 最终类，不能被继承
      final int FINAL_VAR = 10; // 最终变量，值不可变

      final void finalMethod() { // 最终方法，不能被重写
          System.out.println("This is a final method.");
      }
  }

2.3 abstract（抽象修饰符）

  • 作用：
  • 用于类：表示该类是抽象类，不能被实例化，只能被继承。
  • 用于方法：表示该方法没有实现（只有声明），子类必须实现该方法。
  • 示例：
  abstract class AbstractClass { // 抽象类
      abstract void abstractMethod(); // 抽象方法
  }

  public class ConcreteClass extends AbstractClass {
      @Override
      void abstractMethod() { // 必须实现抽象方法
          System.out.println("Implemented abstract method.");
      }
  }

2.4 synchronized（同步修饰符）

  • 作用：
  • 用于方法或代码块，表示该方法或代码块在同一时间只能被一个线程访问，用于线程同步。
  • 示例：
  public class SynchronizedExample {
      public synchronized void synchronizedMethod() { // 同步方法
          System.out.println("This is a synchronized method.");
      }
  }

2.5 volatile（易变修饰符）

  • 作用：
  • 用于变量，表示该变量的值可能会被多个线程同时修改，每次访问时都从主内存中读取，而不是从线程的工作内存中读取。
  • 示例：
  public class VolatileExample {
      private volatile boolean flag = false; // 易变变量
  }

2.6 transient（瞬态修饰符）

  • 作用：
  • 用于变量，表示该变量不会被序列化。
  • 示例：
  import java.io.Serializable;

  public class TransientExample implements Serializable {
      private transient String transientVar; // 瞬态变量，不会被序列化
  }

2.7 native（本地修饰符）

  • 作用：
  • 用于方法，表示该方法是用本地代码（如C/C++）实现的，而不是Java代码。
  • 示例：
  public class NativeExample {
      public native void nativeMethod(); // 本地方法
  }

2.8 strictfp（严格浮点修饰符）

  • 作用：
  • 用于类或方法，表示在该类或方法中，浮点数的计算严格遵循IEEE 754标准，确保结果在所有平台上一致。
  • 示例：
  strictfp class StrictfpClass { // 严格浮点类
      strictfp void strictfpMethod() { // 严格浮点方法
          // 浮点计算
      }
  }

3. 修饰符的组合使用

  • 访问修饰符与非访问修饰符可以组合使用，但有一些限制：
  • 抽象方法不能是private、static或final，因为这些修饰符与抽象方法的特性冲突。
  • static方法不能是abstract，因为静态方法属于类，而抽象方法需要子类实现。
  • final类不能是abstract，因为最终类不能被继承，而抽象类必须被继承。

4. 示例代码总结

以下是一个综合使用修饰符的示例代码：

// 最终类，不能被继承
final class FinalClass {
    // 静态变量
    static int staticVar = 100;

    // 最终变量
    final int FINAL_VAR = 10;

    // 抽象方法（不能在最终类中定义，这里仅为示例说明修饰符冲突）
    // abstract void abstractMethod(); // 编译错误：抽象方法不能在最终类中

    // 同步方法
    public synchronized void synchronizedMethod() {
        System.out.println("This is a synchronized method.");
    }

    // 静态方法
    public static void staticMethod() {
        System.out.println("This is a static method.");
    }
}

// 抽象类
abstract class AbstractClass {
    // 抽象方法
    abstract void abstractMethod();

    // 最终方法
    final void finalMethod() {
        System.out.println("This is a final method.");
    }
}

// 具体类，继承抽象类
public class ConcreteClass extends AbstractClass {
    // 必须实现抽象方法
    @Override
    void abstractMethod() {
        System.out.println("Implemented abstract method.");
    }

    public static void main(String[] args) {
        // 访问静态变量和方法
        System.out.println(FinalClass.staticVar);
        FinalClass.staticMethod();

        // 创建具体类对象并调用方法
        ConcreteClass concrete = new ConcreteClass();
        concrete.abstractMethod();
        concrete.finalMethod();
    }
}

输出结果：

100
This is a static method.
Implemented abstract method.
This is a final method.

5. 总结

  • 访问修饰符：
  • public：对所有类可见。
  • private：仅在当前类内可见。
  • protected：对当前类、同一包和其他包的子类可见。
  • 默认（无修饰符）：仅在当前包内可见。
  • 非访问修饰符：
  • static：类级别的成员。
  • final：不可继承、不可重写、不可修改。
  • abstract：抽象类或抽象方法。
  • synchronized：线程同步。
  • volatile：线程间可见。
  • transient：不被序列化。
  • native：本地方法。
  • strictfp：严格浮点计算。
  • 修饰符组合：
  • 需遵循Java的修饰符规则，避免冲突（如final类不能是abstract）。

合理使用修饰符可以提高代码的安全性、可维护性和可扩展性。理解修饰符的作用和限制是Java编程的基础。

发表评论

您的电子邮箱地址不会被公开。 必填项已用*标注