数据结构
网络
关系数据库管理系统 (RDBMS)
操作系统
Java
MS Excel
iOS
HTML
CSS
Android
Python
C 编程
C++
C#
MongoDB
MySQL
Javascript
PHP
物理学
化学
生物学
数学
英语
经济学
心理学
社会学
服装设计
法学Java 中的 private、protected 和 final 访问修饰符
每当我们声明一个类时，都需要提供它的访问级别，以便 JVM 可以知道程序中是否可以发生继承或实例化，以及类的作用域是什么。为此，我们使用访问修饰符，这些修饰符可以用于类、方法和变量等。
private 访问修饰符将方法或变量的访问限制在类内；这意味着只能在同一个类中访问该方法或变量。
protected 访问修饰符允许访问该类及其任何子类，包括其他包中的类。
final 访问修饰符不允许扩展类。如果应用于方法，则子类不能覆盖它。如果声明一个变量为 final，则在初始化后不能对其重新赋值。
算法
要实现 private、protected 和 final 访问修饰符，请按照以下步骤操作：
步骤 1 − 定义一个类及其成员，即方法和变量。
步骤 2 − 要将变量或方法声明为 private，请使用 private 关键字作为访问修饰符。
步骤 3 − 要将变量或方法声明为 protected，请使用 protected 关键字作为访问修饰符。
步骤 4 − 使用 final 关键字定义变量为 final。
步骤 5 − 现在，同一个类的成员可以访问 private 变量或方法。
步骤 6 − 同一个类或子类的方法可以访问 protected 变量或方法。
步骤 7 − 要在类外部访问 private 和 protected 变量，可以使用访问这些变量的 public 方法。
步骤 8 − 访问 private 和 protected 变量的方法应声明为 public。
步骤 9 − 要创建可在类内访问的常量，请同时使用 private 和 final 关键字。
步骤 10 − 要创建可在类和子类中访问的常量，请同时使用 protected 和 final 关键字。
语法
public class Way2Class {
private int privateVariable;
protected int protectedVariable;
final int finalVariable = 5;
private void privateMethod() {
// method implementation
}
protected void protectedMethod() {
// method implementation
}
}
方法 1：使用 private 访问修饰符
代码片段如下
示例
public class Main {
private String name;
private int age;
public Main(String name, int age) {
this.name = name;
this.age = age;
}
private String getDetails() {
return "Name: " + name + ", Age: " + age;
}
public void displayDetails() {
String details = getDetails();
System.out.println(details);
}
public static void main(String[] args) {
Main john = new Main("John", 30);
john.displayDetails(); // prints "Name: John, Age: 30"
String details = john.getDetails(); // Accessing private method, results in a compile-time error
String name = john.name; // Accessing private field, results in a compile-time error
int age = john.age; // Accessing private field, results in a compile-time error
}
}
输出
Name: John, Age: 30
解释
在上面的程序中，如果我们在 Employee 类外部调用 getDetails() 方法和 private 变量，则会得到编译时错误。
方法 2：使用 protected 访问修饰符
代码示例如下
示例
public class Main {
public static void main(String[] args) {
Car honda = new Car("Honda", "Civic", 2022, 4);
honda.displayDetails();
}
}
class Vehicle {
protected String make;
protected String model;
protected int year;
public Vehicle(String make, String model, int year) {
this.make = make;
this.model = model;
this.year = year;
}
protected String getDetails() {
return "Make: " + make + ", Model: " + model + ", Year: " + year;
}
}
class Car extends Vehicle {
private int numDoors;
public Car(String make, String model, int year, int numDoors) {
super(make, model, year);
this.numDoors = numDoors;
}
public void displayDetails() {
String details = getDetails() + ", Number of Doors: " + numDoors;
System.out.println(details);
}
}
输出
Make: Honda, Model: Civic, Year: 2022, Number of Doors: 4
解释
以下代码执行没有错误，因为我们在同一个包、类和子类中访问 protected 变量和方法。
方法 3：使用 final 访问修饰符
示例
class Animal {
final String species;
public Animal(String species) {
this.species = species;
}
public void makeSound() {
System.out.println("The " + species + " makes a sound.");
}
}
class Cat extends Animal {
public Cat() {
super("Cat");
}
@Override
public void makeSound() {
System.out.println("Meow!");
}
}
public class Main {
public static void main(String[] args) {
Cat cat = new Cat();
cat.makeSound();
}
}
输出
Meow!
解释
Cat 类扩展 Animal 类，并且不添加任何新的实例变量，但是它试图用自己的实现覆盖 makeSound() 方法，该实现只是打印出“Mawo！”。但是，由于 Animal 类中的 makeSound() 方法被标记为 final，因此此尝试会导致编译时错误。
不同方法的比较
Private 修饰符 |
Protected 修饰符 |
Final 修饰符 |
|---|---|---|
成员可以在声明它们的同一个类中访问。 |
成员可以在同一个包中的类和子类中访问。 |
成员不能在同一个类或子类中访问。 |
接口可以使用此修饰符 |
接口可以使用此修饰符 |
接口不能使用此修饰符 |
Private 方法可以被覆盖 |
Protected 方法不能被覆盖 |
Final 方法不能被覆盖。 |
结论
Java 中的这些访问修饰符用于控制类成员（变量、方法和内部类）的可见性。Private 将访问限制在同一个类中，protected 允许访问子类和同一个包中的类，final 表示成员的值不能更改或方法不能被覆盖。
492 次浏览
