El papel de usar final para modificar los parámetros en Java
Agregar la palabra clave final antes de los parámetros del método es evitar que los datos se modifiquen en el peso del método.
Hay dos situaciones principales: primero, use final para modificar el tipo de datos básicos; En segundo lugar, use final para modificar el tipo de datos de referencia.
En el primer caso, modifique el tipo de datos básicos, en cuyo momento el valor del parámetro no puede modificarse en el cuerpo del método, es decir, no puede reasignarse. De lo contrario, la compilación no se pasará.
El segundo caso es modificar el tipo de referencia. En este momento, el objeto a la que se hace referencia por la variable del parámetro no se puede cambiar. Sin embargo, para los tipos de datos de referencia, está perfectamente bien modificar sus propiedades.
Por lo tanto, si desea usar la palabra clave final, use el tipo de datos básicos, que es muy útil.
Variable final:
Use final para tipos básicos: es una constante, el valor es constante y el valor permanece sin cambios.
Use final para las referencias del objeto: haga constante la referencia y una vez que la referencia se inicialice para apuntar a un objeto, no se puede cambiar para apuntar a otro objeto. Sin embargo, el objeto en sí puede modificarse, y Java no proporciona una forma de hacer que el objeto constante. Esta limitación también usa matrices, que son objetos.
ejemplo:
valor de clase {int i; Valor público (int i) {this.i = i; }} clase pública FinalData {private static aleation Random = new Random (47); ID de cadena privada; public FinalData (ID de cadena) {this.id = id; } private final int valueNone = 9; Private static final int value_two = 99; public static final int value_three = 39; Private final int i4 = random.nextint (20); static final int_5 = random.nextint (20); valor privado v1 = nuevo valor (11); valor final privado v2 = nuevo valor (22); valor final estático privado val_3 = nuevo valor (33); Private final int [] a = {1, 2, 3, 4, 5, 6}; public String toString () {return id + ":" + "i4 =" + i4 + ", int_5 =" + int_5; } public static void main (string [] args) {finalData fd1 = new FinalData ("FD1"); //! FD1.ValueOne ++; // Debido a que ValueOne es una constante de tipo básico, su valor es constante fd1.v2.i ++; // El contenido del objeto modificado por final se puede cambiar fd1.v1 = nuevo valor (9); para (int i = 0; i <fd1.a.length; i ++) fd1.a [i] ++; //! fd1.v2 = nuevo valor (0); // Debido a que V2 es un tipo de referencia modificado por final, su referencia no puede modificarse para apuntar a otro objeto //! fd1.val_3 = nuevo valor (1); // Ocupa un espacio de memoria que no se puede cambiar //! fd1.a = new int [3]; // matriz modificada final System.out.println (FD1); System.out.println ("Creación de nuevos Datos finales"); FinalData fd2 = new FinalData ("FD2"); System.out.println (FD1); System.out.println (FD2); }}/*salida: fd1: i4 = 15, int_5 = 18creating nuevo finalDatafd1: i4 = 15, int_5 = 18fd2: i4 = 13, int_5 = 18*/analizar:
Para FD1, FD2, dos objetos, i4 es único, es decir, cada objeto tiene un i4, pero int_5 se declara estático, es decir, es compartido por la clase, FD1 y FD2 comparten int_5, que se inicializa en el momento de la carga, en lugar de inicializar cada vez que se crea un nuevo objeto (por ejemplo, I4); Pero está configurado para final al mismo tiempo, por lo que su referencia es inmutable, es decir, no se puede modificar para señalar a otro objeto.
Final en blanco:
se declara como final pero no tiene valor inicial dado. Final debe asignarse utilizando expresiones en la definición del dominio o en cada constructor, por lo que el dominio final siempre se inicializa antes de su uso.
Parámetros finales:
Esto significa que no puede cambiar la referencia del parámetro en el método para señalar a otro parámetro, pero puede modificar a qué apunta el objeto final
ejemplo:
clase Gizmo {int i = 0; public void spin () {}} public class FinalArGuments {void with (final gizmo g) {//! g = nuevo GizMo (); // La referencia modificada por final no se modifica para apuntar a otro objeto g.i ++; // pero el contenido apuntado por el objeto final puede modificarse} void sin (gizmo g) {g = new GizMo (); g.spin (); } // int g (final int i) {// //! i ++; // porque el parámetro I es un valor constante //} int g (final int i) {return i + 1; } public static void main (string [] args) {fininalArGuments bf = new FininalArGuments (); bf.with (nulo); bf.with (nulo); }}analizar:
El parámetro se declara como final. Si es un parámetro básico, es una constante y no se puede modificar; Si se trata de una variable de referencia, no se puede modificar para señalar a otro objeto, pero el contenido del objeto mencionado por la referencia puede modificarse.
Método Fianl:
Razón de uso:
Todos los métodos privados en la clase se especifican implícitamente como finales, y dado que el método privado no se puede usar, no se puede sobrescribir. Se puede agregar un modificador final al método privado, pero esto no da ningún significado adicional al método.
ejemplo:
clase WithFinals {private final void f () {system.out.println ("withfinals.f ()"); } private void g () {system.out.println ("overridingprivate.f ()"); }} La clase sobreprivingPrivate se extiende con finales {private final void f () {system.out.println ("overridingprivate.f ()"); }} La clase anverningPrivate2 se extiende a través de overridingprivate { /** Cuando se usa la anotación de anulación para forzar el método f () para sobrescribir el método f () de la clase principal, se informará un error* porque no sabe si la clase principal tiene el método. Para el método G (), solo genera un nuevo método y * no sobrescribe el método G () en la clase principal. *///@override public final void f () {system.out.println ("overridingprivate2.f ()"); } public void g () {system.out.println ("overridingprivate2.g ()"); }} clase pública FinalOverridingIllusion {public static void main (string [] args) {overridingprivate2 op2 = new overindingPrivate2 (); op2.f (); op2.g (); // Puede transformar hacia arriba sobre la prima de primaria OP = OP2; //! op.f (); // El método final en la clase principal es invisible para la subclase //! op.g (); Con finales wf = op2; // wf.f (); // wf.g (); }}/*salida: overridingprivate2.f () overridingprivate2.g ()*/analizar:
¿Cuándo ocurre la cobertura?
1. Métodos que aparecen en subclases que son exactamente los mismos que los de las clases de los padres
2. Una subclase puede transformarse en una clase principal hacia arriba y llamar al método en la clase principal
Si un método en la clase principal se declara como final o privado, entonces este método es invisible para la subclase. Incluso si se crea un método exactamente igual que la clase principal en la subclase, este es un método nuevo, en lugar de un método anulado a la clase principal.
Clase final:
Es decir, esta clase no puede ser heredada, ya sea usted u otros, es decir, esta clase no requiere ningún cambio, ni requiere subclases, como la clase de cadena.
ejemplo:
Clase SmallBrain {} final de clase Dinosaur {int i = 7; int j = 1; SmallBrain x = nuevo SmallBrain (); void f () {}} // Error: el tipo además no puede subclasificar la clase final de la clase // clase de dinosaurio no puede tener subclases // clase extiende aún más dinosaurio {} public class Jurassic {public static void main (string [] args) {dinosaur n = nuevo dinosaurio (); nf (); ni = 40; N.J ++; }}Resumir
Lo anterior es todo el contenido de este artículo. Espero que el contenido de este artículo tenga cierto valor de referencia para el estudio o el trabajo de todos. Si tiene alguna pregunta, puede dejar un mensaje para comunicarse. Gracias por su apoyo a Wulin.com.