Lassen Sie uns zunächst über das Finale sprechen.
Das endgültige Schlüsselwort kann Variablen, Methoden und Klassen ändern.
Endgültige Variable:
brauchen:
Ich brauche eine Kompilierungskonstante, die sich nie ändert
2 Ein Wert, der zur Laufzeit initialisiert wurde und nicht geändert werden möchte
Vorteile: Berechnungen zur Kompilierung des Zeitpunkts, wodurch die Last der Laufzeit verringert wird
Erweiterungen:
Sie können grundlegende Typen und Referenzobjekte ändern. Bei der Änderung des Basistyps bedeutet dies, dass der Wert ziemlich konstant ist. Bei der Änderung einer Objektreferenz kann die Referenz initialisiert und auf ein Objekt hingewiesen werden, sondern kann nicht in ein anderes Objekt geändert werden (das Objekt selbst kann geändert werden).
Leeres Finale
Die Domäne, die durch endgültig geändert wird, aber nicht den Anfangswert angibt, muss dem endgültigen Wert unter Verwendung eines Ausdrucks in der Domänendefinition oder im Domänendefinition oder im Konstruktor ein Wert zugeordnet werden (die endgültige muss vor der Verwendung initialisiert werden)
Beachten:
Wenn ein Objekt gleichzeitig durch statische und endgültige Zeit (Kompilierungsperiodekonstante) geändert wird, wird es im Allgemeinen in Kapital und die Parameter der Unterstricheverbindungs -Wortmodifizierung ausgedrückt:
Wenn der endgültige Modify -Parameter ist, bedeutet dies, dass der Parameter lesbar ist, aber nicht geändert werden kann.
Verwendungsbeispiel:
private random rand = new random (); private static random random = new random (); private endgültige int n1 = 12; private endgültige int nummer = rand.nextint (30); private statische endgültige int nummer2 = 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"; Letzte Methode:
Das endgültige kann auch die Methode ändern, was darauf hinweist, dass die Methode nicht durch Unterklassen vererbt werden kann.
Vorteile der Verwendung endgültig:
1 Vor JDK1.5 war die Effizienz höher und nach JDK1.5 kann sie ignoriert werden
2 Methodensperrung, um sicherzustellen, dass die Bedeutung der Methode in der Unterklasse unverändert bleibt und nicht überschrieben werden kann. Beispiel der Nutzung:
public Final String FinalMethod () {return "Hallo Welt"; } Letzte Klasse:
Wenn Sie von keiner Klasse vererbt werden möchten, können Sie das Nutzungsbeispiel der Klasse endgültig ändern:
public Final Class Finalclasstx {private int k; public void getMyWord () {System. out .println ("Dies ist eine endgültige Klasse, der Wert von k ist" +getk ()); } public int getk () {return k;} public void setk (int k) {this .k = k;}} Dann vorübergehendes Schlüsselwort:
Transient kann nur Variablen ändern, was darauf hinweist, dass die Variable nicht serialisiert werden kann.
Im Allgemeinen erben wir die serialisierbare Schnittstellenklasse, und die Serialisierung wird automatisch durchgeführt. Wenn die durch transienten modifizierte Variable serialisiert wird, wird sie nicht zum angegebenen Ziel serialisiert.
Also,
1 Die durch Transient modifizierte Variable ist nicht mehr Teil der Objektpersistenz, und der Inhalt der Variablen ist serialisiert und kann nicht zugegriffen werden.
2 Transient kann nur Variablen ändern, nicht Methoden und Klassen
3 Beispiel für die Verwendung einer statischen Variablen, die nicht serialisiert werden kann, unabhängig davon, ob sie durch transient modifiziert wird:
public class transientex {public static void main (String [] args) {user user = new user (); user.SetUnername ("JEYSON"); user.setPassword ("123456"); System.out.println ("Vor der Serialisierung:"); System.out.println ("userername ="+user.getUnername ()); System.out.println ("password ="+user.getPassword ()); // Serialisierung try {ObjectOutputStream os = new ObjectOutputStream (neuer FileOutputStream ("c: //myresource//test1.txt")); os.writeObject (Benutzer); os.flush (); os.close (); } catch (Ausnahme e) {e.printstacktrace (); } // Deserialisierung try {ObjectInputStream ist = new ObjectInputStream (neuer FileInputStream ("c: //myresource//test1.txt")); user = (user) is.ReadObject (); IS.CLOSE (); System.out.println ("序列化后 ："); System.out.println ("userername ="+user.getUnername ()); System.out.println ("password ="+user.getPassword ()); } catch (Ausnahme e) {e.printstacktrace (); } System.out.println ("--------------------------------"); }} Klasse Benutzer implementiert serialisierbar {private statische endgültige long serialversionuid = 1l; privater String -Benutzername; // Transient Private Transient String Passwort verwenden; public String getUnername () {return userername; } public void setUnername (String -Benutzername) {this.username = userername; } public String getPassword () {Kennwort zurückgeben; } public void setPassword (String -Passwort) {this.password = password; }} Erweiterung: externalisierbar
Die Klasse, die die serialisierbare Schnittstelle implementiert, wird implementiert, sodass die Serialisierung automatisch die Klasse implementiert, die die Externaliazble -Schnittstelle implementiert. Nichts kann automatisch serialisiert werden, und ob die Verwendung von Transienten keinen Einfluss auf das Ergebnis hat oder nicht.
Wenn eine Serialisierung erforderlich ist, müssen Sie die Variable, die in der WriteExternal -Methode serialisiert werden soll, manuell angeben.
Beispiel der Nutzung:
public class externalizableex implementiert externalisierbar {private transiente String name = "ssss"; @Override public void ReadExternal (ObjectInput in) löst IOException, classNotFoundException {name = (string) in.ReadObject () aus; } @Override public void writeExternal (ObjectOutput Out) löst IOException {out.writeObject (Name) aus; } public String getName () {return name; } public void setName (String -Name) {this.name = name; } public static void main (String [] args) {externalizableex ex = new externalizableEx (); Ex.SetName ("Jeyson"); System.out.println ("externalisierbare Serialisierung:"); System.out.println (ex.getName ()); // Serialisierung try {ObjectOutputStream os = new ObjectOutputStream (neuer FileOutputStream (neue Datei ("c: //myresource//test2.txt"))); OS.WriteObject (Ex); os.flush (); os.close (); } catch (Ausnahme e) {e.printstacktrace (); } // Deserialisierung try {ObjectInputStream ist = new ObjectInputStream (neuer FileInputStream (neue Datei ("c: //myresource//test2.txt")); ex = (externalisierbar) ist.ReadObject (); IS.CLOSE (); System.out.println ("externalisierbare Serialisierung:"); System.out.println (ex.getName ()); } catch (Ausnahme e) {e.printstacktrace (); }}} Stellungnahme:
Der größte Teil des Finales stammt aus der vierten Ausgabe von "Java Programming Thoughts"
Referenzartikel: //www.vevb.com/article/86996.htm
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.