Explicación detallada del uso de palabras clave finales en Java

Significado final

Final es una palabra clave de retención en Java, que puede declarar variables, métodos y clases miembros. Una vez que cotice la declaración como el tipo final, no volverá a cambiar esta referencia. El compilador verificará el código.
variable final

Cualquier variable o variable local (en el método o bloque de código se denomina declaración de variable local) para las variables de membresía o variables locales se denominan variables finales. El siguiente es un ejemplo de la variable del modificador final:

 Final intValue = 1;

Punto de suplemento:

• Las variables del miembro final deben inicializarse o inicializarse en el constructor cuando se declaran, de lo contrario, el compilador informará un error.
• No se puede asignar a la variable final nuevamente.
• Todas las variables en categorías anónimas deben ser la variable final.

método final

Final también puede declarar el método. El nombre del método se agrega con la palabra clave final, lo que significa que este método no puede reescribirse por subclases. Si cree que la función de un método está completa y el método no necesita cambiar el método en la subclase, puede declarar el método como el tipo final.
El método declarado por final es más rápido que el método no final, porque ha sido unión estática al compilarse, y no necesita unirse dinámicamente en tiempo de ejecución. El siguiente es un ejemplo del método final:

 Persona de clase pública {public Final void printName () {System.out.println ("Wangzhengyi");}}

clase final

La clase de clase modificada se llama clase final. La clase final generalmente está completa y no se pueden heredar. Muchas clases en Java son finales, como las clases de cadena.

Uno de los beneficios de las categorías no disponibles es que es una seguridad de hilo. Para crear categorías no disponibles, se deben lograr los siguientes pasos:

• Declarar la clase a la final para que no se pueda heredar.
• Todos los miembros declaran como privados, de modo que estos miembros no están permitidos directamente.
• No proporcione el método Setter para las variables.
• Indique todos los miembros variables a la final, para que solo puedan asignarlos una vez.
• Inicialice a todos los miembros por constructor y copia profunda.
• En el método Getter, no regrese directamente al objeto en sí, sino a la copia del objeto de clonación y regrese al objeto.

Nota: La diferencia entre copia superficial y copia profunda:

Copia superficial (clonación superficial): todas las variables del objeto replicado contienen el mismo valor que el objeto original, y las referencias de todos los demás objetos aún apuntan al objeto original. En otras palabras, solo se copian los tipos básicos de objetos, y el tipo de objetos aún pertenece a la cita original.
Copia profunda (clonación profunda): todas las variables copiadas contienen el mismo valor que el objeto original, elimine las variables que cotizan otros objetos. Las variables que cotizan otros objetos apuntarán a nuevos objetos que se han copiado, y ya no se hace referencia a los objetos originales. En otras palabras, no solo los tipos básicos de objetos, sino también los objetos en el objeto original.

Ejemplos inshenables:

 Import java.util.hashmap; String getName () {Return Name;} / *** Objetos variables: Copiar del objeto de retorno* @return* / public Hashmap <Integer, String> Gethmap () {Rashmap <Integer, ST. );} / ... Tmap = new HashMap <Integer, String> (); , map.get (key));} this.hmap = tmap;} /*** Una implementación de copias poco profundas* / /* public FinalClassExample (int id, name de cadena, hashmap <intt eger, string> map) {this .id = id;

Beneficios finales de palabras clave

Las ventajas de usar las palabras clave finales son las siguientes:

• Las palabras clave finales mejoran el rendimiento. Las aplicaciones JVM y Java almacenan en caché la variable final.
• Las variables finales se pueden compartir de manera segura en entornos múltiples sin gastos sin gastos sincrónicos adicionales.
• Con la palabra clave final, JVM optimizará métodos, variables y clases.