El método final en Java se utiliza como modificador de no acceso aplicable sólo a un variable , a método , o un clase. Es usado para restringir a un usuario en Java .

Los siguientes son diferentes contextos donde se usa la final:

1. Variable
2. Método
3. Clase

Características de la palabra clave final en Java:

En Java, la palabra clave final se utiliza para indicar que una variable, método o clase no se puede modificar ni ampliar. Estas son algunas de sus características:

• Variables finales: Cuando una variable se declara como final, su valor no se puede cambiar una vez que se ha inicializado. Esto es útil para declarar constantes u otros valores que no deben modificarse.
• Métodos finales : Cuando un método se declara como final, una subclase no puede anularlo. Esto es útil para métodos que forman parte de la API pública de una clase y no deben ser modificados por subclases.
• Clases finales: Cuando una clase se declara final, no puede ser ampliada por una subclase. Esto es útil para clases que están destinadas a usarse tal cual y no deben modificarse ni ampliarse.
• Inicialización: Las variables finales deben inicializarse en el momento de la declaración o en el constructor de la clase. Esto garantiza que el valor de la variable esté establecido y no se pueda cambiar.
• Actuación: El uso de un final a veces puede mejorar el rendimiento, ya que el compilador puede optimizar el código de manera más efectiva cuando sabe que una variable o método no se puede cambiar.
• Seguridad: El último puede ayudar a mejorar la seguridad al evitar que el código malicioso modifique datos o comportamientos confidenciales.

En general, la palabra clave final es una herramienta útil para mejorar la calidad del código y garantizar que ciertos aspectos de un programa no puedan modificarse ni ampliarse. Al declarar variables, métodos y clases como finales, los desarrolladores pueden escribir código más seguro, sólido y fácil de mantener.

Variable final de Java

Cuando se declara una variable con el palabra clave final , es el valor no se puede cambiar , esencialmente, un constante . Esto también significa que usted debe inicializar una variable final .

Si la variable final es una referencia , esto significa que la variable no puede ser volver a enlazar con la referencia otro objeto, pero el estado interno del objeto señalado por esa variable de referencia se puede cambiar, es decir, puede agregar o eliminar elementos del matriz final o recogida final.

Es una buena práctica representar las variables finales en mayúsculas, utilizando guiones bajos para separar las palabras.

Ejemplo:

public class ConstantExample {  public static void main(String[] args) {  // Define a constant variable PI  final double PI = 3.14159;  // Print the value of PI  System.out.println('Value of PI: ' + PI);  } }>

Value of PI: 3.14159>

Producción:

