Java 私有、受保护和最终访问修饰符

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

私有访问修饰符将方法或变量的访问限制在类内部；这意味着该方法或变量只能在同一个类内部访问。
受保护的访问修饰符允许访问类及其任何子类，包括其他包中的类。
最终访问修饰符不允许类被扩展。如果应用于方法，则该方法不能被子类覆盖。如果变量被声明为final，则在初始化之后不能再被赋值。

步骤

要实现私有、受保护和最终访问修饰符，请按照以下步骤进行：

步骤1 - 定义一个类及其成员，即方法和变量。
步骤2 - 使用private关键字作为访问修饰符将变量或方法声明为私有。
步骤3 - 使用protected关键字作为访问修饰符将变量或方法声明为受保护。
步骤4 - 使用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：使用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()方法和私有变量，则会得到编译时错误。

方法2：使用受保护的访问修饰符

下面是一个代码示例

示例

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，所以这个尝试导致了编译时错误。

方法比较

私有修饰符	受保护的修饰符	最终修饰符
成员在声明的同一类中可以被访问。	在同一包中的类和子类中可以访问成员。	成员不能在同一类或子类中访问。
接口可以使用此修饰符。	接口可以使用此修饰符。	接口不能使用此修饰符。
私有方法可以被重写。	受保护的方法不能被重写。	最终方法不能被重写。