Pause café #180. Variables en Java : qu'est-ce qu'elles sont et comment elles sont utilisées. 5 choses que vous devez savoir sur la sérialisation et la désérialisation en Java

Variables en Java : que sont-elles et comment sont-elles utilisées

Source : Hackernoon Il existe quatre types différents de variables en Java, selon l'endroit où elles sont déclarées dans le programme. Aujourd'hui, vous apprendrez des exemples et des différences de chaque type. 1. Les variables d'instance ou les champs d'instance sont des variables déclarées à l'intérieur d'une classe sans le mot-clé static , mais en dehors d'une méthode, d'un constructeur ou d'un bloc de code. De telles variables peuvent être déclarées n'importe où dans la classe. Vous pouvez les déclarer avec ou sans modificateur d'accès, tel que public , private , protected ou default (pas un mot-clé).

public class MyClass {

  //instance field 1
  private String instanceField1;

  public MyClass(){} //Constructor

  //instance field 2
  public int anotherInstanceField2;

  public void setInstanceField(String parameterVariable) {...} //instance method

  //instance field 3
  boolean instanceField3;

  public static void main(String[] args) {
    System.out.println("field 1 value: " + instanceField1); // = null
    System.out.println("field 2 value: " + anotherInstanceField2); // = 0
    System.out.println("field 3 value: " + instanceField3); // = 0
  }
}

Si aucune valeur n'est attribuée à un champ d'instance au moment de la déclaration, il se voit attribuer une valeur par défaut de zéro s'il s'agit d'un type primitif, tel que ( int , boolean , long , float ), ou null s'il ne s'agit pas d'un type primitif, tels que ( String , Integer , AnyClass ). On les appelle champs ou variables d'instance car ils appartiennent à l'instance de tout objet créé à partir de la classe dans laquelle ils sont déclarés.

public Main {

  public static void main(String[] args) {
    MyClass obj1 = new MyClass();
    MyClass obj2 = new MyClass();

    //Now we can access every 'public' field declared in the MyClass class
    // from the newly created object 'obj'

    obj1.anotherInstanceField2 = 11;
    obj2.anotherInstanceField2 = 33;

    System.out.println(obj1.anotherInstanceField2); // prints '11'
    System.out.println(obj2.anotherInstanceField2); // prints '33'
  }
}

Ainsi, chaque champ d'instance est unique à son objet, comme le montre l'extrait ci-dessus. Dans celui-ci, obj1 et obj2 ont des valeurs uniques attribuées à leurs champs d'instance respectifs. 2. Les champs de classe ou champs statiques sont des champs déclarés avec le mot clé static . Ils sont déclarés à l’intérieur de la classe, mais en dehors de la méthode, du constructeur ou du bloc de code. Ils peuvent également être déclarés à n'importe quelle position au sein d'une classe, avec ou sans modificateur d'accès, tel que public , private , protected ou default (pas un mot-clé).

public class MyClass {

  //static field
  public static String staticField;

  public MyClass(){} //Constructor

}

class Main {

  public static void main(String[] args) {

    MyClass obj = new MyClass();

    obj.staticField //will throw Not defined Error

    //Now we cannot access the static field declared in MyClass class from the
     // newly created object 'obj' because static fields are not attached to any
    // object. They belong solely to the class they are declared and can only be
    // accessed from their class.

    MyClass.staticField = "I am a static field";
    System.out.println(MyClass.staticField); // prints 'I am a static field'
  }
}

Les champs statiques ne sont accessibles que via leurs classes et non à partir d'un objet comme indiqué dans l'extrait de code ci-dessus. 3. Les paramètres ou les variables d'argument sont des variables déclarées dans une construction de méthode entre les accolades ouvrantes et fermantes de la signature de la méthode. Ils servent à transmettre des valeurs ou des objets à une méthode.

public class MyClass {

  //instance field
  public String instanceField;

  public MyClass(){} //Constructor

