Introducción a la palabra clave final en Java
En esta publicación, veremos las diferentes palabras clave finales para java. Es una palabra clave utilizada en lenguaje java para aplicar restricciones en su uso o modificación por otras clases o variables. Al usar esta palabra clave, uno le dice al intérprete que no permita ninguna modificación futura a esa variable o método y que la trate como constante. Se puede usar con los siguientes 3 escenarios: -
- Variable: declarar una variable como final restringe su modificación para referirse a cualquier otro valor o referencia.
- Métodos: declarar un método como final restringe la anulación del método en las clases secundarias.
- Clases: declarar una clase como final evita la herencia de esa clase.
Siempre se recomienda declarar estas palabras clave en mayúsculas de acuerdo con las buenas prácticas de codificación.
Sintaxis de la palabra clave final en Java
Esta palabra clave se puede utilizar de las siguientes 3 maneras: -
1. Variable
Las variables en Java se pueden declarar como variables para restringir cualquier cambio en sus valores. Se puede declarar en cualquiera de las siguientes tres formas:
Sintaxis:
final int VAR1=21;//final variable
final int VAR2; //blank final variable
static final double DUMMY= 45.504;//final static variable
static final double PK;//blank final static variable
final String builder sb = new StringBuilder ("LetsLearn");
2. Métodos
Se dice que el método declarado con la palabra clave final es el método final. El método final no puede ser anulado por su clase secundaria, lo que significa que el método de la clase secundaria no puede cambiar la definición del método final presente en la clase primaria. Cuando deseamos que se siga la implementación de un método definido en la clase principal en todas sus clases secundarias, entonces debemos declarar ese método como final.
Sintaxis:
final int my1()(
//method defination
)
3. Clases
Las palabras clave finales también se pueden usar con clases para convertirla en una clase final, lo que significa que una clase en particular no puede ser extendida o heredada por ninguna otra clase.
Sintaxis:
final class myClass(
/member variables and member functions.
)
¿Cómo funciona la palabra clave final en Java?
La palabra clave final ayuda a restringir la anulación de las clases, miembros o variables durante la herencia.
1. Variables finales
Declarar una variable como final significa restringir cualquier alteración al valor de la variable en las clases heredadas. Una variable final solo se puede inicializar una vez y debe usarse tal como está, por lo tanto, uno debe inicializar una variable final. Se usa principalmente con static para crear una variable de clase constante.
Por ejemplo:
final int a =0;
También podemos declarar variables de referencia finales también, en este caso, una variable de referencia no puede referirse a diferentes objetos. Pero en Java, el estado interno de un objeto se puede cambiar al que se refiere la variable de referencia final. Por lo tanto, podemos hacer cambios en el valor de la variable de referencia. Esto es lo mismo que usar las matrices finales como se muestra a continuación:
Código:
class MyClass
(
public static void main(String args())
(
final int myarr() = (1, 2, 3, 4, 5);
for (int q = 0; q < myarr.length; q++)
(
myarr (q) = myarr (q)*10;
System.out.println(myarr (q));
)
)
)
Salida:
Explicación
Aquí la matriz a1 se refiere al mismo objeto, solo el valor de ese objeto está cambiando porque todos sabemos que la variable de la matriz contiene solo la dirección inicial de la ubicación de la memoria donde se almacenan esos elementos de la matriz.
Y de la misma manera, si intentamos referir una matriz diferente usando la misma variable de matriz a1, el compilador arrojará un error. Por lo tanto, al usar el conjunto de palabras final aquí, se puede hacer cualquier modificación en el miembro del conjunto, pero la variable no puede referirse a ningún otro objeto.
Cosas para recordar
La inicialización de una variable final es necesaria para evitar errores en tiempo de compilación. Hay una diferencia entre las variables const de C ++ y estas variables finales que las variables const no necesitan inicializarse. Hay tres formas de inicializar una variable final:
- Inicialice en el momento de la declaración en sí : podemos declarar fácilmente una variable final en el momento de declararla. En caso de que no se inicialice, esa variable se considera como una variable final en blanco, y cualquiera de las siguientes 2 formas puede ayudarnos a inicializar una variable final en blanco.
- Uso del bloque de inicializador de instancia : dentro de este bloque o del constructor, se puede inicializar fácilmente una variable final en blanco. Mientras usa un constructor para inicializar, recuerde siempre inicializar la variable particular en todos los constructores disponibles.
- Bloque estático: también se puede usar un bloque estático para inicializar la variable final en blanco. El bloque estático siempre se activa una vez para cada clase, por lo tanto, el valor de la variable cuyos valores no están destinados a ser alterados se puede inicializar fácilmente usando este bloque.
Por lo tanto, la palabra clave final se usa solo para aquellas variables que no necesitan cambiar su valor durante la ejecución del programa. Todas las variables finales creadas dentro de un método o bloque deben inicializarse allí mismo. Dichas variables de tipo se conocen como variables finales locales.
Explicación
En el siguiente ejemplo, una variable i ha sido declarada dentro de la función principal e inicializada también, por lo tanto, se considera como una variable local final.
Código:
class myClass
(
public static void main(String args())
(
// local final variable
final int i;
i = 20;
System.out.println(i);
)
)
Salida:
2. Métodos finales
Un método declarado como final no puede anularse en ninguna de las subclases, por lo tanto llamado como método final. El método debe declararse como final si requerimos que las clases secundarias sigan la misma implementación de la clase.
Nota : no es necesario que los métodos finales se declaren en la etapa inicial de herencia (clase base). El método se puede declarar final en cualquier subclase que deseemos que otras subclases sigan la misma definición.Código:
class A(
void myMethod()(
//method definition
)
)
class B extends A(
final void myMethod()(
//overrides the method in parent class
//runs successfully
)
)
class C extends B(
void myMethod()(
//will throw error
)
)
3. Clases finales
Las clases declaradas como finales no pueden ser heredadas por ninguna otra clase. Mencionar una palabra clave final antes del nombre de la clase le dice al compilador que la definición de esta clase solo se puede usar como está. Ninguna otra clase puede agregar sus especificaciones a esta definición o reutilizar su código. En caso de que uno intente extender la clase final, el compilador arroja un error que indica que esta clase no debe extenderse. Se pueden usar palabras clave finales en java en cualquiera de los siguientes 2 propósitos: -
- El primero es evitar la herencia de esa clase. Por ejemplo, todas las clases Wrapper presentes en el paquete java.lang son clases finales, por lo que no podemos extenderlas en nuestras clases, pero podemos usarlas declarando sus objetos. Cualquier intento realizado para acceder a esas clases dará como resultado un error por parte del compilador.
final class myParentClass
(
// member variables and member functions
)
// illegal extend.
class myChildClass extends parentClass
(
// Can't subclass A
)
- El segundo uso de final con clases es cuando uno necesita crear una clase inmutable, es decir, una vez que se crea el objeto de la clase, no podemos cambiar su contenido como la clase String predefinida. La clase debe declararse como final para que sea inmutable.
Nota :
- Si una clase se declara como final, el compilador también considera que sus variables miembro y funciones miembro son finales.
- Una clase no se puede declarar abstracta donde depende de las clases secundarias para completar su definición, así como final, lo que impide la herencia en sí.
Ejemplos de palabras clave finales en Java
A continuación se muestran los diferentes ejemplos de palabras clave finales en Java:
1. Usando la variable final
En el siguiente ejemplo, se inicializan diferentes variables utilizando varios métodos. Por ejemplo, la SEGUNDA variable se inicializa usando un constructor, mientras que TERCERO se inicializa usando un inicializador.
Código:
class myClass
(
final int FIRST = 5;
// a blank final variable
final int SECOND;
// another blank final variable
final int THIRD;
FIRST =10; //illegal attempt to change the value of final variable
// a final static variable PI
// direct initialize
static final double MINVALUE = 3.141592653589793;
// a blank final static variable
static final double MAXRANGE;
(
THIRD = 25; // initializer block
)
static(
MAXRANGE = 200.3;
)
public myClass()
(
SECOND = -1;//needs to be initialised in every constructor
)
)
Salida:
2. Usando métodos finales
En el siguiente ejemplo, la clase abstracta myShape declara los métodos finales getWidth y obtiene ocho que no necesitan ser anulados por las clases heredadas. También declara una función abstracta cuya implementación es obligatoria en las clases posteriores. Por lo tanto, la única definición de una función abstracta se implementa en una primera clase secundaria y en una segunda clase secundaria.
Código:
abstract class myShape
(
private double width;
private double height;
public myShape(double width, double height)
(
this.width = width;
this.height = height;
)
public final double getWidth() //override not allowed
(
return width;
)
public final double getHeight() //override not allowed
(
return height;
)
abstract double getArea(); //needs to be defined in the child class
)
class firstChildClass extends myShape
(
public firstChildClass(double width, double height)
(
super(width, height);
)
final double getArea()
(
return this.getHeight() * this.getWidth();
)
)
class secondChildClass extends myShape
(
public secondChildClass(double side)
(
super(side, side);
)
final double getArea()
(
return this.getHeight() * this.getWidth();
)
)
public class myClass
(
public static void main(String() args)
(
myShape s1 = new firstChildClass(10, 20);
myShape s2 = new secondChildClass(10);
System.out.println("width of s1 : "+ s1.getWidth());
System.out.println("height of s1 : "+ s1.getHeight());
System.out.println("width of s2 : "+ s2.getWidth());
System.out.println("height of s2 : "+ s2.getHeight());
System.out.println("area of s1 : "+ s1.getArea());
System.out.println("area of s2 : "+ s2.getArea());
)
)
Salida:
3. Usando clases finales
En el siguiente programa, estamos utilizando una clase final Sólido que define un método para calcular el volumen de una forma usando sus dimensiones, pero la visualización del volumen de un cuadro se realiza mediante la función printVol en la clase heredada. Shape As Solid es una clase final, por lo tanto, la clase Shape no podrá extenderla (o heredarla). Por lo tanto, utiliza el objeto de Shape para calcular el volumen de cualquiera de Shape simplemente pasando los argumentos a las funciones.
Código:
final class Solid (
public double getVol(double length, double width, double height) (
return length * width * height;
)
)
class Shape (
private float length;
private float width;
private float height;
Shape(float length, float width, float height) (
this.length = length;
this.width = width;
this.height = height;
)
public void printVol(Solid bObj) (
double volume = bObj.getVol(this.length, this.width, this.height);
System.out.println("Volume of the Shape: " + volume);
)
)
public class myClass (
public static void main(String() args) (
Solid bObj = new Solid();
Shape obj = new Shape(5, 4, 3);
obj.printVol(bObj);
)
)
Salida:
Conclusión
La palabra clave final se usa para evitar que las clases, variables y métodos sean anulados por sus clases secundarias. También se puede usar para hacer que las clases sean inmutables, lo que restringe el cambio en el valor de sus objetos. La verificación final de palabras clave siempre se verifica solo en tiempo de compilación. Es una gran utilidad para evitar la reutilización de las variables definidas, la lógica y las clases.
Artículos recomendados
Esta es una guía de ejemplo de palabra clave final en Java. Aquí discutimos cómo funciona la palabra clave final en Java? que incluye variables finales, métodos finales, clases finales junto con la sintaxis. También puede consultar los siguientes artículos para obtener más información:
- Tipos y modificadores utilizados para JComponent en Java
- Nuevas características de Java 8
- ¿Cómo crear un objeto en JavaScript?
- ¿Qué es la declaración de caso en JavaScript?
- Lanzamiento vs Lanzamientos | Las 5 principales diferencias que debes saber
- Declaración de clase abstracta en C # con ejemplo
- Usos y ejemplos de esta palabra clave