Java继承机制深度解析：细探private与protected权限控制

private 和 protected 是 Java 中的两种访问修饰符，用于控制类成员（字段和方法）的访问权限。它们在设计类和实现封装、继承多态性方面具有重要作用。下面详细说明它们的区别和含义。

1. private 修饰符

• 含义：

  • 被 private 修饰的成员（字段或方法）只能在定义它们的类内部访问。
  • 其他类，包括继承该类的子类，无法直接访问这些成员。

• 使用场景：

  • 用于封装类的内部实现细节，确保类的状态和行为不会被外部类或子类随意访问或修改。
  • 常用于保护敏感数据和防止类的内部结构被外部代码破坏。

• 示例：

  class Example {
      private int secretNumber;  // 私有字段
  
      public Example(int number) {
          this.secretNumber = number;
      }
  
      private void displaySecret() {  // 私有方法
          System.out.println("Secret number is: " + secretNumber);
      }
  
      public void reveal() {
          displaySecret();  // 在本类内调用私有方法
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Example example = new Example(42);
          example.reveal();  // 正常调用
          // example.secretNumber;  // 编译错误：无法访问私有字段
          // example.displaySecret();  // 编译错误：无法访问私有方法
      }
  }
  

2. protected 修饰符

• 含义：

  • 被 protected 修饰的成员可以在以下情况下访问：
    • 定义它们的类内部访问。
    • 同一包中的其他类访问。
    • 任何子类（无论它们是否在同一包中）访问。

• 使用场景：

  • 当你希望某些类成员在继承体系中可见，但又不希望它们公之于众时，可以使用 protected。
  • 常用于基类与子类之间的共享数据或方法。

• 示例：

  class Animal {
      protected String species;  // 受保护字段
  
      protected void displaySpecies() {  // 受保护方法
          System.out.println("Species is: " + species);
      }
  }
  
  class Dog extends Animal {
      public Dog(String species) {
          this.species = species;  // 子类可以访问受保护字段
      }
      
      public void bark() {
          System.out.println("Dog barks");
      }
  
      public void show() {
          displaySpecies();  // 子类可以调用受保护方法
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Dog dog = new Dog("Canine");
          dog.show();  // 输出: Species is: Canine
          // dog.species;  // 编译错误：无法访问受保护字段（如果在不同包下）
      }
  }
  

3. private 和 protected 的主要区别

4. 总结

• private 修饰符用于保护类的实现细节，防止外部类或甚至子类访问，强调信息隐藏和封装。
• protected 修饰符允许在继承层次中共享，提供了比 private 更宽松的可见性，便于子类与父类之间的交互。

在实际编程中，根据自己的需求选择合适的访问修饰符，可以有效地管理类的接口和内部实现，增强代码的可读性和可维护性。

5. 快速掌握继承

下面提供一份简洁的JAVA代码，全面地介绍类的继承,看完理解基本能掌握继承:

public class demo06 {
  public static void main(String[] args) {
      // 创建 Dog 对象
      Dog dog = new Dog("Buddy", 3, "Canine", "Golden Retriever");
      dog.speak();  // 输出: Dog barks
      dog.eat();    // 输出: Animal eats
      dog.fetch();  // 输出: Dog fetches
      dog.showInfo();  // 输出: Name: Buddy, Age: 3, Species: Canine, Breed: Golden Retriever

      // 创建 Cat 对象
      Cat cat = new Cat("Whiskers", 2, "Feline", "Black");
      cat.speak();  // 输出: Cat meows
      cat.eat();    // 输出: Animal eats
      cat.scratch();  // 输出: Cat scratches
      cat.showInfo();  // 输出: Name: Whiskers, Age: 2, Species: Feline, Color: Black

      // 多态性：使用父类引用指向子类对象
      Animal animal1 = new Dog("Max", 4, "Canine", "German Shepherd");
      Animal animal2 = new Cat("Mittens", 1, "Feline", "White");

      animal1.speak();  // 输出: Dog barks
      animal2.speak();  // 输出: Cat meows

      // 不能直接访问父类的私有字段，但可以通过 Getter 方法访问
      System.out.println("Dog's name: " + animal1.getName());  // 输出: Dog's name: Max
      System.out.println("Cat's age: " + animal2.getAge());  // 输出: Cat's age: 1
  }
}

// 定义父类 Animal
class Animal {
  // 父类的私有字段
  private String name;
  private int age;

  // 父类的受保护字段
  protected String species;

  // 构造函数
  public Animal(String name, int age, String species) {
      this.name = name;
      this.age = age;
      this.species = species;
  }

  // 父类的方法
  public void speak() {
      System.out.println("Animal speaks");
  }

  public void eat() {
      System.out.println("Animal eats");
  }

  public void sleep() {
      System.out.println("Animal sleeps");
  }

  // Getter 方法用于访问私有字段
  public String getName() {
      return name;
  }

  public int getAge() {
      return age;
  }

  // 受保护的方法
  protected void displayInfo() {
      System.out.println("Name: " + name + ", Age: " + age + ", Species: " + species);
  }
}

// 子类 Dog，继承自 Animal
class Dog extends Animal {
  // 子类的额外字段
  private String breed;

  // 子类的构造函数
  public Dog(String name, int age, String species, String breed) {
      super(name, age, species);  // 调用父类构造函数
      this.breed = breed;
  }

  // 子类覆盖父类的方法
  @Override
  public void speak() {
      System.out.println("Dog barks");
  }

  // 子类的新方法
  public void fetch() {
      System.out.println("Dog fetches");
  }

  // 子类使用受保护的方法
  public void showInfo() {
      displayInfo();  // 调用父类的受保护方法
      System.out.println("Breed: " + breed);
  }
}

// 子类 Cat，继承自 Animal
class Cat extends Animal {
  // 子类的额外字段
  private String color;

  // 子类的构造函数
  public Cat(String name, int age, String species, String color) {
      super(name, age, species);  // 调用父类构造函数
      this.color = color;
  }

  // 子类覆盖父类的方法
  @Override
  public void speak() {
      System.out.println("Cat meows");
  }

  // 子类的新方法
  public void scratch() {
      System.out.println("Cat scratches");
  }

  // 子类使用受保护的方法
  public void showInfo() {
      displayInfo();  // 调用父类的受保护方法
      System.out.println("Color: " + color);
  }
}