Modificadores de acceso protegido vs paquete 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.

Modificador 1: 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.

Ejemplo:

// Java Program to show Protected keyword
 
// Importing input output classes
import java.io.*;
// Importing utility classes
import java.util.*;
 
// Class 1
// Parent class
class Parent {
 
    // declaring a protected method m1()
    protected void print() { System.out.println("GFG"); }
}
 
// Class 2
// Child class which is extending Parent class
class Child extends Parent {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Creating an object of parent class
        // using parent reference
        Parent p = new Parent();
 
        /// calling the print() method of Parent class
        p.print();
 
        // Creating an object of child class
        // using child reference
        Child c = new Child();
 
        // Calling the print() method of Parent class
        c.print();
 
        // Creating an object of child class
        // using parent reference
        Parent cp = new Child();
 
        // Calling the print method over this object
        cp.print();
    }
}

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 2: 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 de 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 ambos, concluyamos las diferencias evidentes entre ellos.