Tout d'abord, parlons de final.
Le mot-clé final peut modifier les variables, les méthodes et les classes .
Variable finale:
besoin:
1 besoin d'une constante de temps de compilation qui ne change jamais
2 Une valeur initialisée au moment de l'exécution, ne voulant pas être modifiée
Avantages: calcul exécuté au moment de la compilation, réduisant le fardeau de l'exécution
Extensions:
Vous pouvez modifier les types de base et les objets de référence. Lors de la modification du type de base, cela signifie que la valeur est assez constante. Lors de la modification d'une référence d'objet, une fois la référence initialisée et pointée vers un objet, il ne peut pas être changé en un autre objet (l'objet lui-même peut être modifié)
Final vide
Le domaine qui est modifié par Final mais ne donne pas la valeur initiale doit se voir attribuer une valeur à la finale en utilisant une expression dans la définition du domaine ou le constructeur (final doit être initialisé avant utilisation)
Avis:
Si un objet est modifié par statique et final en même temps (constante de période de compilation), il est généralement exprimé en capital et les paramètres de modification du mot de liaison de liaison:
Si le paramètre de modification final, cela signifie que le paramètre est lisible mais ne peut pas être modifié.
Exemple d'utilisation:
Private Random Rand = new Random (); Random random statique privé = nouveau aléatoire (); Final privé int n1 = 12; Numéro fin final privé = rand.nextint (30); private static final int number2 = random.nextint (40); @Test public void finalDatatest () {System.out.println (n1); System.out.println ("-----------------------------------"); System.out.println (Rand.Nextint (30)); System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- * @param sk * @return * / public string finalParam (final string sk) {// sk = "jeyson"; Méthode finale:
Final peut également modifier la méthode, indiquant que la méthode ne peut pas être héritée par les sous-classes.
Avantages de l'utilisation de la finale:
1 Avant JDK1.5, l'efficacité était plus élevée, et après JDK1.5, il peut être ignoré
2 Verrouillage de la méthode pour garantir que la signification de la méthode dans la sous-classe reste inchangée et ne peut pas être écrasée. Exemple d'utilisation:
Public Final String finalMethod () {return "Hello World"; } Classe finale:
Si vous ne souhaitez être hérité par aucune classe, vous pouvez utiliser Final pour modifier l'exemple d'utilisation de la classe:
Classe finale publique FinalClasstx {private int k; public void getMyWord () {System. out .println ("Ceci est une classe finale, la valeur de k est" + getk ()); } public int getk () {return k;} public void setk (int k) {this .k = k;}} Puis mot-clé transitoire:
Le transitoire ne peut modifier que des variables, indiquant que la variable ne peut pas être sérialisée.
Généralement, nous héritons de la classe d'interface sérialisable et la sérialisation sera effectuée automatiquement. Lorsque la variable modifiée par transitoire est sérialisée, elle ne sera pas sérialisée dans la destination spécifiée.
donc,
1 La variable modifiée par transitoire ne fait plus partie de la persistance de l'objet, et le contenu de la variable est sérialisé et n'est pas accessible.
2 transitoire ne peut modifier que des variables, pas des méthodes et des classes
3 Exemple d'utilisation d'une variable statique qui ne peut pas être sérialisée, qu'elle soit modifiée par transitoire:
classe publique Transientex {public static void main (String [] args) {user user = new user (); user.setUsername ("Jeyson"); user.setpassword ("123456"); System.out.println ("Avant la sérialisation:"); System.out.println ("username =" + user.getUserName ()); System.out.println ("Password =" + user.getPassword ()); // sérialisation try {objectOutputStream os = new ObjectOutputStream (new FileOutputStream ("c: //myresource//test1.txt")); OS.WriteObject (utilisateur); os.flush (); os.close (); } catch (exception e) {e.printStackTrace (); } // Deserialization try {objectInputStream est = new ObjectInputStream (new FileInputStream ("c: //myresource//test1.txt")); user = (user) 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 ("--------------------------------"); }} Classe User implémente Serializable {private static final long SerialVersionUID = 1l; Nom d'utilisateur de chaîne privée; // Utiliser le mot de passe de chaîne transitoire privée transitoire; public String getUserName () {return username; } public void setUsername (String username) {this.userName = username; } public String getPassword () {return mot de passe; } public void setPassword (String Motword) {this.password = mot de passe; }} Extension: externalisable
La classe qui implémente l'interface sérialisable est implémentée, de sorte que la sérialisation implémentera automatiquement la classe qui implémente l'interface externaliazble. Rien ne peut être automatiquement sérialisé et si l'utilisation de Transient n'a aucun effet sur le résultat.
Si la sérialisation est requise, vous devez spécifier manuellement la variable à sérialiser dans la méthode WriteExternal.
Exemple d'utilisation:
classe publique ExternalizableEx implémente externalisable {private transity String name = "ssss"; @Override public void readExternal (objectInput in) lève ioException, classNotFoundException {name = (string) in.readObject (); } @Override public void writeExternal (objectOutput out) lève ioException {out.writeObject (name); } public String getName () {Nom de retour; } public void setName (string name) {this.name = name; } public static void main (String [] args) {externalizableEx ex = new externalizableEx (); ex.setName ("Jeyson"); System.out.println ("sérialisation externalisable:"); System.out.println (ex.getName ()); // sérialisation try {objectOutputStream os = new ObjectOutputStream (new FileOutputStream (nouveau fichier ("c: //myresource//test2.txt"))); os.writeObject (ex); os.flush (); os.close (); } catch (exception e) {e.printStackTrace (); } // Deserialization try {objectInputStream est = new ObjectInputStream (new FileInputStream (nouveau fichier ("c: //myresource//test2.txt"))); ex = (externalizableEx) is.readObject (); is.close (); System.out.println ("sérialisation externalisable:"); System.out.println (ex.getName ()); } catch (exception e) {e.printStackTrace (); }}} déclaration:
La majeure partie de la finale vient de la quatrième édition de "Java Programming Thoughts"
Article de référence: //www.vevb.com/article/86996.htm
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.