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

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 illustrate Protected Access Modifier
 
// Importing required classes
import java.io.*;
import java.util.*;
 
// Class 1
// Declaring a parent class A
class A {
 
    // Declaring a protected method m1()
    protected void m1() { System.out.println("GFG"); }
}
 
// Class 2
// Creating a child class by extending the class A
class B extends A {
 
    // Main driver 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: 

Aquí hemos creado 3 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 utilizando la referencia principal o por referencia infantil.
 

Modificador de acceso final

Es un modificador aplicable a clases, métodos y variables. Básicamente se refiere a un espécimen que no se puede cambiar en el futuro una vez inicializado. Supongamos que 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 siempre es final por defecto, pero cada variable presente dentro de la clase final no necesita ser final. La principal ventaja de la palabra clave final es que podemos lograr seguridad y podemos proporcionar una implementación única. 

En palabras más simples, es un modificador que se usa para crear el método final, las variables que queramos crear en nuestro programa según los requisitos. Usamos donde queremos hacer parte del programa, ya sea desde la variable más pequeña hasta la parte más grande, ya sea el método considerado para la fecha de nacimiento.

final int dob = 25011947 ;

Ahora debe preguntarse qué es lo que simplemente declaramos y no inicializamos, en este caso, recuerde que el valor se puede inicializar más adelante solo con la ayuda de constructores y estos constructores no se pueden heredar. 

Nota: 

• Si la variable se declara estática junto con final como se muestra a continuación, solo se puede inicializar en los bloques estáticos.

public static final weekDay ;

• En el caso de una clase, si se declara como final, no puede ser implementada o heredada por otra clase no final, pero viceversa es cierto, lo que significa que una clase no final puede heredar métodos de clase final.

Ejemplo

// Java program to Illustrate Final keyword
 
// Importing required classes
import java.io.*;
import java.util.*;
 
// Class 1
// 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");
    }
}
 
// Class 2
// Creating a child class of above parent class
class C extends P {
 
    // Method 1
    // Overriding the surName() method
    public void surName()
    {
 
        // Display surname
        System.out.println("Sharma");
    }
 
    // Method 2
    // Main driver method
    public static void main(String[] args)
    {
 
        // Display message
        System.out.println("GFG");
    }
}

Producción:

Ahora analicemos las diferencias entre estos dos que se enumeran de manera concluyente a continuación en formato tabular como se proporciona a continuación: