Modificador de acceso privado vs protegido vs final 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:

1. Privado
2. Protegido
3. Final

Discutámoslos en profundidad para obtener una mejor comprensión antes de llegar a las diferencias entre ellos.

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

// Java Program to illustrate Private Access Modifier
 
// Importing required packages
import java.io.*;
import java.util.*;
 
// Class 1
// Helper class
class A {
 
    // Method of this class
    private void m1() {
 
        // Print statement whenever this method is called
        System.out.println("GFG");
    }
}
 
// Class 2
// Main class
class B {
 
    // Main driver method
    public static void main(String[] args) {
        // Creating an object of above class
        A a = new A();
 
        // Accessing the method m1() of above class
        // by creating object of above class in
        // main() method of this class
        a.m1();
    }
}

Modificador de acceso protegido: este modificador se puede aplicar al miembro de datos, al método y al 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.

// Java program to illustrate 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 utilizando la referencia principal o la referencia secundaria.

Modificador de acceso final:Es un modificador aplicable a clases, métodos y variables. Si declaramos un método de clase principal como final, no podemos anular ese método en la clase secundaria porque su implementación es final y si una clase se declara como final, no podemos extender la funcionalidad de esa clase, es decir, no podemos crear una clase secundaria para esa clase, es decir, la herencia no es posible para las clases finales. Cada método presente dentro de la clase final es siempre final y predeterminado, pero no es necesario que cada variable presente dentro de la clase final sea final. La principal ventaja de la palabra clave final es que podemos lograr seguridad y podemos proporcionar una implementación única. Pero la principal desventaja de la palabra clave final es que nos faltan beneficios clave de los OOP como la herencia (debido a la clase final), 

// Java program to illustrate Final keyword
   
// import required packages
import java.io.*;
import java.util.*;
// Declaring parent class P
class P {
    // Declaring a first name
    // method
    public void firstName()
    {
        // Display firstname
        System.out.println("Rahul ");
    }
    /// Declaring a final surName
    // method
    public final void surName()
    {
        // Display surname
        System.out.println("Trivedi");
    }
}
// Creating a child class
// of above parent class
class C extends P {
    // overriding the surName
    // method
    public void surName()
    {
        // Display surname
        System.out.println("Sharma");
    }
    // Main method
    public static void main(String[] args)
    {
        // Display message
        System.out.println("GFG");
    }
}

Producción:

Ahora, después de tener una comprensión de todos ellos, aterricemos en las diferencias entre ellos para concluir.