final (Java)

En el lenguaje de programación Java , la finalpalabra clave se utiliza en varios contextos para definir una entidad que solo se puede asignar una vez.

Una vez finalque se asigna un valor a una variable, se espera que siempre contenga el mismo valor. Si una finalvariable contiene una referencia a un objeto, el estado de este puede modificarse mediante operaciones sobre él, pero la variable siempre hará referencia al mismo objeto (esta propiedad finalse denomina no transitividad ^{[ 1 ]} ). Esto también se aplica a los arreglos, ya que estos son objetos; si una finalvariable contiene una referencia a un arreglo, los componentes del arreglo pueden modificarse mediante operaciones sobre él, pero la variable siempre hará referencia al mismo arreglo ^{[ 2 ] .}

Una clase final no puede tener subclases. Dado que esto puede brindar beneficios de seguridad y eficiencia, muchas de las clases de la biblioteca estándar de Java son finales, como java.lang.Systemy java.lang.String.

Ejemplo:

clase final Final { // ... }// Clase prohibida Derived extiende Final { // ... }

Un método final no puede ser sobrescrito ni ocultado por subclases. ^{[ 3 ]} Esto se utiliza para evitar un comportamiento inesperado cuando una subclase modifica un método que puede ser crucial para la función o la consistencia de la clase. ^{[ 4 ]}

Ejemplo:

public class Base { public void foo () { // ... }public final void bar () { // ... }public static void baz () { // ... }public static final void qux () { // ... } }public class Derived extends Base { // OK, sobrescribiendo Base::foo() @Override public void foo () { // ... }// prohibido @Override public void bar () { // ... }// OK, sobrescribiendo Base::baz() @Override public static void baz () { // ... }// prohibido @Override public static void qux () { // ... } }

Una idea errónea común es que declarar un método como `inline` finalmejora la eficiencia al permitir que el compilador lo inserte directamente dondequiera que se llame (véase expansión en línea ). Dado que el método se carga en tiempo de ejecución , los compiladores no pueden hacer esto. Solo el entorno de ejecución y el compilador JIT saben exactamente qué clases se han cargado, por lo que solo ellos pueden tomar decisiones sobre cuándo realizar la expansión en línea, independientemente de si el método es final o no. ^{[ 5 ]}

Los compiladores de código máquina que generan código máquina específico de la plataforma y ejecutable directamente son una excepción. Al usar el enlace estático , el compilador puede asumir con seguridad que los métodos y variables computables en tiempo de compilación pueden insertarse en línea.

Una variable final solo puede inicializarse una vez, ya sea mediante un inicializador o una instrucción de asignación. No es necesario inicializarla en el momento de la declaración: esto se denomina variable "final vacía". Una variable de instancia final vacía de una clase debe asignarse definitivamente en cada constructor de la clase en la que se declara; de forma similar, una variable estática final vacía debe asignarse definitivamente en un inicializador estático de la clase en la que se declara; de lo contrario, se produce un error de compilación en ambos casos. ^{[ 6 ]} (Nota: Si la variable es una referencia, esto significa que no se puede volver a enlazar para que haga referencia a otro objeto. Pero el objeto al que hace referencia sigue siendo mutable , si originalmente lo era).

A diferencia del valor de una constante , el valor de una variable final no necesariamente se conoce en tiempo de compilación. Se considera una buena práctica representar las constantes finales en mayúsculas, utilizando guiones bajos para separar las palabras. ^{[ 7 ]}

Ejemplo:

public class Sphere { // Pi es una constante universal, tan constante como puede ser cualquier cosa. public static final double PI = 3.141592653589793 ;public final double radio ; public final double xPos ; public final double yPos ; public final double zPos ;Esfera ( doble x , doble y , doble z , doble r ) { radio = r ; xPos = x ; yPos = y ; zPos = z ; }// ... }

Cualquier intento de reasignar radius, xPos, yPos, o zPosdará como resultado un error de compilación. De hecho, incluso si el constructor no establece una variable final, intentar establecerla fuera del constructor dará como resultado un error de compilación .

Para ilustrar que la finalidad no garantiza la inmutabilidad: supongamos que reemplazamos las tres variables de posición por una sola:

Posición final pública pos ;

donde poses un objeto con tres propiedades pos.x, pos.yy pos.z. Entonces posno se le puede asignar nada, pero las tres propiedades sí, a menos que sean finales en sí mismas.

Al igual que la inmutabilidad total , el uso de variables finales ofrece grandes ventajas, especialmente en la optimización. Por ejemplo, Sphereprobablemente habrá una función que devuelva su volumen; saber que su radio es constante nos permite memorizar el volumen calculado. Si tenemos relativamente pocos Sphereobjetos y necesitamos sus volúmenes con mucha frecuencia, la mejora en el rendimiento podría ser sustancial. Hacer que el radio de un objeto Spherefinalinforme a los desarrolladores y compiladores de que este tipo de optimización es posible en todo el código que utiliza Sphereobjetos.

Aunque parezca contravenir el finalprincipio, la siguiente es una declaración legal:

for ( final SomeObject obj : someList ) { // hacer algo con obj }

Dado que la objvariable queda fuera de ámbito con cada iteración del bucle, en realidad se vuelve a declarar en cada iteración, lo que permite que el mismo token (es decir, obj) se utilice para representar múltiples variables. ^{[ 8 ]}

import java.awt.Point ;clase pública FinalDemo {clase estática Sistema de coordenadas { privado final Punto ORIGEN = nuevo Punto ( 0 , 0 );public Point getOrigin () { return ORIGIN ; } }public static void main ( String [] args ) { CoordinateSystem coordinateSystem = new CoordinateSystem ();sistemaCoordenadas.obtenerOrigen ( ) . x = 15 ;assert coordinateSystem.getOrigin ( ). getX ( ) == 0 ; } }

paquete org.wikipedia.examples ;import javax.swing.JButton ; import javax.swing.JFrame ; import javax.swing.SwingUtilities ;public class FooGUI { public static void main ( String [] args ) { // inicializar componentes de la interfaz gráfica final JFrame jf = new JFrame ( "Hello world!" ); // permite acceder a jf desde el cuerpo de la clase interna jf . add ( new JButton ( "Click me" ));// Empaquetar y hacer visible en el hilo de despacho de eventos SwingUtilities.invokeLater ( new Runnable ( ) { @Override public void run () { jf.pack ( ) ; // Esto sería un error de compilación si jf no fuera final jf.setLocationRelativeTo ( null ) ; jf.setVisible ( true ) ; } }) ; } }

final boolean hasTwoDigits ; if ( number >= 10 && number < 100 ) { hasTwoDigits = true ; } if ( number > -100 && number <= -10 ) { // error de compilación porque la variable final podría ya estar asignada. hasTwoDigits = true ; }

booleano final es par ;Si ( número % 2 == 0 ) { es par = verdadero ; }// Error de compilación porque la variable no se asignó en el caso else. System.out.println ( isEven );

booleano esPar ; // NO finalSi ( número % 2 == 0 ) { es par = verdadero ; }// Mismo error de compilación porque la variable no final no se asignó en el caso else. System.out.println ( isEven );

Aunque los campos finales inicializados están diseñados para ser inmutables, en realidad pueden modificarse mediante reflexión. El java.lang.reflectpaquete contiene métodos que permiten acceder a cualquier campo y modificarlo. Se prevé eliminar esta funcionalidad en una futura versión de Java en 2026. ^{[ 12 ]}

En C y C++ , la construcción análoga es la constpalabra clave . Esto difiere sustancialmente de finalen Java, principalmente en que es un calificador de tipo : constes parte del tipo , no solo parte del identificador (variable). Esto también significa que la constancia de un valor puede cambiarse mediante conversión explícita de tipo , en este caso conocida como "const casting". Sin embargo, convertir la constancia y luego modificar el objeto resulta en un comportamiento indefinido si el objeto fue declarado originalmente como const. Java finales una regla estricta de tal manera que es imposible compilar código que rompa o eluda directamente las restricciones finales. Sin embargo, usando reflexión , a menudo es posible modificar variables finales. Esta característica se usa principalmente al deserializar objetos con miembros finales.

Además, debido a que C y C++ exponen punteros y referencias directamente, existe una distinción entre si el puntero en sí es constante y si los datos a los que apunta el puntero son constantes. Aplicar `const` consta un puntero en sí, como en `<const>` SomeClass* const ptr, significa que el contenido al que se hace referencia puede modificarse, pero la referencia en sí no (sin conversión de tipo). Este uso da como resultado un comportamiento que imita el comportamiento de una finalreferencia a una variable en Java. Por el contrario, cuando se aplica `const` solo a los datos referenciados, como en ` const SomeClass* ptr<const>`, el contenido no puede modificarse (sin conversión de tipo), pero la referencia en sí sí. Tanto la referencia como el contenido al que se hace referencia pueden declararse como `const` const.

En C++, la finalpalabra clave se utiliza para indicar que una función no puede ser sobrescrita. También se usa de forma similar a Java para declarar una clase como final (no se puede extender).

// final en una declaración de clase declara que una clase no puede ser extendida class Z final : public X , public Y { public : // final en la firma de un método declara que un método no puede ser sobrescrito más void someOperation () override final { // hacer algo aquí } };

C# puede considerarse similar a Java en términos de sus características de lenguaje y sintaxis básica: Java tiene JVM, C# tiene .Net Framework ; Java tiene bytecode , C# tiene CIL ; Java no tiene soporte para punteros (memoria real), C# es igual.

En cuanto a la última palabra clave, C# tiene dos palabras clave relacionadas:

1. La palabra clave equivalente para métodos y clases essealed
2. La palabra clave equivalente para variables es readonly^{[ 13 ].}

Tenga en cuenta que una diferencia clave entre la palabra clave derivada de C/C++ consty la palabra clave de C# readonlyes que constse evalúa en tiempo de compilación, mientras que readonlyse evalúa en tiempo de ejecución, y por lo tanto puede tener una expresión que solo se calcula y se corrige más tarde (en tiempo de ejecución).

• final (C++)