异常教程

Java 修饰符（长文解析）

更新时间:

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

  • 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;
  • 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 82w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 2900+ 小伙伴加入学习 ，欢迎点击围观

前言

在 Java 开发中，修饰符（Modifiers）如同程序设计的“交通规则”，它们定义了代码元素（如类、方法、变量等）的可见性、行为限制或特殊属性。无论是初学者还是中级开发者，掌握这些规则都能显著提升代码的规范性、可维护性和安全性。本文将从基础到进阶，结合案例和比喻，系统解析 Java 修饰符的核心概念与应用场景。

一、访问控制修饰符：定义“可见性”的边界

访问控制修饰符决定了代码元素在不同包（Package）和类之间的可见性。Java 提供了四种核心修饰符：public、protected、default（包级私有）和 private。

1.1 公开的“高速公路”：public

  • 作用：声明的类、方法或变量对所有包和类可见。
  • 比喻：如同城市的主干道，所有人都可以自由访问。
  • 代码示例： 
    public class Car {  
    public void startEngine() {  
        System.out.println("Engine started!");  
    }  
}

    任何其他类（无论是否同包）均可直接调用 Car 类的 startEngine() 方法。

1.2 包内与继承的“双向车道”：protected

  • 作用：允许同包的类直接访问，跨包的子类可通过继承访问。
  • 比喻：如同小区内的道路，邻居可以直接使用，但外部人员需通过特定权限（继承关系）进入。
  • 代码示例： 
    class Vehicle {  
    protected void checkFuel() {  
        // 实现逻辑  
    }  
}  
class ElectricCar extends Vehicle {  
    void recharge() {  
        checkFuel();  // 子类可直接调用  
    }  
}

1.3 默认的“小区内部道路”：default（无显式修饰符）

  • 作用：仅在同包内可见，无需显式声明。
  • 比喻：如同仅限本小区居民通行的道路，外部无法直接访问。
  • 代码示例： 
    // 同一包中的类  
class Garage {  
    void maintainCar(Car car) {  
        car.startEngine();  // 可访问 public 方法  
        // car.checkFuel(); // 报错，因 Vehicle 的 checkFuel 是 protected  
    }  
}

1.4 完全私密的“私人车库”：private

  • 作用：仅限于声明它的类内部使用，完全隔离外部访问。
  • 比喻：如同私人车库，只有车主（类自身）能直接操作。
  • 代码示例： 
    public class BankAccount {  
    private double balance;  
    public void deposit(double amount) {  
        balance += amount;  // 允许类内部修改  
    }  
    // 通过方法间接访问私有变量  
    public double getBalance() {  
        return balance;  
    }  
}

二、类修饰符：定义类的“身份与规则”

Java 允许为类添加修饰符，以限定其行为或用途。常见修饰符包括 abstract、final、strictfp 和 public。

2.1 不可实例化的“蓝图”：abstract

  • 作用：声明抽象类，无法直接实例化，但可被继承。
  • 比喻：如同建筑蓝图，本身不能直接使用，但能指导子类构建具体结构。
  • 代码示例： 
    abstract class Animal {  
    abstract void makeSound();  // 抽象方法  
    public void eat() {  
        System.out.println("Eating...");  
    }  
}  
class Dog extends Animal {  
    void makeSound() {  
        System.out.println("Bark!");  
    }  
}

2.2 无法被继承的“终局”：final

  • 作用：禁止类被继承，确保其行为不可被修改。
  • 比喻：如同法律条文的“最终条款”，不可被推翻或更改。
  • 代码示例： 
    final class Constants {  
    public static final double PI = 3.14159;  
}  
// class MathExt extends Constants { ... } // 报错，无法继承

2.3 精确浮点运算的“标尺”：strictfp

  • 作用：强制类或方法使用严格的浮点运算规则（符合 IEEE 754 标准）。
  • 适用场景：跨平台计算需要统一结果时（如金融计算）。
  • 代码示例： 
    strictfp class Calculator {  
    double compute(double a, double b) {  
        return a / b;  // 确保运算规则一致  
    }  
}