  //instance method with a parameter variable
   public void setInstanceField(String parameterVariable) {
      instanceField = parameterVariable;
   }
}

class Main {

  public static void main(String[] args) {

    MyClass obj = new MyClass();

    obj.setInstanceField("From a parameter variable");

    System.out.println(obj.instanceField); // prints 'From a parameter variable'
  }
}

4. Les variables locales sont des variables déclarées dans une méthode ou dans n'importe quel bloc de code, par exemple, dans un bloc d' instructions if , une boucle for , une boucle while , un bloc d' instructions switch , etc.

public Main {

  public static void main(String[] args) {
    MyClass obj1 = new MyClass(); // 'obj1' is local reference variable

    int id = 1; // 'name' is a local variable here.

    if (id > 1) {
        String tempName = "Austin"; // 'tempName' is a local reference variable
     }
  }
}

Dans ce code, vous pouvez remarquer l'utilisation de référence avec certaines variables, alors que la variable locale id n'a pas été mentionnée comme variable de référence. Toute variable non primitive est une variable de référence. Par exemple, obj1 est une variable de type MyClass et tempName est une variable de type String , et ici les deux types ne sont pas des types primitifs. Dans ce cas, id est une variable de type int , qui est un type de données primitif. Il s’agit donc d’une variable non-référence.

5 choses que vous devez savoir sur la sérialisation et la désérialisation en Java

Source : Devgenius Avec ce tutoriel, vous améliorerez vos connaissances sur le fonctionnement de la sérialisation et de la désérialisation. La sérialisation en Java permet de convertir un objet existant en flux d'octets. À l’inverse, la désérialisation fait d’un flux d’octets un objet. Grâce à la sérialisation et à la désérialisation en Java, les informations sur les objets peuvent être transférées d'une JVM à une autre.

#1 Sérialisation

Avant d'entrer dans les détails, jetons un œil aux classes SerializeUtils.java et Person.java . Ici, ils nous aideront à effectuer la sérialisation et la désérialisation à l'aide d'exemples spécifiques.

SerializeUtils.java

package com.techteam.serialization;

import java.io.*;

public class SerializeUtils {
    public static <T> void serialize(T input, String fileName) throws IOException {
        FileOutputStream file = new FileOutputStream(fileName);
        ObjectOutputStream out = new ObjectOutputStream(file);
        out.writeObject(input);
        out.close();
        file.close();
    }

    public static <T> T deserialize(String fileName) throws IOException, ClassNotFoundException {
        FileInputStream file = new FileInputStream(fileName);
        ObjectInputStream in = new ObjectInputStream(file);
        T result = (T) in.readObject();

        return result;
    }

    public static void externalSeialize(Externalizable e, String fileName) throws IOException {
        FileOutputStream file = new FileOutputStream(fileName);
        ObjectOutputStream out = new ObjectOutputStream(file);
        e.writeExternal(out);
        out.close();
        file.close();
    }

    public static void externalDeseialize(Externalizable e, String fileName) throws IOException, ClassNotFoundException {
        FileInputStream file = new FileInputStream (fileName);
        ObjectInputStream in = new ObjectInputStream (file);
        e.readExternal(in);
        in.close();
        file.close();
    }
}

Personne.java

package com.techteam.serialization;

import java.io.Serializable;

public class Person implements Serializable {
    private static final long serialVersionUID = 1L;

    private int id;
    private String name;
    private int age;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

Comme mentionné, la sérialisation permet de convertir un objet en un flux d'octets. Cela signifie que toutes les informations sur l'objet sont également converties en flux d'octets, telles que la méthode, les propriétés et les données. Voici un exemple de la façon dont un objet est sérialisé :

package com.techteam.serialization;

import java.io.IOException;

public class SerializationMain {

