Modificador de acceso público vs protegido vs paquete vs privado en Java

Cada vez que escribimos nuestras clases, debemos proporcionar cierta información sobre nuestras clases a la JVM , como si esta clase puede ser accesible desde cualquier lugar o no, si la creación de clases secundarias es posible o no, si la creación de objetos es posible o no, etc. podemos especifique esta información utilizando una palabra clave adecuada en java denominada modificadores de acceso. Por lo tanto, los modificadores de acceso se utilizan para establecer la accesibilidad de clases, métodos y otros miembros.

Modificador 1: Modificadores de acceso público

Si una clase se declara como pública, podemos acceder a esa clase desde cualquier lugar.

En el siguiente ejemplo, estamos creando un paquete pack1 dentro de ese paquete, declaramos una clase A que es pública y dentro de esa clase, declaramos un método m1 que también es público. Ahora creamos otro paquete pack2 y dentro de ese pack2 importamos pack1 y declaramos una clase B y en el método principal de la clase B creamos un objeto de tipo clase A e intentamos acceder a los datos del método m1.

Ejemplo:

// Java program to showcase the example
// of public access modifier
 
// creating a package
package pack1;
   
// import required packages
import java.io.*;
import java.util.*;
   
// declaring a public class
public class A {
     
    // declaring method m1
    public void m1() { System.out.println("GFG"); }
}

 
Compilando y guardando el código anterior usando la siguiente línea de comando:

// creating a package
package pack2;
   
// import required packages
import java.io.*;
import java.util.*;
   
// importing package pack1
import pack1.A;
   
// driver class
class B {
     
    // main method
    public static void main(String[] args)
    {
        // creating an object of type class A
        A a = new A();
         
        // accessing the method m1()
        a.m1();
    }
}

 Si la clase A no es pública al compilar la clase B, obtendremos un error en tiempo de compilación que dice pack1. A no es público en el paquete 1 y no se puede acceder desde el paquete externo.

De manera similar, un miembro, método o interfaz se declara como público, ya que podemos acceder a ese miembro desde cualquier lugar.

Modificador 2: Modificador de acceso protegido

Este modificador se puede aplicar al miembro de datos, el método y el constructor, pero este modificador no se puede aplicar a las clases ni a la interfaz de nivel superior.

Un miembro se declara como protegido ya que podemos acceder a ese miembro solo dentro del paquete actual pero solo en la clase secundaria del paquete externo.

Implementación:

Ejemplo 

// Java program to showcase the example
// of protected access modifier
// import required packages
import java.io.*;
import java.util.*;
   
// declaring a parent class A
class A {
     
    // declaring a protected method m1()
    protected void m1() { System.out.println("GFG"); }
}
   
// creating a child class by extending the class A
class B extends A {
     
    // main method
    public static void main(String[] args)
    {
        // creating an object of parent class
        // using parent reference
        A a = new A();
         
        /// calling method m1
        a.m1();
         
        // creating an object of child class
        // using child reference
        B b = new B();
         
        // calling method m1
        b.m1();
         
        // creating an object of child class
        // using parent reference
        A a1 = new B();
         
        // calling m1 method
        a1.m1();
    }
}

GFG
GFG
GFG

Explicación de salida:

En el ejemplo anterior, creamos tres objetos usando la referencia principal y la referencia secundaria y llamamos al método m1() en él, y se ejecutó con éxito, por lo que del ejemplo anterior podemos decir que podemos acceder al método protegido dentro del paquete actual en cualquier lugar ya sea por usando referencia padre o por referencia hijo.

Modificador 3: Modificadores de acceso privado

Este modificador no se aplica a clases o interfaces de nivel superior. Solo es aplicable a constructores, métodos y campos dentro de las clases.  

Si una variable, un método o un constructor se declaran privados, solo podemos acceder a ellos desde dentro de la clase, es decir, desde fuera de la clase no podemos acceder a ellos.

Ejemplo:

// Java program to showcase the example
// of private access modifier
   
// import required packages
import java.io.*;
   
import java.util.*;
   
// helper class
class A {
     
    // helper method
    private void m1() { System.out.println("GFG"); }
}
   
// driver class
class B {
     
    // main method
    public static void main(String[] args)
    {
        // creating an object of type class A
        A a = new A();
         
        // accessing the method m1()
        a.m1();
    }
}

Modificador 4: Modificador de acceso al paquete (predeterminado)  

Una clase, método o variable se declara sin ningún modificador de acceso, entonces se considera que tiene un modificador de acceso de paquete (predeterminado). El modificador predeterminado actúa como público dentro del mismo paquete y actúa como privado fuera del paquete. Si una clase se declara como predeterminada, podemos acceder a esa clase solo dentro del paquete actual, es decir, desde el paquete externo no podemos acceder a ella. Por lo tanto, el modificador de acceso predeterminado también se conoce como modificador de acceso a nivel de paquete. Una regla similar también se aplica a las variables y métodos en Java.

Ejemplo: 

// Java Program to illustrate Package Level Access Modifier
   
// Importing utility classes
// Importing input output classes
import java.io.*;
import java.util.*;
   
// Main Class
class GFG {
   
    // Declaring default variables that is
    // having no access modifier
    String s = "Geeksfor";
    String s1 = "Geeks";
   
    // Method 1
    // To declare a default method
    String fullName()
    {
   
        // Concatenation of strings
        return s + s1;
    }
   
    // Method 2
    // Main driver method
    public static void main(String[] args)
    {
   
        // Creating an object of main class(GFG)
        // in the main() method
        GFG g = new GFG();
   
        // Calling method1 using class instance
        // and printing the concatenation of strings
        System.out.println(g.fullName());
    }
}

GeeksforGeeks

Finalmente, después de hacerlo con los cuatro modificadores de acceso, concluyamos las diferencias evidentes entre ellos.