Discussion :

[menakikou]

Bonjour,

Je suis sur un problème de conception JAVA.

Voici les données :
J'ai 3 fichiers (type 1, type 2 , type 3) que je dois leur appliqué des contrôles , je peux faire trois modules dans chacune placés les contrôles pour chaque fichiers.

Cependant, il y a des contrôles commun pour ces 3 fichiers , je propose une idée. J'aimerai avoir votre avis, je voudrais créer une Interface "Control" dans laquelle je place tous les contrôles ainsi j’implémenterai pour chaque type de fichier l'implementation associé.

Mais, comment puis je faire pour ne pas ré implémenté les contrôles déjà utiliser par le fichier de type 1 par exemple que je voudrais ré utiliser pour le type 2.

Je pense que j'y suis presque, y a t il un design pattern adapté à ce genre de conception ?

Merci pour votre aide

[andry.aime]

Bonjour,

On appelle ça héritage. Regarde ce tutoriel.

A+.

[menakikou]

Ok, je sais ce que c'est l'héritage, mais je ne sais pas le mettre en oeuvre pour ce cas.

Ça voudrait dire pour mon problème de conception,

Créer une Interface Controle.
Créer plusieurs Implémentation pour chaque type de fichiers.

Ensuite pour chaque Controle j'hérite de l'interface , ainsi je pourrais avoir accés à toute les implentations de controles en commun ?

Pourrais tu me le confirmer s'il te plait ? ou me proposer une architecture .

Merci d'avance

[rg77140]

Bonjour,

Code :

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

1
2
3
public interface Control{
public boolean isValid(File fichier);
}

Code :

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

1
2
3
4
5
public class ControlFichier1 implements Control{
   public boolean isValid(File fichier){
        // control pour le fichier 1
   }
}

Tu as ensuite deux possibilités pour mutualisé ton code. Soit tu utilises un pattern décorateur, soit tu utilises l'héritage. L'héritage n'étant pas multiple en Java il n'est pas possible de mutualiser le comportement de plusieurs classes...

Solution 1 - Héritage

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
public class ControlFichier2 extends ControlFichier1 implements Control{
   public boolean isValid(File fichier){
        if(super.isValid(fichier)){
            // controle spécifique fichier 2
        }else{
            return false;
        }
   }
}
 
// Utilisation 
Control controlFichier2 = new ControlFichier2();

Solution 2 - Composition (patron décorateur)

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
 
public class ControlFichier2 implements Control{
 
   private Control control;
 
   public ControlFichier2(Control control){
      this.control = control;
   }
 
   public boolean isValid(File fichier){
        if(control.isValid(fichier)){
            // controle spécifique fichier 2
        }else{
            return false;
        }
   }
}
 
// Utilisation 
Control controlFichier2 = new ControlFichier2(new ControlFichier1());

J'ai une préférence pour la seconde solution qui te permet de modifier le constructeur pour accepter plusieurs "Control" et de mutualiser le code de plusieurs "Control" contrairement à l'héritage ou tu ne peux mutualiser/hériter le comportement d'une classe uniquement...

Romain.

[menakikou]

Merci pour ta réponse, je viens de tester et ça fonctionne à merveille.

Par contre, cela implique que seule les fichiers du type 2 et du type 3 peuvent bénéficier des contrôles du fichier du type 1.

Dans l'évolution des choses, on pourrait s’imaginer qu'un contrôle supplémentaire du type 2 pourrait être utile donc utiliser par contrôle du type 1.

Du coup, on pourrait pas l'utiliser.

Code :

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

1
2
3
4
5
6
7
8
9
 
File f = new File("D://logo.gif") ; 
 
//ControlFichier1 controle1 = new ControlFichier1();
//controle1.isValid(f);
 
ControlFichier2 controle2 = new ControlFichier2(controle1);
controle2.isValid(f);
	}

Je pousse le raisonnement assez loin pour ne pas avoir d’inter blocage .

Est ce que c'est possible en gros que tous les contrôles de fichier de n'importe quels type puisse être utiliser dans n'importe lesquels.

Merci pour ta patience et ton aide.

[rg77140]

Si tu souhaites vraiment pouvoir assembler n'importe quelle Control les uns avec les autres alors je vois bien cette solution :

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
 
public class ControlType1 implements Control{
   public boolean isValid(File fichier){
        // control de type 1
   }
}
 
public class ControlType2 implements Control{
   public boolean isValid(File fichier){
        // control de type 2
   }
}
 
public class ControlType3 implements Control{
   public boolean isValid(File fichier){
        // control de type 3
   }
}

Si tu veux effectuer un contrôle d'un seul type tu peux utilise un de ces trois là, si tu veux les combiner tu peux faire :

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
public class ControleCompose implements Control{
 
   private Control[] controls;
 
   public ControleCompose(Control... controls){
      this.controls = controls;
   }
 
   public boolean isValid(File fichier){
        for(Control control : controls){
            if(!control.isValid(fichier)){ return false;}
        }
        return true;
   }
}
 
// Utilisation 
Control controleCompose12 = new ControleCompose(new ControlType1(), new ControlType2());
Control controleCompose23 = new ControleCompose(new ControlType2(), new ControlType3());
Control controleCompose13 = new ControleCompose(new ControlType1(), new ControlType3());
Control controleCompose123 = new ControleCompose(new ControlType1(), new ControlType2(), ControlType3());

Romain.