  Value of PI: 3.14159>

Diferentes métodos de uso de la variable final

Veamos diferentes métodos con los que podemos usar la variable final en Java.

1. variable final

Ejemplo:

// Final variable final int THRESHOLD = 5;>

2. Variable final en blanco

Ejemplo:

// Blank final variable final int THRESHOLD;>

3. Variable final estática

Ejemplo:

// Final static variable PI static final double PI = 3.141592653589793;>

4. Variable final en blanco estática

Ejemplo:

// Blank final static variable static final double PI;>

Inicializando una variable final

Debemos inicializar una variable final; de lo contrario, el compilador arrojará un error en tiempo de compilación. Una variable final sólo puede inicializarse una vez, ya sea mediante un inicializador o una declaración de asignación. Hay tres formas de inicializar una variable final:

programa de matriz bidimensional en c

1. Puede inicializar una variable final cuando se declara. Este enfoque es el más común. Una variable final se llama variable final en blanco si esto es no inicializado durante la declaración. A continuación se muestran las dos formas de inicializar una variable final en blanco.
2. Una variable final en blanco se puede inicializar dentro de un bloque inicializador de instancia o el constructor. Si tiene más de un constructor en su clase, entonces debe inicializarse en todos ellos; de lo contrario, se generará un error en tiempo de compilación.
3. Una variable estática final en blanco se puede inicializar dentro de un bloque estático .

Veamos estas dos formas diferentes de inicializar una variable final.

Ejemplo:

// Java Program to demonstrate Different // Ways of Initializing a final Variable // Main class  class GFG {    // a final variable  // direct initialize  final int THRESHOLD = 5;    // a blank final variable  final int CAPACITY;    // another blank final variable  final int MINIMUM;    // a final static variable PI  // direct initialize  static final double PI = 3.141592653589793;    // a blank final static variable  static final double EULERCONSTANT;    // instance initializer block for   // initializing CAPACITY  {  CAPACITY = 25;  }    // static initializer block for   // initializing EULERCONSTANT  static{  EULERCONSTANT = 2.3;  }    // constructor for initializing MINIMUM  // Note that if there are more than one  // constructor, you must initialize MINIMUM  // in them also  public GFG()   {  MINIMUM = -1;  }   }>

No había ningún método principal en el código anterior, ya que era simplemente con fines ilustrativos para obtener una mejor comprensión y sacar conclusiones:

Observación 1: ¿Cuándo utilizar una variable final?

La única diferencia entre una variable normal y una variable final es que podemos reasignar el valor a una variable normal pero no podemos cambiar el valor de una variable final una vez asignada. De ahí que las variables finales deban usarse solo para los valores que queremos que permanezcan constantes durante la ejecución del programa.

Observación 2: Variable final de referencia.

Cuando una variable final es una referencia a un objeto, entonces esta variable final se llama variable final de referencia . Por ejemplo, una final búfer de cadena La variable se ve definida a continuación de la siguiente manera:

final StringBuffer sb;>

Como todos sabemos, una variable final no se puede reasignar. Pero en el caso de una variable final de referencia, se puede cambiar el estado interno del objeto al que apunta esa variable de referencia. Tenga en cuenta que esto no es una reasignación.

Esta propiedad del final se llama no transitividad . Para comprender lo que se entiende por estado interno del objeto como se muestra en el siguiente ejemplo:

Ejemplo 1:

// Java Program to demonstrate // Reference of Final Variable // Main class class GFG {  // Main driver method  public static void main(String[] args)  {  // Creating an object of StringBuilder class  // Final reference variable  final StringBuilder sb = new StringBuilder('Geeks');  // Printing the element in StringBuilder object  System.out.println(sb);  // changing internal state of object reference by  // final reference variable sb  sb.append('ForGeeks');  // Again printing the element in StringBuilder  // object after appending above element in it  System.out.println(sb);  } }>

Geeks GeeksForGeeks>

El no transitividad La propiedad también se aplica a las matrices, porque matrices son objetos en Java. matrices con el palabra clave final también se llaman matrices finales .

Nota: Como se analizó anteriormente, una variable final no se puede reasignar, ya que al hacerlo se producirá un error en tiempo de compilación.

Ejemplo 2:

// Java Program to Demonstrate Re-assigning // Final Variable will throw Compile-time Error // Main class class GFG {  // Declaring and customly initializing  // static final variable  static final int CAPACITY = 4;  // Main driver method  public static void main(String args[])  {  // Re-assigning final variable  // will throw compile-time error  CAPACITY = 5;  } }>

Producción:

Recordar: Cuando se crea una variable final dentro de un método/constructor/bloque, se llama variable final local y debe inicializarse una vez donde se crea. Consulte el programa a continuación para conocer la variable final local.

lista java

Ejemplo:

// Java program to demonstrate // local final variable // Main class class GFG {  // Main driver method  public static void main(String args[])  {  // Declaring local final variable  final int i;  // Now initializing it with integer value  i = 20;  // Printing the value on console  System.out.println(i);  } }>

20>

Recuerde estos puntos clave tal como se perciben antes de seguir adelante, como se enumera a continuación:

1. Tenga en cuenta la diferencia entre C++ constante variables y Java final variables. las variables constantes en C++ deben ser se le asigna un valor cuando se declara . Para las variables finales en Java, es no es necesario como vemos en los ejemplos anteriores. A una variable final se le puede asignar valor más adelante, pero solo una vez.
2. final con bucle foreach : final con declaración para cada uno es una declaración legal.

Ejemplo:

// Java Program to demonstrate Final // with for-each Statement // Main class class GFG {  // Main driver method  public static void main(String[] args)  {  // Declaring and initializing  // custom integer array  int arr[] = { 1, 2, 3 };  // final with for-each statement  // legal statement  for (final int i : arr)  System.out.print(i + ' ');  } }>

1 2 3>

Explicación de salida: desde el i Si una variable sale del alcance con cada iteración del bucle, se vuelve a declarar en cada iteración, lo que permite utilizar el mismo token (i) para representar múltiples variables.

Ejemplo:

public class Example {  public static void main(String[] args) {  final int VALUE = 10; // declaring a final variable    System.out.println('The value is: ' + VALUE);  // VALUE = 20; // uncommenting this line will cause a compiler error  // System.out.println('The new value is: ' + VALUE);    final String MESSAGE = 'Hello, world!'; // declaring a final variable  System.out.println(MESSAGE);    MyClass myObj = new MyClass();  myObj.printMessage();  myObj.printFinalMessage();    // MyOtherClass extends MyClass {} // uncommenting this line will cause a compiler error  } } class MyClass {  final String message = 'Hello!'; // declaring a final instance variable    void printMessage() {  System.out.println(message);  }    void printFinalMessage() {  final String finalMessage = 'Hello, final!';  System.out.println(finalMessage);  } } final class MyOtherClass { // declaring a final class  // ... }>

The value is: 10 Hello, world! Hello! Hello, final!>

Clases finales de Java

Cuando se declara una clase con el final palabra clave en Java, se llama clase final . Una clase final no puede ser extendido (heredado) .

Hay dos usos de una clase final:

Uso 1: Uno es definitivamente prevenir herencia , ya que las clases finales no se pueden ampliar. Por ejemplo, todos Clases contenedoras como Entero , Flotar , etc. son clases finales. No podemos extenderlos.

final class A {  // methods and fields }   // The following class is illegal  class B extends A  {   // COMPILE-ERROR! Can't subclass A }>

Uso 2: El otro uso de final con clases es crear una clase inmutable como el predefinido Cadena clase. No se puede hacer que una clase sea inmutable sin hacerla definitiva.

Método final de Java

Cuando se declara un método con final palabra clave, se llama método final en Java. Un método final no puede ser anulado .

El Objeto La clase hace esto: varios de sus métodos son finales. Debemos declarar métodos con la palabra clave final para lo cual debemos seguir la misma implementación en todas las clases derivadas.

Ilustración: Palabra clave final con un método.

class A  {  final void m1()   {  System.out.println('This is a final method.');  } } class B extends A  {  void m1()  {     // Compile-error! We can not override   System.out.println('Illegal!');  } }>

Ventajas de la palabra clave final en Java:

La palabra clave final en Java proporciona varias ventajas, entre ellas:

• Garantizar la inmutabilidad: Cuando una variable o referencia está marcada como final, su valor no se puede cambiar una vez asignado. Esto ayuda a garantizar que los datos sean inmutables y no puedan modificarse accidental o maliciosamente.
• Mejorando el desempeño : El uso del final a veces puede ayudar a mejorar el rendimiento, ya que la Máquina Virtual Java (JVM) puede optimizar el código de manera más efectiva cuando sabe que ciertos valores o referencias no se pueden cambiar.
• Hacer que el código sea más fácil de entender: Al declarar variables, métodos o clases como finales, los desarrolladores pueden hacer que su código sea más fácil de entender y razonar. Cuando un valor o referencia se marca como final, está claro que no cambiará, lo que puede simplificar el análisis y la depuración del código.
• Promoción de la reutilización de código: Al declarar los métodos como finales, los desarrolladores pueden evitar que las subclases los anulen. Esto puede ayudar a promover la reutilización del código y reducir la duplicación, ya que las subclases deben usar la implementación del método de la clase principal.
• Mejora de la seguridad: El uso de final puede ayudar a mejorar la seguridad al evitar que el código malicioso modifique datos o comportamientos confidenciales.

En general, la palabra clave final es una herramienta útil para mejorar la calidad del código y garantizar que ciertos aspectos de un programa no puedan modificarse. Al declarar variables, métodos y clases como finales, los desarrolladores pueden escribir código más seguro, sólido y fácil de mantener.

Para más ejemplos y comportamiento de métodos finales y clases finales , por favor mira Usando final con herencia. Por favor vea el resumen en java artículo para las diferencias entre los final y el abstracto .

Pregunta de entrevista relacionada (importante): Diferencia entre final, finalmente y finalizar en Java

Conclusión

La palabra clave final en Java es un método para crear variables, métodos o clases restringidos al usuario. En este tutorial, cubrimos en detalle la última palabra clave de Java y comprendemos todos sus contextos.

Los contextos se explican con programas Java en ejemplos, proporcionando una comprensión completa del tema.

Palabra clave final de Java: preguntas frecuentes

¿Qué es un método final en Java?

Un método final en Java es un método declarado con la palabra clave final , lo que significa que las subclases no pueden anular su implementación.

¿Se hereda el método final?

No, en Java una subclase no puede heredar un método final. Esto significa que una subclase no se puede anular un método final .

¿Cuál es la palabra clave final y la palabra clave estática en Java?

Palabra clave final: Se utiliza para declarar variables, métodos o clases como no modificables.

Palabra clave estática: se utiliza para declarar miembros de una clase (variables y métodos) que pertenecen a la clase misma, no a objetos individuales.

¿Podemos escribir la palabra clave final con una cadena en Java?

Sí, puede declarar una variable con la palabra clave final y asignarle una cadena literal.