Java 修饰符
Java 修饰符是用来控制类、变量、方法和构造函数的访问权限和行为的特殊关键字。
✅ Java 修饰符主要分为两类:
- 访问修饰符(Access Modifiers)
- 非访问修饰符(Non-Access Modifiers)
下面是包含类、变量、方法和构造函数的Person
类,展示了各种修饰符的合理使用:
public class Person { // public类 - 任何其他类都能访问
private String name; // private变量 - 只能在本类中使用
private int age;
public Person(String name, int age) { // public构造方法 - 所有类都能使用
this.name = name;
this.age = age;
}
protected void celebrateBirthday() { // protected方法 - 只能被本类、子类和同包类使用
System.out.println(name + "过生日啦!现在年龄:" + age);
}
public void introduce() { // public方法 - 所有类都能使用
System.out.println("大家好,我是" + name + ",今年" + age + "岁");
}
}
访问修饰符 (Access Modifiers)
✅ 控制访问级别的修饰符:
public
:对所有类可见。适用场景:类、方法、变量、构造器。protected
:对同一包内的类和所有子类可见。适用场景:变量、方法。注意:不能修饰类(Class)default
:仅对同一包(package)内的类可见,不使用任何修饰符。适用场景:类、变量、方法构造器。private
:仅对当前类可见。适用场景:变量、方法。注意:不能修饰类(Class)
✅ 访问修饰符权限一览表:
修饰符 | 当前类 | 同一包内 | 子类 | 其他包 |
---|---|---|---|---|
public | ✓ | ✓ | ✓ | ✓ |
protected | ✓ | ✓ | ✓ | ✗ |
default | ✓ | ✓ | ✗ | ✗ |
private | ✓ | ✗ | ✗ | ✗ |
1. 公有访问修饰符(public)
在面向对象编程中,public
是最开放的访问修饰符,它表示被修饰的成员(属性、方法、类等)可以被任何其他代码访问,无论这些代码是否在同一个类、同一个包或不同的包中。
这种公有访问修饰符通常将类提供给外部使用的接口方法中。
✅ 如下例所示,使用了公有访问控制修饰符:
public class MyClass {
public int publicField; // 公有字段
public void publicMethod() { // 公有方法
System.out.println("这是一个公有方法");
}
}
2. 受保护的访问修饰符(protected)
protected
是面向对象编程中的一种访问控制修饰符,它提供了比private
更宽松但比public
更严格的访问权限。
这种受保护的访问修饰符可以被类的成员函数访问,也可以被派生类成员函数访问。
✅ 如下例所示,使用了受保护的访问控制修饰符:
// 基类
class Parent {
protected int protectedValue = 10; // protected变量
protected void showValue() { // protected方法
System.out.println("父类的值: " + protectedValue);
}
}
// 派生类
class Child extends Parent {
public void changeValue() {
protectedValue = 20; // 可以访问父类的protected变量
System.out.println("修改后的值: " + protectedValue);
}
public void callParentMethod() {
showValue(); // 可以调用父类的protected方法
}
}
// 测试类
public class Main {
public static void main(String[] args) {
Child child = new Child();
child.callParentMethod(); // 输出: 父类的值: 10
child.changeValue(); // 输出: 修改后的值: 20
child.callParentMethod(); // 输出: 父类的值: 20
// 下面这行会报错 - 类外不能直接访问protected成员
// child.protectedValue = 30; // 错误
// child.showValue(); // 错误
}
}
3. 默认访问修饰符
如果类、变量、方法或构造函数的定义中没有显式指定任何访问修饰符(如public
、protected
或private
),那么它们将默认具有包级私有(package-private)访问权限。
这种默认访问修饰符意味着这些成员只能被同一个包内的其他类访问,而不能被其他包中的类访问。
需要注意的是,对于类而言,如果没有指定访问修饰符,它只能是包级私有的或者是嵌套类(内部类);而顶层类(非嵌套类)要么是public
的,要么是包级私有的。
✅ 如下例所示,类、变量和方法的声明可以不使用任何修饰符:
// 文件1: Employee.java (包 com.company)
package com.company;
// 默认访问修饰符的类(仅当前包可见)
class Employee {
// 默认访问修饰符的变量(仅当前包可见)
String name;
int age;
// 默认访问修饰符的构造方法(仅当前包可见)
Employee(String name, int age) {
this.name = name;
this.age = age;
}
// 默认访问修饰符的方法(仅当前包可见)
void displayInfo() {
System.out.println("员工姓名: " + name + ", 年龄: " + age);
}
}
// 文件2: Main.java (包 com.company)
package com.company;
public class Main {
public static void main(String[] args) {
// 同包中可以访问默认修饰符的类、构造方法、变量和方法
Employee emp = new Employee("张三", 28);
emp.name = "李四"; // 可以访问默认修饰符的变量
emp.displayInfo(); // 可以调用默认修饰符的方法
}
}
以上实例中,Employee
类和它的成员变量name
、age
以及方法displayInfo()
都使用默认访问修饰符进行了定义。Main
类与Employee
类在同一包中(com.company
),因此可以访问Employee
类及其所有默认访问权限的成员变量和方法。
4. 私有访问修饰符(private)
private
是面向对象编程中的一种访问控制修饰符(access modifier),用于限制类成员的访问权限。
使用private
修饰的成员(字段、方法、内部类等)只能在声明它们的类内部访问,其他类(包括子类)都无法直接访问。
✅ 如下例所示,使用了私有访问修饰符:
public class Cat {
// private字段:只有本类能直接访问
private String secretName = "喵小黑";
// public方法:外部通过这个方法间接访问private字段
public String getSecretName() {
return secretName;
}
}
public class Test {
public static void main(String[] args) {
Cat cat = new Cat();
// System.out.println(cat.secretName); // 报错!private字段不能直接访问
System.out.println(cat.getSecretName()); // 正确:通过public方法访问
}
}
非访问修饰符 (Non-Access Modifiers)
非访问修饰符是用来控制类、方法、变量等行为的修饰符,它们不控制访问权限,而是提供其他方面的控制。
✅ 提供其他功能的修饰符:
修饰符 | 应用目标 | 作用说明 |
---|---|---|
static |
变量/方法 | 表示类成员(变量或方法)属于类本身,而不是类的实例 |
final |
类 | 不能被继承 |
方法 | 不能被子类重写 | |
变量 | 值不能被修改(常量) | |
abstract |
类 | 不能实例化,可能包含抽象方法 |
方法 | 没有实现,必须在子类中实现 | |
synchronized |
方法 | 表示方法在同一时间只能被一个线程访问 |
transient |
变量 | 表示变量不应被序列化 |
volatile |
变量 | 表示变量可能被多个线程同时修改 |
native |
方法 | 表示方法是用非Java代码实现的 |
strictfp |
类/方法 | 表示类或方法使用严格的浮点计算规则 |
1. static 修饰符
static
表示 "静态的",用于修饰静态变量、静态方法,使其成为类成员而非实例成员。
类成员(static 成员)解决了成员数据共享、不依赖实例的操作、类级别初始化和配置和内存效率考虑等问题。
类成员(static 成员)与实例成员的关键区别:
特性 | 类成员(static) | 实例成员 |
---|---|---|
内存分配 | 类加载时分配,所有实例共享一份 | 每个实例单独一份 |
访问方式 | 通过类名直接访问 | 通过对象实例访问 |
生命周期 | 与类相同 | 与对象实例相同 |
能否访问实例成员 | 不能直接访问 | 可以 |
能否访问类成员 | 可以 | 可以 |
典型用途 | 共享数据、工具方法、常量等 | 对象特有的状态和行为 |
✅ 以下是定义了静态变量(类变量)和静态方法的实例代码:
public class Counter {
// 静态变量(类变量)
static int count = 0; // 所有对象共享
// 静态方法
static void increment() {
count++; // 修改静态变量
}
public static void main(String[] args) {
Counter.increment(); // 直接通过类名调用静态方法
Counter.increment();
System.out.println("当前计数: " + Counter.count); // 输出: 当前计数: 2
}
}
2. final 修饰符
final
表示 "最终的",用于修饰变量、方法和类,使其成为不可修改的常量或不可继承的实体。
该修饰符确保了数据的不可变性约束、方法行为的稳定性保持以及类继承的精确控制。
✅ final
修饰符核心特性:
概念 | 说明 |
---|---|
变量不可变性 | 确保变量只能被赋值一次 |
方法保护 | 防止子类重写关键方法 |
类完整性 | 禁止类被继承,保持设计初衷 |
✅ 以下定义了final
的变量、方法和类的实例代码:
// 1. final类 - 不能被继承
final class MyFinalClass {
// 2. final变量 - 常量
final int CONSTANT = 100;
static final double PI = 3.14159;
// 3. final方法 - 不能被子类重写
final void showFinalMethod() {
System.out.println("Final方法,值: " + CONSTANT);
}
void showNormalMethod() {
System.out.println("普通方法,PI: " + PI);
}
}
public class FinalKeywordDemo {
public static void main(String[] args) {
MyFinalClass obj = new MyFinalClass();
// 使用final变量
System.out.println("常量值: " + obj.CONSTANT);
System.out.println("静态常量PI: " + MyFinalClass.PI);
// 调用方法
obj.showFinalMethod();
obj.showNormalMethod();
// final局部变量
final String message = "Hello, final!";
System.out.println(message);
}
}
其他的修饰符在这里就一一不介绍了,后续会在代码笔记栏目中陆续补全。
反馈提交成功
感谢您的反馈,我们将尽快处理您的反馈