Java 中的 Private、Protected 和 Final 访问修饰符

每当我们声明一个类时，我们都需要提供它的访问级别，以便 JVM 能够知道程序中是否可以发生继承或实例化，以及该类的范围是什么。为此，我们使用访问修饰符，这些修饰符可以与类、方法和变量等一起使用。

• Private 访问修饰符将方法或变量的访问限制为仅对类；这意味着只能在同一个类中访问该方法或变量。

• Protected 访问修饰符允许访问该类及其任何子类，包括其他包中的类。

• Final 访问修饰符不允许扩展类。如果应用于方法，则不能被子类覆盖。如果变量被声明为 final，则初始化后不能对其进行赋值。

算法

要实现 private、protected 和 final 访问修饰符，请按照以下步骤操作 -

• 步骤 1 - 定义一个类及其成员，即方法和变量。

• 步骤 2 - 要将变量或方法声明为私有，请使用 private 关键字作为访问修饰符。

• 步骤 3 - 要将变量或方法声明为受保护，请使用 protected 关键字作为访问修饰符。

• 步骤 4 - 使用 final 关键字将变量定义为 final。

• 步骤 5 - 现在，同一个类的成员可以访问私有变量或方法。

• 步骤 6 - 同一类或子类的方法可以访问受保护的变量或方法。

• 步骤 7 - 要访问类外的私有和受保护变量，可以使用访问这些变量的公共方法。

• 步骤 8 - 访问私有和受保护变量的方法应声明为公共方法。

• 步骤 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:使用私有访问修饰符

以下是代码片段

示例

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(); // 打印"姓名:John，年龄:30"
        String details = john.getDetails(); // 访问私有方法，导致编译时错误
        String name = john.name; // 访问私有字段，导致编译时错误
        int age = john.age; // 访问私有字段，导致编译时错误
   }
}

输出

Name: John, Age: 30

解释

在上面的程序中，如果我们调用 getDetails() 方法和 Employee 类之外的私有变量，那么我们将得到编译时错误。

方法 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

解释

以下代码执行时没有任何错误，因为我们访问的是同一包、类和子类内的受保护变量和方法。

方法 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，因此此尝试会导致编译时错误。

方法之间的比较

结论

这些访问Java 中的修饰符用于控制类成员(变量、方法和内部类)的可见性。Private 限制只能访问同一类的成员，protected 允许访问同一包中的子类和类，final 表示成员的值不能更改或方法不能被覆盖。

相关文章

• 在 Java 中计算 n 中至少有一位数字与 n 相同的除数
• Java 中二叉树奇数位置和偶数位置节点之和的差异
• Java 中二叉树奇数层和偶数层节点之和的差异
• 奇数和偶数之和的差异。
• 前 n 个自然数的平方和与和的平方之间的差异。
• Java 中数组中最大和最小素数之间的差异
• Java 中的 EnumMap 类
• 在 Java 中比较两个字符串
• 在 Java 中比较日期
• Java 中的流

有用资源

• java 参考教程 - 该教程包含有关 java 的更多信息:https://www.cainiaomax.com/java/