Het tijdelijke trefwoord in Java

1. Inleiding

In dit artikel zullen we eerst de voorbijgaand trefwoord, en dan zullen we het gedrag zien aan de hand van voorbeelden.

2. Gebruik van voorbijgaand

Laten we eerst de serialisatie begrijpen voordat we naar voorbijgaand zoals het wordt gebruikt in de context van serialisatie.

Serialisatie is het proces waarbij een object wordt omgezet in een bytestroom, en deserialisatie is het tegenovergestelde ervan.

Wanneer we een variabele markeren als voorbijgaand, dan is die variabele niet geserialiseerd. Daarom negeert het serialiseringsproces de oorspronkelijke waarde van de variabelen en worden de standaardwaarden voor dat gegevenstype opgeslagen.

De voorbijgaand trefwoord is handig in een paar scenario's:

  • We kunnen het gebruiken voor afgeleide velden
  • Het is handig voor velden die niet de staat van het object vertegenwoordigen
  • We gebruiken het voor alle niet-serialiseerbare referenties

3. Voorbeeld

Om het in actie te zien, maken we eerst een Boek klasse waarvan we het object willen serialiseren:

public class Book implementeert Serializable {private static final long serialVersionUID = -2936687026040726549L; private String bookName; privé voorbijgaande String beschrijving; privé tijdelijke int kopieën; // getters en setters}

Hier hebben we gemarkeerd Omschrijving en kopieën net zo voorbijgaand velden.

Nadat we de klasse hebben gemaakt, maken we een object van deze klasse:

Boek boek = nieuw boek (); book.setBookName ("Java-referentie"); book.setDescription ("zal niet worden opgeslagen"); book.setCopies (25);

Nu gaan we het object serialiseren in een bestand:

public static void serialize (boekboek) gooit uitzondering {FileOutputStream-bestand = nieuwe FileOutputStream (bestandsnaam); ObjectOutputStream out = nieuw ObjectOutputStream (bestand); out.writeObject (boek); out.close (); bestand.close (); }

Laten we het object nu uit het bestand deserialiseren:

openbaar statisch boek deserialize () gooit uitzondering {FileInputStream-bestand = nieuwe FileInputStream (bestandsnaam); ObjectInputStream in = nieuwe ObjectInputStream (bestand); Boek boek = (Boek) in.readObject (); in.close (); bestand.close (); retourboek; }

Ten slotte verifiëren we de waarden van de boek voorwerp:

assertEquals ("Java-referentie", book.getBookName ()); assertNull (book.getDescription ()); assertEquals (0, book.getCopies ());

Hier zien we dat bookName correct is gehandhaafd. Aan de andere kant is het kopieën veld heeft waarde 0 en de Omschrijving is nul - de standaardwaarden voor hun respectievelijke gegevenstypen - in plaats van de originele waarden.

4. Gedrag met laatste

Laten we nu eens kijken naar een speciaal geval waarin we zullen gebruiken voorbijgaand met de laatste trefwoord. Daarvoor voegen we eerst een laatste voorbijgaande element in onze Boek class en maak vervolgens een leeg Boek voorwerp:

public class Book implementeert Serializable {// bestaande velden private final transient String bookCategory = "Fiction"; // getters en setters}
Boek boek = nieuw boek ();

Wanneer we de waarden verifiëren na de deserialisatie, zullen we dat observeren voorbijgaand werd genegeerd voor dit veld en de oorspronkelijke waarde bleef behouden:

assertEquals ("Fictie", book.getBookCategory ());

5. Conclusie

In dit artikel hebben we het gebruik van de voorbijgaand trefwoord en zijn gedrag bij serialisatie en deserialisatie. We hebben ook het andere gedrag gezien met de laatste trefwoord.

Zoals altijd is alle code beschikbaar op GitHub.