01_Java 修饰符
访问修饰符 public/protected/default/private，非访问修饰符 static/final/abstract/synchronized/transient/volatile
Java语言提供了很多修饰符，主要分为以下两类：
- 访问修饰符
- 非访问修饰符
修饰符用来定义类、方法或者变量，通常放在语句的最前端。我们通过下面的例子来说明：
public class ClassName {
// ...
}
private boolean myFlag;
static final double weeks = 9.5;
protected static final int BOXWIDTH = 42;
public static void main(String[] arguments) {
// 方法体
}
访问控制修饰符
Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。
-
default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
-
private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
-
public : 对所有类可见。使用对象：类、接口、变量、方法
-
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
我们可以通过以下表来说明访问权限：
| 修饰符 | 当前类 | 同一包内 | 子孙类(同一包) | 子孙类(不同包) | 其他包 |
|---|---|---|---|---|---|
public |
Y | Y | Y | Y | Y |
protected |
Y | Y | Y | Y/N | N |
default |
Y | Y | Y | N | N |
private |
Y | N | N | N | N |
默认访问修饰符——不使用任何关键字
如果在类、变量、方法或构造函数的定义中没有指定任何访问修饰符，那么它们就默认具有默认访问修饰符。
默认访问修饰符的访问级别是包级别（package-level），即只能被同一包中的其他类访问。
如下例所示，变量和方法的声明可以不使用任何修饰符。
实例
// MyClass.java
class MyClass { // 默认访问修饰符
int x = 10; // 默认访问修饰符
void display() { // 默认访问修饰符
System.out.println("Value of x is: " + x);
}
}
// MyOtherClass.java
class MyOtherClass {
public static void main(String[] args) {
MyClass obj = new MyClass();
obj.display(); // 访问 MyClass 中的默认访问修饰符变量和方法
}
}
以上实例中，MyClass 类和它的成员变量 x 和方法 display() 都使用默认访问修饰符进行了定义。MyOtherClass 类在同一包中，因此可以访问 MyClass 类和它的成员变量和方法。
私有访问修饰符——private
私有访问修饰符是最严格的访问级别，所以被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。
声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。
Private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。
下面的类使用了私有访问修饰符：
public class Logger {
private String format;
public String getFormat() {
return this.format;
}
public void setFormat(String format) {
this.format = format;
}
}
实例中，Logger 类中的 format 变量为私有变量，所以其他类不能直接得到和设置该变量的值。为了使其他类能够操作该变量，定义了两个 public 方法：getFormat()（返回 format 的值）和 setFormat(String)（设置 format 的值）。
公有访问修饰符——public
被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。
如果几个相互访问的 public 类分布在不同的包中，则需要导入相应 public 类所在的包。由于类的继承性，类所有的公有方法和变量都能被其子类继承。
以下函数使用了公有访问控制：
public static void main(String[] arguments) {
// ...
}
Java 程序的 main() 方法必须设置成公有的，否则，Java 解释器将不能运行该类。
受保护的访问修饰符——protected
protected 需要从以下两个点来分析说明：
-
子类与基类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；
-
子类与基类不在同一包中：那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的 protected 方法。
protected 可以修饰数据成员，构造方法，方法成员，不能修饰类（内部类除外）。
接口及接口的成员变量和成员方法不能声明为 protected。可以看看下图演示： ![[java-protected.gif]]
子类能访问 protected 修饰符声明的方法和变量，这样就能保护不相关的类使用这些方法和变量。
下面的父类使用了 protected 访问修饰符，子类重写了父类的 openSpeaker() 方法。
class AudioPlayer {
protected boolean openSpeaker(Speaker sp) {
// 实现细节
}
}
class StreamingAudioPlayer extends AudioPlayer {
protected boolean openSpeaker(Speaker sp) {
// 实现细节
}
}
如果把 openSpeaker() 方法声明为 private，那么除了 AudioPlayer 外，其他类将不能访问该方法。
如果把 openSpeaker() 声明为 public，那么所有的类都能够访问该方法。
如果我们只想让该方法对其所在类的子类可见，则将该方法声明为 protected。
protected 是最难理解的一种 Java 类成员访问权限修饰词，更多详细内容请查看 Java protected 关键字详解。
访问控制和继承
请注意以下方法继承的规则：
-
父类中声明为 public 的方法在子类中也必须为 public。
-
父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
-
父类中声明为 private 的方法，不能够被子类继承。
非访问修饰符
为了实现一些其他的功能，Java 也提供了许多非访问修饰符。
static 修饰符，用来修饰类方法和类变量。
final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
abstract 修饰符，用来创建抽象类和抽象方法。
synchronized 和 volatile 修饰符，主要用于线程的编程。
static 修饰符
static 的意思是「属于类的，而不属于某个对象」。被 static 修饰的变量或方法，不依赖于任何实例，直接用 类名.变量名 或 类名.方法名() 就能访问。
比喻： 班级里的「班费」是全班同学共有的，不属于某一个同学——这就是 static。
静态变量 vs 实例变量
class Student {
String name; // 实例变量：每个学生有自己的名字
static String school = "第一中学"; // 静态变量：所有学生共享同一个学校名
Student(String name) {
this.name = name;
}
}
// 使用：
Student s1 = new Student("小明");
Student s2 = new Student("小红");
System.out.println(s1.name); // 小明（每个对象自己的）
System.out.println(s2.name); // 小红（每个对象自己的）
System.out.println(Student.school); // 第一中学（所有对象共享，用类名访问）
静态方法
class Calculator {
// 静态方法：不需要创建对象就能用
static int add(int a, int b) {
return a + b;
}
}
// 使用：直接用类名调用
int result = Calculator.add(3, 5); // result = 8
注意：静态方法里不能直接使用实例变量
class Demo {
int x = 10; // 实例变量——属于对象
static int y = 20; // 静态变量——属于类
static void show() {
// System.out.println(x); // ❌ 错误！静态方法不能访问实例变量
System.out.println(y); // ✅ 正确！静态方法可以访问静态变量
}
}
final 修饰符
final 的意思是「最终的、不可改变的」。就好比你的身份证号，一旦确定就不能再改。
final 变量：一旦赋值，不能再修改
final double PI = 3.14159;
// PI = 3.14; // ❌ 错误！final 变量不能重新赋值
final String COUNTRY = "中国";
// COUNTRY = "美国"; // ❌ 错误！
配合 static 使用——定义常量
public class Config {
public static final int MAX_USERS = 100; // 常量：全大写，用下划线分隔
public static final String APP_NAME = "管理系统";
}
// 使用常量
int max = Config.MAX_USERS;
final 方法：子类不能重写
class Animal {
final void breathe() {
System.out.println("用肺呼吸");
}
}
class Dog extends Animal {
// void breathe() { // ❌ 错误！final 方法不能被子类重写
// System.out.println("用鳃呼吸");
// }
}
final 类：不能被继承
final class StringUtil {
// 工具类，不想让别人继承
}
// class MyStringUtil extends StringUtil { } // ❌ 错误！final 类不能被继承
abstract 修饰符
abstract 的意思是「抽象的、不完整的」。就像一个填空题的模板——只定义了题目，具体答案由子类来填。
一个完整的例子：「动物」模板
每种动物的叫声不同，所以先定义一个抽象的「叫」方法（只有名字，没有内容），然后让 Dog、Cat 各自去实现：
// 抽象类：不能直接 new，只能被继承
abstract class Animal {
String name;
Animal(String name) {
this.name = name;
}
// 抽象方法：只有声明，没有方法体（没有大括号）
abstract void makeSound();
// 普通方法：有具体实现，子类直接继承
void sleep() {
System.out.println(name + " 在睡觉");
}
}
// 子类必须实现所有抽象方法
class Dog extends Animal {
Dog(String name) { super(name); }
void makeSound() {
System.out.println(name + "：汪汪！");
}
}
class Cat extends Animal {
Cat(String name) { super(name); }
void makeSound() {
System.out.println(name + "：喵喵！");
}
}
// 测试：
public class Zoo {
public static void main(String[] args) {
// Animal a = new Animal(); // ❌ 错误！抽象类不能创建对象
Animal dog = new Dog("旺财");
Animal cat = new Cat("咪咪");
dog.makeSound(); // 旺财：汪汪！
cat.makeSound(); // 咪咪：喵喵！
dog.sleep(); // 旺财 在睡觉
cat.sleep(); // 咪咪 在睡觉
}
}
关键规则：
- 抽象类不能直接
new创建对象 - 子类必须实现父类的所有抽象方法（除非子类也是抽象类）
- 一个类只要有抽象方法，就必须声明为抽象类
abstract和final不能同时使用（矛盾：一个要继承，一个不让继承）
synchronized 修饰符
synchronized 的意思是「同步的」，用于多线程场景。可以理解为一把锁——同一时间只允许一个人进入房间。
比喻： 公共厕所只有一个坑位，谁先进去就锁门，其他人必须等。这就是 synchronized。
class TicketSeller {
private int tickets = 5; // 总共 5 张票
// synchronized = 加锁，同一时间只有一个线程能执行这个方法
synchronized void sellTicket(String buyer) {
if (tickets > 0) {
System.out.println(buyer + " 买到了第 " + tickets + " 张票");
tickets--;
} else {
System.out.println("票卖完了，" + buyer + " 没买到");
}
}
}
// 假设有三个窗口同时抢票：
public class TicketWindow {
public static void main(String[] args) {
TicketSeller seller = new TicketSeller();
// 三个线程 = 三个窗口同时抢票
new Thread(() -> seller.sellTicket("张三")).start();
new Thread(() -> seller.sellTicket("李四")).start();
new Thread(() -> seller.sellTicket("王五")).start();
}
}
/* 可能的输出（同一张票不会卖给两个人）：
张三 买到了第 5 张票
李四 买到了第 4 张票
王五 买到了第 3 张票
*/
transient 修饰符
transient 的意思是「瞬时的、不持久的」。当对象被序列化（保存到文件或网络传输）时，带有 transient 的字段会被跳过。
比喻： 你填一张表格交给别人，但表格上的「银行卡密码」不想让别人看到，就在这个字段前加上 transient。保存到文件时密码不会被存进去。
import java.io.*;
class User implements Serializable {
String username = "zhangsan"; // 会被保存
int age = 25; // 会被保存
transient String password = "123456"; // ⚠️ 不会被保存到文件
}
public class TestTransient {
public static void main(String[] args) throws Exception {
User user = new User();
// 保存到文件
ObjectOutputStream out = new ObjectOutputStream(
new FileOutputStream("user.txt"));
out.writeObject(user); // username 和 age 被保存，password 不保存
out.close();
// 从文件读取
ObjectInputStream in = new ObjectInputStream(
new FileInputStream("user.txt"));
User loaded = (User) in.readObject();
in.close();
System.out.println(loaded.username); // zhangsan ✅ 有值
System.out.println(loaded.password); // null ⚠️ transient 字段恢复为 null
}
}
volatile 修饰符
volatile 的意思是「易变的」。在多线程环境下，volatile 保证每次读取变量时都从主内存读取最新值，而不是从线程的本地缓存读。
比喻： 你在手机和电脑上同时登录微信，消息状态需要实时同步。不用 volatile 就好比手机上看已经撤回的消息，电脑上还能看到——数据不一致。volatile 保证所有地方看到的都是最新的。
class StopWatch {
// volatile：保证 running 的值变化时，所有线程立刻看到
private volatile boolean running = true;
// 线程 A：不停计数
void countUp() {
int count = 0;
while (running) { // 每次循环都从主内存读取最新值
count++;
}
System.out.println("计时结束，一共数了：" + count + " 次");
}
// 线程 B：叫停
void stop() {
running = false; // 修改后立刻写回主内存，线程 A 马上能看到
}
public static void main(String[] args) throws InterruptedException {
StopWatch watch = new StopWatch();
new Thread(watch::countUp).start(); // 线程 A 开始计数
Thread.sleep(100); // 让线程 A 数 0.1 秒
watch.stop(); // 线程 B 叫停
// 输出：计时结束，一共数了：xxxxx 次
}
}
注意： 上面的例子是简化版。由于 JIT 优化等原因，实际测试结果可能因环境而异，但 volatile 保证了逻辑上的正确性。
非访问修饰符速查表
| 修饰符 | 一句话解释 | 用在 |
|---|---|---|
static |
属于类，不属于对象 | 变量、方法 |
final |
不可改变 | 变量（常量）、方法（不可重写）、类（不可继承） |
abstract |
不完整，子类来补全 | 类、方法 |
synchronized |
加锁，一次只进一个线程 | 方法、代码块 |
transient |
序列化时跳过此字段 | 变量 |
volatile |
线程间可见，总读最新值 | 变量 |