Transient en langage Java n'est pas aussi connu que les mots-clés class, synchronisé et autres mots-clés familiers, il apparaîtra donc dans certaines questions d'entretien. Dans cet article, je vais vous expliquer le transitoire.
Q : Que peut accomplir le mot-clé transient ?
A : Lorsque l'objet est sérialisé (écriture de la séquence d'octets dans le fichier cible), transitoire empêche les variables déclarées avec ce mot-clé dans l'instance d'être conservées lorsque l'objet est désérialisé (à partir de la lecture du fichier source ; la séquence d'octets pour la reconstruction), ces valeurs de variables d'instance ne seront pas conservées et restaurées. Par exemple, lors de la désérialisation d'un objet, un flux de données (par exemple, un fichier) peut ne pas exister, la raison en est qu'il existe des variables de type java.io.InputStream dans votre objet et que les flux d'entrée référencés par ces variables ne peuvent pas être ouvert pendant la sérialisation.
Q : Comment utiliser le transitoire ?
A : Contient le modificateur transitoire dans la déclaration de variable d'instance. L'extrait 1 fournit une petite démonstration.
importer java.io.DataInputStream;
importer java.io.FileInputStream;
importer java.io.FileOutputStream;
importer java.io.InputStream;
importer java.io .IOException;
importer java.io.ObjectInputStream;
importer java.io.ObjectOutputStream;
importer java.io.Seriallessly;
class ClassLib implements Serializable {
private transient InputStream is;
private int majorVer;
private int minorVer;
ClassLib(InputStream is) throws IOException {
System.out.println("ClassLib(InputStream) called");
this.is = is;
DataInputStream dis;
if (is instanceof DataInputStream)
dis = (DataInputStream) is;
else
dis = new DataInputStream(is);
if (dis.readInt() != 0xcafebabe)
throw new IOException("not a .class file");
minorVer = dis.readShort();
majorVer = dis.readShort();
}
int getMajorVer() {
return majorVer;
}
int getMinorVer() {
return minorVer;
}
void showIS() {
System.out.println(is);
}
}
public class TransDemo {
public static void main(String[] args) throws IOException {
if (args.length != 1) {
System.err.println("usage: java TransDemo classfile");
return;
}
ClassLib cl = new ClassLib(new FileInputStream(args[0]));
System.out.printf("Minor version number: %d%n", cl.getMinorVer());
System.out.printf("Major version number: %d%n", cl.getMajorVer());
cl.showIS();
try (FileOutputStream fos = new FileOutputStream("x.ser");
ObjectOutputStream oos = new ObjectOutputStream(fos)) {
oos.writeObject(cl);
}
cl = null;
try (FileInputStream fis = new FileInputStream("x.ser");
ObjectInputStream ois = new ObjectInputStream(fis)) {
System.out.println();
cl = (ClassLib) ois.readObject();
System.out.printf("Minor version number: %d%n", cl.getMinorVer());
System.out.printf("Major version number: %d%n", cl.getMajorVer());
cl.showIS();
} catch (ClassNotFoundException cnfe) {
System.err.println(cnfe.getMessage());
}
}
} Fragment 1 : Sérialisation et désérialisation des objets ClassLib
Les classes ClassLib et TransDemo sont déclarées dans le Fragment 1. ClassLib est une bibliothèque qui lit les fichiers de classe Java et implémente l'interface java.io.Serializing afin que ces instances puissent être sérialisées et désérialisées. TransDemo est une classe d'application utilisée pour sérialiser et désérialiser les instances ClassLib.
ClassLib déclare ses variables d'instance comme transitoires car elles peuvent sérialiser sans signification un flux d'entrée (comme décrit ci-dessus). En fait, si cette variable n'est pas transitoire, java.io.NotSerializingException sera levée lors de la désérialisation du contenu de x.ser car InputStream n'implémente pas l'interface Serialisable.
Fragment de compilation 1 : javac TransDemo.java ; exécutez l'application avec un paramètre TransDemo.class : java TransDemo TransDemo.class. Vous pouvez voir un résultat similaire à celui-ci :
ClassLib(InputStream) called Minor version number: 0 Major version number: 51 java.io.FileInputStream@79f1e0e0 Minor version number: 0 Major version number: 51 null
Le résultat ci-dessus montre que lorsque l'objet est reconstruit, aucune méthode constructeur n'est appelée. De plus, on suppose que sa valeur par défaut est null, contrairement à majorVer et minorVer qui ont des valeurs lorsque l'objet ClassLib est sérialisé.
Q : Les transitoires peuvent-ils être utilisés dans les variables membres d'une classe ?
A : Pour la réponse à la question, veuillez consulter le fragment 2
public class TransDemo {
public static void main(String[] args) throws IOException {
Foo foo = new Foo();
System.out.printf("w: %d%n", Foo.w);
System.out.printf("x: %d%n", Foo.x);
System.out.printf("y: %d%n", foo.y);
System.out.printf("z: %d%n", foo.z);
try (FileOutputStream fos = new FileOutputStream("x.ser");
ObjectOutputStream oos = new ObjectOutputStream(fos)) {
oos.writeObject(foo);
}
foo = null;
try (FileInputStream fis = new FileInputStream("x.ser");
ObjectInputStream ois = new ObjectInputStream(fis)) {
System.out.println();
foo = (Foo) ois.readObject();
System.out.printf("w: %d%n", Foo.w);
System.out.printf("x: %d%n", Foo.x);
System.out.printf("y: %d%n", foo.y);
System.out.printf("z: %d%n", foo.z);
} catch (ClassNotFoundException cnfe) {
System.err.println(cnfe.getMessage());
}
}
}Fragment 2 : Sérialisation et désérialisation des objets Foo
Le clip 2 est quelque peu similaire au clip 1. Mais la différence est que c'est l'objet Foo qui est sérialisé et désérialisé, et non ClassLib. De plus, Foo contient une paire de variables, w et x, et des variables d'instance y et z.
Compilez le fragment 2 (javac TransDemo.java) et exécutez l'application (java TransDemo). Vous pouvez voir la sortie suivante :
w: 1 x: 2 y: 3 z: 4 w: 1 x: 2 y: 3 z: 0
Cette sortie nous indique que la variable d'instance y est sérialisée, mais z ne l'est pas, elle est marquée transitoire. Cependant, lorsque Foo est sérialisé, cela ne nous dit pas si les variables w et x sont sérialisées et désérialisées, ou si elles sont simplement initialisées de la manière normale d'initialisation de classe. Pour la réponse, nous devons examiner le contenu de x.ser.
Ce qui suit affiche x.ser hexadécimal :
00000000 AC ED 00 05 73 72 00 03 46 6F 6F FC 7A 5D 82 1D ....sr..Foo.z].. 00000010 D2 9D 3F 02 00 01 49 00 01 79 78 70 00 00 00 03 ..?...I..yxp....
Grâce à l'article "L'algorithme de sérialisation Java révélé" dans JavaWorld, nous avons constaté que la sortie Signification :
Identification du protocole de sérialisation AC ED
00 05 Numéro de version du flux
73 signifie qu'il s'agit d'un nouvel objet
72 signifie qu'il s'agit d'une nouvelle classe d'objet
00 03 Représente la longueur du nom de la classe (3)
46 6F 6F Représente le nom de la classe (Foo)
FC 7A 5D 82 1D D2 9D 3F Représente la chaîne de la classe Identifiant de version de ligne
02 indique que l'objet prend en charge la sérialisation
00 01 indique le nombre de variables de cette classe (1)
49 code de type de variable (0 ×49, ou I, représente int)
00 01 représente la longueur du nom de la variable (1)
79 nom de la variable (y)
78 représente la fin facultative du bloc de données de l'objet
70 signifie que nous avons atteint le sommet de la hiérarchie des classes
00 00 00 03 signifie la valeur de y (3)
Évidemment, seule la variable d'instance y est sérialisé. Parce que z est transitoire, il ne peut pas être sérialisé. De plus, même s'ils sont marqués comme transitoires, w et x ne peuvent pas être sérialisés, car leurs variables de classe ne peuvent pas être sérialisées.
Ce qui précède explique comment utiliser les transitoires en Java. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (m.sbmmt.com) !