La diferencia entre modificadores de permisos en java

Los modificadores de acceso en Java se utilizan para restringir el acceso a clases, variables, métodos y constructores. Java proporciona cuatro modificadores de permisos, a saber:

1. privado: privado, solo se puede acceder en esta clase, no en otras clases.
2. predeterminado (no se especifica explícitamente ningún modificador de permiso): de forma predeterminada, solo pueden acceder a él las clases del mismo paquete, no las clases de otros paquetes.
3. protegido: solo 同一个包中的类o 是这个类的子类可以访问
   Por ejemplo, si tiene un método o variable protegido en una clase, cualquier otra clase en este paquete puede acceder directamente a este método o variable. Al mismo tiempo, cualquier subclase que herede esta clase, esté o no en el mismo paquete, puede acceder a este método o variable.

public class Animal {
    
      
    protected String name;  
  
    protected void eat() {
    
      
        // ...  
    }  
}  
  
public class Dog extends Animal {
    
      
    // 可以在这里访问 Animal 类的 protected 成员  
    public void bark() {
    
      
        System.out.println(name);  // 可以访问 name  
        eat();  // 可以访问 eat  
    }  
}

En el ejemplo anterior, la clase Perro puede acceder al método protegido eat() y al nombre de la variable protegida de la clase Animal.

4. público: público, accesible desde cualquier lugar.

A continuación se muestra un ejemplo sencillo que muestra el uso de diferentes modificadores de permisos:

public class Animal {
    
    
    private String name; // 私有变量，只能在本类中访问
    String color; // 默认变量，只能在同一个包中的类访问
    protected int age; // 受保护变量，可以在同一个包中的类以及其他包中的子类访问
    public String species; // 公共变量，可以在任何地方访问
    
    private void eat() {
    
     // 私有方法，只能在本类中访问
        // ...
    }
    
    void sleep() {
    
     // 默认方法，只能在同一个包中的类访问
        // ...
    }
    
    protected void breathe() {
    
     // 受保护方法，可以在同一个包中的类以及其他包中的子类访问
        // ...
    }
    
    public void move() {
    
     // 公共方法，可以在任何地方访问
        // ...
    }
}

El alcance de un modificador de permiso comienza desde donde se define y termina con la clase o interfaz.