Primero, hablemos de la final.
La palabra clave final puede modificar variables, métodos y clases .
Variable final:
necesidad:
Necesito una constante de tiempo de compilación que nunca cambie
2 Un valor inicializado en tiempo de ejecución, no querer ser cambiado
Beneficios: Calculas ejecutadas en el momento de la compilación, reduciendo la carga en el tiempo de ejecución
Extensiones:
Puede modificar tipos básicos y objetos de referencia. Al modificar el tipo básico, significa que el valor es bastante constante. Al modificar una referencia de objeto, una vez que la referencia se inicializa y apunta a un objeto, no se puede cambiar a otro objeto (el objeto en sí puede modificarse)
Final en blanco
El dominio que se modifica por final pero no da el valor inicial se le debe asignar un valor a la final utilizando una expresión en la definición o constructor de dominio (final debe inicializarse antes de usar)
Aviso:
Si un objeto se modifica por estática y final al mismo tiempo (período de compilación constante), generalmente se expresa en capital y los parámetros de modificación de palabras de enlace inferior:
Si el parámetro de modificación final, significa que el parámetro es legible pero no se puede modificar.
Ejemplo de uso:
Rand aleatorio privado = new Random (); privado static aleatorio = new Random (); Private final int n1 = 12; Private Final Int Number = Rand.NextInt (30); Private static final int número2 = random.nextInt (40); @Test public void FinalDatate () {System.out.println (n1); System.out.println ("-----------------------------------"); System.out.println (rand.nextint (30)); System.out.println ("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------- * @param sk * @return */public String FinalParam (String final SK) {// SK = "JEYSON"; Método final:
Final también puede modificar el método, lo que indica que el método no puede ser heredado por subclases.
Beneficios del uso final:
1 Antes de JDK1.5, la eficiencia fue mayor, y después de JDK1.5, se puede ignorar
2 Bloqueo del método para garantizar que el significado del método en la subclase permanezca sin cambios y no se pueda sobrescribir. Ejemplo de uso:
public Final String FinalMethod () {return "Hello World"; } Clase final:
Si no desea ser heredado por ninguna clase, puede usar final para modificar el ejemplo de uso de clase:
Public Final Clase FinalClasstx {private int k; public void getMyword () {sistema. out .println ("Esta es una clase final, el valor de k es" +getk ()); } public int getk () {return k;} public void setk (int k) {this .k = k;}} Luego palabra clave transitoria:
Transitorio solo puede modificar variables, lo que indica que la variable no puede ser serializada.
En general, heredamos la clase de interfaz serializable, y la serialización se realizará automáticamente. Cuando la variable modificada por transitorio se está serializada, no se serializará al destino especificado.
entonces,
1 La variable modificada por transitorio ya no es parte de la persistencia del objeto, y el contenido de la variable se está serializado y no se puede acceder.
2 transitorio solo puede modificar variables, no métodos y clases
3 Ejemplo de uso de una variable estática que no se puede serializar independientemente de si es modificado por transitorio:
public class Transientex {public static void main (string [] args) {user user = new user (); user.setUsername ("Jeyson"); user.setPassword ("123456"); System.out.println ("Antes de serialización:"); System.out.println ("username ="+user.getUsername ()); System.out.println ("Password ="+user.getPassword ()); // Serialización intenta {ObjectOutputStream OS = New ObjectOutputStream (new FileOutputStream ("c: //myresource//test1.txt")); OS.WriteObject (usuario); OS.Flush (); os.close (); } catch (Exception e) {E.PrintStackTrace (); } // Deserialización Try {ObjectInputStream IS = New ObjectInputStream (new FileInputStream ("c: //myResource//test1.txt")); user = (usuario) IS.ReadObject (); is.close (); System.out.println ("序列化后 ："); System.out.println ("username ="+user.getUsername ()); System.out.println ("Password ="+user.getPassword ()); } catch (Exception e) {E.PrintStackTrace (); } System.out.println ("--------------------------------"); }} clase El usuario implementa serializable {private static final long serialversionUid = 1l; nombre de usuario de cadena privada; // Use contraseña transitoria de cadena transitoria privada; public String getUsername () {return UserName; } public void setUsername (String UserName) {this.Username = username; } public String getPassword () {return Password; } public void setPassword (String Password) {this.password = contraseña; }} Extensión: externalizable
Se implementa la clase que implementa la interfaz serializable, por lo que la serialización implementará automáticamente la clase que implementa la interfaz externaliaZble. Nada se puede serializar automáticamente, y si el uso de transitorios no tiene ningún efecto en el resultado.
Si se requiere serialización, debe especificar manualmente la variable que se serializa en el método WriteExternal.
Ejemplo de uso:
Public Class OutrealizableEx implementa Externalizable {private Transient String Name = "SSSS"; @Override public void ReadExternal (ObjectInput in) lanza IOException, ClassNotFoundException {name = (String) in.readObject (); } @Override public void writeExternal (ObjectOutput out) lanza ioexception {out.writeObject (nombre); } public String getName () {nombre de retorno; } public void setName (nombre de cadena) {this.name = name; } public static void main (string [] args) {externalizableEx ex = new ExtereseizableEx (); Ex.SetName ("Jeyson"); System.out.println ("Serialización externalizable:"); System.out.println (ex.getName ()); // Serialization intenta {ObjectOutputStream OS = New ObjectOutputStream (new FileOutputStream (nuevo archivo ("c: //myresource//test2.txt"))); OS.WriteObject (ex); OS.Flush (); os.close (); } catch (Exception e) {E.PrintStackTrace (); } // Deserialización Try {ObjectInputStream is = New ObjectInputStream (new FileInputStream (nuevo archivo ("c: //myresource//test2.txt"))); ex = (externalizableEx) is.ReadObject (); is.close (); System.out.println ("Serialización externalizable:"); System.out.println (ex.getName ()); } catch (Exception e) {E.PrintStackTrace (); }}} declaración:
La mayor parte de la final proviene de la cuarta edición de "Java Programming Pensings"
Artículo de referencia: //www.vevb.com/article/86996.htm
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.