Discussion :

[Deallyra]

Bonjour,

Suite à ce cour sur la sérialisation, j'ai souhaité le mettre en application et je me posais une question.

Est-il possible de faire une fonction qui permettrait de sérialiser n'importe quel objet qui implémenterai le serializable ?

quelque chose du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

public void serializer(Object o){

Prenons deux classes. Avion et Bateau.

Actuellement, j'utiliserai ceci pour faire la sérialisation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
    public void serializerAvion(Avion a){
        try {
            // ouverture d'un flux de sortie vers le fichier "avion.serial"
            FileOutputStream fos = new FileOutputStream("avion.serial");
 
            // création d'un "flux objet" avec le flux fichier
            ObjectOutputStream oos= new ObjectOutputStream(fos);
            try {
                // sérialisation : écriture de l'objet dans le flux de sortie
                oos.writeObject(a);
                // on vide le tampon
                oos.flush();
                System.out.println(a + " a ete serialise");
            } finally {
                //fermeture des flux
                try {
                    oos.close();
                } finally {
                    fos.close();
                }
            }
        }
        catch(IOException ioe) {
            ioe.printStackTrace();
        }
    }

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
    public void serializerBateau(Bateau b){
        try {
            // ouverture d'un flux de sortie vers le fichier "bateau.serial"
            FileOutputStream fos = new FileOutputStream("bateau.serial");
 
            // création d'un "flux objet" avec le flux fichier
            ObjectOutputStream oos= new ObjectOutputStream(fos);
            try {
                // sérialisation : écriture de l'objet dans le flux de sortie
                oos.writeObject(b);
                // on vide le tampon
                oos.flush();
                System.out.println(b + " a ete serialise");
            } finally {
                //fermeture des flux
                try {
                    oos.close();
                } finally {
                    fos.close();
                }
            }
        }
        catch(IOException ioe) {
            ioe.printStackTrace();
        }
    }

Si j'avais 36 classes, je serais obligé de décrire 36 méthodes... pour rien >.<

Comment pourrais-je rendre cette sérialisation générique ?

Merci à vous

[herch]

Salut,
juste une petite remarque, les deux méthodes ne diffèrent que du type d'objet à sérialiser, peut être que faire une méthode générique ferait l'affaire, quelque chose du genre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

public <T> void serializerAvion(T t, String fichierSortie)

.
Je ne sais si j'ai bien compris la question, mais bon, j'espère que c'est ce que tu cherchais.

[Deallyra]

xD

En effet, je demandais s'il pouvait être utilisé une méthode générique.

T représente quelque chose de particulier ? Une classe spécifique ou justement le terme générique ?

[Deallyra]

Nickel, c'est bien ce que je souhaitais ^^

Mais si tu peux me donner un ou deux renseignements sur <T>

[herch]

Resalut,
tu sais, c'est toi qui a plein d'étoiles

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public <T> void serializerObjet(T t, String fichierSortie)
{
try {
            // ouverture d'un flux de sortie vers le fichier "avion.serial"
            FileOutputStream fos = new FileOutputStream(fichierSortie);
 
            // création d'un "flux objet" avec le flux fichier
            ObjectOutputStream oos= new ObjectOutputStream(fos);
            try {
                // sérialisation : écriture de l'objet dans le flux de sortie
                oos.writeObject(t);
                // on vide le tampon
                oos.flush();
                System.out.println(t + " a ete serialise");
            } finally {
                //fermeture des flux
                try {
                    oos.close();
                } finally {
                    fos.close();
                }
            }
        }
        catch(IOException ioe) {
            ioe.printStackTrace();
        }
    }
 
}

T représente la classe qui sera donné en paramètre; par exp, si on met :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

serializerObjet(Avion a, "avion.serial");

T sera remplacé par Avion, et ainsi de suite.
Rmq: j'ai pas testé le code ci-dessus, mais je crois que c'est correcte ( suis trop paresseux )
Voilà, j'espère que ça aidera.

[Deallyra]

Nan mais j'avais bien modifié mon code xD

Je voulais juste savoir à quoi correspondait le T

java.lang
Class Class<T>

java.lang.Object
extended by java.lang.Class<T>

Type Parameters:
T - the type of the class modeled by this Class object. For example, the type of String.class is Class<String>. Use Class<?> if the class being modeled is unknown.

All Implemented Interfaces:
Serializable, AnnotatedElement, GenericDeclaration, Type

__________________________

public final class Class<T>
extends Object
implements Serializable, GenericDeclaration, Type, AnnotatedElement

Instances of the class Class represent classes and interfaces in a running Java application. An enum is a kind of class and an annotation is a kind of interface. Every array also belongs to a class that is reflected as a Class object that is shared by all arrays with the same element type and number of dimensions. The primitive Java types (boolean, byte, char, short, int, long, float, and double), and the keyword void are also represented as Class objects.

Class has no public constructor. Instead Class objects are constructed automatically by the Java Virtual Machine as classes are loaded and by calls to the defineClass method in the class loader.

The following example uses a Class object to print the class name of an object:

void printClassName(Object obj) {
System.out.println("The class of " + obj +
" is " + obj.getClass().getName());
}


It is also possible to get the Class object for a named type (or for void) using a class literal (JLS Section 15.8.2). For example:

System.out.println("The name of class Foo is: "+Foo.class.getName());