Diferencia entre el nivel de clase y el control de acceso a nivel de método en Java

El acceso de una clase o un método o ambos en Java se puede declarar con la ayuda de modificadores de acceso . Modificadores de acceso que están disponibles en Java

• Modificador privado: si se declara solo accesible dentro de la clase
• Modificador predeterminado: si se declara solo accesible dentro del propio paquete
• Modificador protegido: si se declara accesible dentro del paquete y solo en clases secundarias de otros paquetes
• Modificador público: si se declara accesible en cualquier lugar

Obtenga más información sobre los modificadores de acceso aquí .

Nota: Hay otros modificadores final, strictfp, static, abstract, pero no son modificadores de acceso, es decir, proporcionan información sobre la creación de instancias de objetos o la anulación de permisos, etc., pero no se utilizan para declarar el acceso.

Tipos de Nivel de Acceso

Hay dos tipos de nivel de acceso

1. Acceso a nivel de clase

El acceso otorgado a una clase, ya sea que sea visible fuera del paquete, etc., se denomina acceso a nivel de clase. Los modificadores public y default[package_ private] se utilizan para el acceso a nivel de clase. Si usamos el modificador público, la clase se puede usar en cualquier lugar con solo la condición de que la clase debe estar disponible [importar, etc.]. mientras que si usamos el modificador predeterminado, solo se puede acceder a la clase dentro del paquete declarado y no en ningún otro lugar 

2. Acceso a nivel de método

El acceso otorgado a un método de una clase, ya sea para trabajar fuera de la clase o paquete o dentro de una clase secundaria, etc., se denomina acceso a nivel de método. Los cuatro modificadores se utilizan para el acceso a nivel de método

Nota : la clase debe ser pública si usamos métodos protegidos o públicos, ya que la clase debe estar disponible en los paquetes externos antes de que usemos sus miembros. Aunque tenga al menosun método público o protegido, es obligatorio declarar la clase . como publico

• Si usamos el modificador privado , el método solo se puede permitir dentro de la clase.
• Si usamos el modificador predeterminado , solo se puede acceder a la clase dentro del paquete declarado y no en ningún otro lugar, la clase puede ser pública o no, no hace ninguna diferencia.
• Si usamos el modificador protected , entonces se puede acceder a la clase en cualquier lugar dentro del paquete y solo en las clases secundarias fuera del paquete que también solo tienen referencias secundarias.
• Si usamos el modificador público , entonces se permite usar el método en cualquier lugar con la única condición de que la clase debe estar disponible.

Ejemplo

Un programa de ejemplo para demostrar los modificadores de acceso.

package salary;
 
public class Manager
{
    private int a = 15;
     
    // This method needs to be private as
    // only the manager will have the
    // power to change employees' salary
    private void change()
    {                    
        System.out.println("salary changed");
    }
   
    // This method needs to be protected
    // as the companies salary
    // column can only be seen by
    // the company employees
    // and their child companies
    protected void sal_column()
    {                 
        System.out.println("salary shown");
    }
   
    // This method needs to be default
    // as individual salary
    // can only be shared within the company
    void indi_sal()
    {              
        System.out.println("your salary is shown");
    }
   
      // This method needs to be public
      // as the cost of a product
      // must be marketized to increase the profits
    public void prod_cost()
    {                 
        System.out.println("product cost");
    }
}
     
class Employee
{
    public static void main(String arg[]){
        Manager mng = new Manager();
       
          // error: change() has private access in Manager
         // mng.change();
       
        // total salary of all employees
        mng.sal_column();
       
        // individual salary
        mng.indi_sal();
       
        // cost of product
        mng.prod_cost(); 
    }
}
 
// Code written by @srivathsanani

compilado y ejecutado

package reports;
 
// importing salary package with Manager class
import salary.Manager;
 
 
// The reports of our company needs our
// manager so we inherit Manager class
public class Reports extends Manager
{
    public static void main(String arg[])
    {
        Manager manager = new Manager();
        Reports report = new Reports();
         
        // error: indi_sal() is not public in Manager;
        // cannot be accessed from outside package
        // manager.indi_sal();
        manager.prod_cost();
        report.sal_column();
    }
}
 
 
// AS other companies are not related to our
// company we won't inherit our Manager class
class OtherCompany
{
    public static void main(String arg[])
    {
        Manager manager = new Manager();
        manager.prod_cost();
       
          // error: sal_column() has protected access in Manager
        // manager.sal_column();  
    }
}
 
// code written by @srivathsanani

compilado y ejecutado

Nota: solo debemos usar referencias de clases secundarias si estamos usando métodos protegidos fuera del paquete

Tabla de diferencias