    public static void main(String[] args) throws IOException {
        Person p = new Person();
        p.setId(1);
        p.setName("Tech team members");
        p.setAge(20);

        SerializeUtils.serialize(p, "/person.txt");
    }
}

Après le processus de sérialisation, nous avons un fichier avec le contenu suivant :

#2 Désérialisation

Si dans l'exemple précédent nous avons créé un flux d'octets en sérialisant un objet, voyons maintenant comment revenir à l'objet en utilisant la désérialisation :

package com.techteam.serialization;

import java.io.IOException;

public class DeserializationMain {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Person p = SerializeUtils.deserialize("/person.txt");

        System.out.println("Person data:");
        System.out.println(p.getId());
        System.out.println(p.getName());
        System.out.println(p.getAge());
    }
}

Voici les données après le processus de désérialisation :

#3 UID de la version série

SerialVersionUID signifie un numéro d'identification unique pour chaque version du processus de sérialisation et de désérialisation. Ce numéro est utilisé pour garantir que les objets sérialisés et désérialisés utilisent des classes compatibles. Pour Person.java, je voudrais augmenter le serialVersionUID à 2. Regardons le résultat après avoir désérialisé le fichier person.txt.

#4 Mot-clé transitoire

Pendant le processus de sérialisation et de désérialisation, nous n'avons parfois pas besoin de sérialiser toutes les informations sur un objet. En utilisant un processus transitoire pour les variables, nous pouvons ignorer ces variables de l'objet en cours de sérialisation. L’exemple ci-dessous aidera à comprendre cela plus clairement :

package com.techteam.serialization;

import java.io.IOException;
import java.io.Serializable;

public class PersonWithTransient implements Serializable {

    private static final long serialVersionUID = 1L;

    private int id;
    private String name;
    private transient int age;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        PersonWithTransient p = new PersonWithTransient();
        p.setId(2);
        p.setName("Tech team members(transient)");
        p.setAge(50);

        SerializeUtils.serialize(p, "/person_transient.txt");

        PersonWithTransient deserializeP = SerializeUtils.deserialize("/person_transient.txt");
        System.out.println("Person without transient data:");
        System.out.println(deserializeP.getId());
        System.out.println(deserializeP.getName());
        System.out.println(deserializeP.getAge());
    }
}

Dans le code ci-dessus, nous avons utilisé le mot-clé transient pour la variable age . Et c'est ce que nous avons obtenu après le processus de sérialisation et de désérialisation.

#5 Interface externalisable

En Java, lorsque nous souhaitons personnaliser le processus de sérialisation et de désérialisation, nous pouvons utiliser un processus de transition pour ignorer les variables dont nous n'avons pas besoin pour le processus de sérialisation et de désérialisation. Une autre façon de simplifier et d'améliorer les performances consiste à utiliser l' interface Externalisable au lieu de l' interface Serialisable . Regardons un exemple :

package com.techteam.serialization;

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

public class PersonExternalizable implements Externalizable {
    private static final long serialVersionUID = 1L;
    private int id;
    private String name;
    private int age;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeUTF(this.name);
        out.writeInt(this.age);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        this.name = in.readUTF();
        this.age = in.readInt();
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        PersonExternalizable p = new PersonExternalizable();
        p.setId(3);
        p.setName("Tech team members(Externalizable)");
        p.setAge(30);

        SerializeUtils.externalSeialize(p, "/person_externalizable.txt");

        PersonExternalizable deserializeP = new PersonExternalizable();
        SerializeUtils.externalDeseialize(deserializeP, "/person_externalizable.txt");
        System.out.println("Person data:");
        System.out.println(deserializeP.getId());
        System.out.println(deserializeP.getName());
        System.out.println(deserializeP.getAge());
    }
}

Comme vous pouvez le voir, lorsque vous utilisez Externalizing , nous pouvons facilement écrire une logique personnalisée, ignorer les variables et obtenir de meilleures performances qu'en utilisant Serialisable . Regardons maintenant le résultat :

Conclusion

J'espère que grâce à cet article, vous avez acquis une compréhension claire du fonctionnement de la sérialisation et de la désérialisation en Java, et que les exemples ci-dessus pourront vous aider dans la pratique à l'avenir.