三、方法修饰符：约束行为与增强功能

方法修饰符不仅限定了方法的可见性，还定义了其执行方式或特殊属性。常见修饰符包括 static、final、abstract、synchronized 等。

3.1 无需实例的“共享工具”：static

  • 作用：声明静态方法，可直接通过类名调用，无需创建实例。
  • 比喻：如同公共工具箱，所有人都可以直接使用，无需各自购买。
  • 代码示例： 
    public class MathUtils {  
    public static int add(int a, int b) {  
        return a + b;  
    }  
}  
// 调用：int result = MathUtils.add(3, 5);

3.2 无法被覆盖的“锁定方法”：final

  • 作用：禁止子类重写（Override）该方法。
  • 比喻：如同被焊死的门，子类无法修改其功能。
  • 代码示例： 
    class Parent {  
    final void lockMethod() {  
        System.out.println("This can't be overridden");  
    }  
}  
class Child extends Parent {  
    // void lockMethod() { ... } // 报错，无法覆盖  
}

3.3 线程安全的“交通灯”：synchronized

  • 作用：确保同一时间只有一个线程访问该方法，避免并发问题。
  • 比喻：如同十字路口的红绿灯，控制线程的有序通行。
  • 代码示例： 
    public class Counter {  
    private int count = 0;  
    public synchronized void increment() {  
        count++;  // 线程安全操作  
    }  
}

四、变量修饰符：定义数据的“属性与生命周期”

变量修饰符控制变量的存储方式、可变性或作用域。核心修饰符包括 final、volatile、transient 和 static。

4.1 不可更改的“常量”：final

  • 作用：声明不可修改的变量，通常用于常量定义。
  • 比喻：如同刻在石头上的文字，一旦写入不可更改。
  • 代码示例： 
    final int MAX_USERS = 100;  
// MAX_USERS = 200; // 报错，无法重新赋值

4.2 共享变量的“动态标记”：volatile

  • 作用：确保变量的修改对所有线程可见，避免缓存一致性问题。
  • 适用场景：多线程环境下共享变量的同步。
  • 代码示例： 
    class SharedResource {  
    volatile boolean isRunning = true;  
}

4.3 序列化时的“隐形标记”：transient

  • 作用：标记变量在序列化时被忽略，避免敏感数据被持久化。
  • 比喻：如同文件中的隐藏字段，不参与数据保存。
  • 代码示例： 
    class User {  
    transient String password;  // 序列化时排除密码  
    String username;  
}

五、综合案例：修饰符的协同应用

以下案例演示了如何结合多种修饰符设计一个“银行账户”系统：

// final 类禁止继承，确保行为固定  
final class BankAccount {  
    // private 变量仅类内部可访问  
    private double balance;  

    // static 方法直接通过类调用  
    public static void displayRules() {  
        System.out.println("No overdraft allowed!");  
    }  

    // synchronized 方法保证线程安全  
    public synchronized void withdraw(double amount) {  
        if (balance >= amount) {  
            balance -= amount;  
        } else {  
            System.out.println("Insufficient funds!");  
        }  
    }  

    // final 方法禁止子类覆盖  
    final public void setBalance(double newBalance) {  
        if (newBalance >= 0) {  
            balance = newBalance;  
        }  
    }  
}

结论

Java 修饰符是构建健壮代码的基石，它们通过定义可见性、行为约束和数据属性，帮助开发者实现模块化、安全性与可维护性。无论是初学者理解访问控制，还是中级开发者设计复杂系统，掌握修饰符的规则与最佳实践都至关重要。建议读者通过实际编码练习，逐步体会修饰符在不同场景中的应用价值，并养成“修饰符先行”的编码习惯。

通过本文的系统解析，希望读者能够建立起对 Java 修饰符的完整认知框架，并在后续开发中灵活运用这些规则，提升代码的质量与可靠性。

最新发布

查看更多文章