Modificador de acceso público vs protegido en Java

Cada vez que escribimos nuestras clases, debemos proporcionar cierta información sobre nuestras clases a la JVM , como si se puede acceder a esta clase 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 especificar esta información usando una palabra clave apropiada en Java llamada modificadores de acceso. Por lo tanto, los modificadores de acceso se utilizan para establecer la accesibilidad de clases, métodos y otros miembros.

Modificadores de acceso público: si una clase se declara 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.

// 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 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. 

// 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();
    }
}

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.