Design pattern MVC - est ce que je suis dans le bon ?

**bbsebb** · 20/02/2021, 21h36

Bonjour,

J'ai repris un tuto sur openclassroom où on fait une calculatrice en utilisant le design pattern MVC. J'ai complètement refait sans utiliser interfaces Observer et observable qui sont obsolètes. J'aimerai avoir des critiques de votre part, en particulier sur ce design pattern (mais tous autres critiques seront les bienvenus).

Merci d'avance.

Pièce jointe 591528

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package apj.p3.calculatrice;
 
import javax.swing.JFrame;
 
public class App {
 
	public static void main(String[] args) {
 
		JFrame f = new Gui(new CalcModel());
		f.setVisible(true);
 
	}
 
}

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
 
package apj.p3.calculatrice;
 
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
 
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
 
public class Gui extends JFrame {
 
	private static final long serialVersionUID = 1L;
	String[] operateur = { "+", "-", "/", "*" };
	/* On associe un model abstrait */
	AbstractModel calcModel;
	/* On associe un controller abstrait */
	AbstractController controller;
	JLabel label;
 
	public Gui(AbstractModel caclModel) {
 
		super("Calculatrice v2");
 
		this.calcModel = new CalcModel();
		this.controller = new CalcController(this.calcModel);
 
		/* -- Construction de la JFRAME -- */
		this.setSize(270, 270);
		this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
		this.setResizable(false);
		this.setLocationRelativeTo(null);
 
		/* -- Construction des composants -- */
		JPanel pan = (JPanel) this.getContentPane();
		pan.setLayout(new BorderLayout());
		pan.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
		this.label = createLabel();
		pan.add(this.label, BorderLayout.NORTH);
		pan.add(createPanChiffre(), BorderLayout.CENTER);
		pan.add(createPanOp(), BorderLayout.EAST);
 
	}
 
	/**
         * 
         * @return le JPanel où se trouve les boutons des opérations et clear 
         */
	private JPanel createPanOp() {
 
		JPanel panOp = new JPanel();
		panOp.setLayout(new GridLayout(5, 1, 5, 5));
		panOp.add(createBtnClear());
		for (String string : operateur) {
			panOp.add(createBtnOp(string));
		}
		return panOp;
 
	}
 
	/**
         * 
         * @return le JPanel où se trouve les chiffres, le point et le bouton égal
         */
	private JPanel createPanChiffre() {
 
		JPanel panChiffre = new JPanel();
		panChiffre.setLayout(new GridLayout(4, 3, 5, 5));
		for (int i = 1; i < 10; i++) {
 
			panChiffre.add(this.createBtnChiffre(i));
		}
		panChiffre.add(this.createBtnChiffre("0"));
		panChiffre.add(this.createBtnChiffre("."));
		panChiffre.add(this.createBtnEgal());
		return panChiffre;
	}
 
	/**
         * 
         * @return le JLabel d'affichage des resultats
         */
	private JLabel createLabel() {
 
		JLabel label = new JLabel();
		label.setBorder(BorderFactory.createLineBorder(Color.black));
		label.setText("0");
		calcModel.addPropertyChangeListener((e) -> label.setText(e.getNewValue().toString()));
		return label;
	}
 
	private JButton createBtnChiffre(String chiffre) {
		JButton btn = new JButton(chiffre);
		btn.addActionListener(this::actionChiffre);
		return btn;
	}
 
	private JButton createBtnChiffre(int chiffre) {
		return createBtnChiffre(Integer.toString(chiffre));
	}
 
	private JButton createBtnEgal() {
		JButton btn = new JButton("=");
		btn.addActionListener(this::actionEgal);
		return btn;
	}
 
	private JButton createBtnOp(String op) {
		JButton btn = new JButton(op);
		btn.addActionListener(this::actionOperateur);
		return btn;
	}
 
	private JButton createBtnClear() {
		JButton btn = new JButton("C");
		btn.addActionListener(this::actionClear);
		return btn;
	}
 
	private void actionChiffre(ActionEvent e) {	
		try {
			this.label.setText(controller.controleChiffre(((JButton) e.getSource()).getText()));
		} catch (IllegalArgumentException e1) {
			this.actionClear(e);
			this.label.setText(e1.getMessage());
		}
	}
 
	private void actionEgal(ActionEvent e) {
		try {
			controller.controleEgal();
		} catch (IllegalArgumentException e1) {
			this.actionClear(e);
			this.label.setText(e1.getMessage());
		}
	}
 
	private void actionOperateur(ActionEvent e) {
		String txtBtn = ((JButton) e.getSource()).getText();
 
		try {
			controller.controleOp(txtBtn);
		} catch (IllegalArgumentException e1) {
			this.actionClear(e);
			this.label.setText(e1.getMessage());
		}
 
	}
 
	private void actionClear(ActionEvent e) {
		controller.controleCancel();
	}
}

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
package apj.p3.calculatrice;
 
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
 
public abstract class AbstractModel {
	float rslt;
	PropertyChangeSupport support;
 
	AbstractModel() {
		support = new PropertyChangeSupport(this);
	}
 
	public abstract boolean operationAdditionner (float nbr);
	public abstract boolean operationSoustraire (float nbr);
	public abstract boolean operationDiviser (float nbr);
	public abstract boolean operationMultiplier (float nbr);
	public abstract boolean reset ();
 
 
	protected float getRslt() {
		return rslt;
	}
	protected void setRslt(float rslt) {
		support.firePropertyChange("resultat", this.rslt , rslt);
		this.rslt = rslt;
	}
 
	protected PropertyChangeSupport getSupport() {
		return support;
	}
 
	protected void setSupport(PropertyChangeSupport support) {
		this.support = support;
	}
 
    public void addPropertyChangeListener(PropertyChangeListener listener) {
        this.support.addPropertyChangeListener(listener);
    }
 
    public void removePropertyChangeListener(PropertyChangeListener listener) {
        this.support.removePropertyChangeListener(listener);
    }
 
 
 
 
 
}

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
package apj.p3.calculatrice;
 
import java.util.regex.Pattern;
 
public abstract class AbstractController {
 
	String rgx;
	Pattern pattern;
	String chiffre;
	String op;
	String opPre = null;
	AbstractModel model;
	boolean nouveauChiffre;
	boolean negatif;
 
	AbstractController() {
		this.setRgx(".*");
		this.pattern = Pattern.compile(rgx);
		this.setChiffre(null);
		this.setOp(null);
		this.setOpPre(null);
		this.setModel(null);
		this.setNouveauChiffre(true);
		this.setNegatif(false);
	}
 
	/**
         * Controle le chiffre est correcte
         * @param chiffre correspond au bouton appuyé
         * @return le nombre complèt à afficher
         */
	public abstract String controleChiffre(String chiffre);
 
	public abstract void controleOp(String operateur);
 
	public abstract void controleCancel();
 
	public abstract void controleEgal();
 
	protected String getChiffre() {
		return chiffre;
	}
 
	protected void setChiffre(String chiffre) {
		if (chiffre != null) {
			if (pattern.matcher(chiffre).matches())
				this.chiffre = chiffre;
			else
				throw new IllegalArgumentException("Erreur : chiffre incorrect");
		}
	}
 
	protected String getOp() {
		return op;
	}
 
	protected void setOp(String op) {
		this.op = op;
	}
 
	protected AbstractModel getModel() {
		return model;
	}
 
	protected void setModel(AbstractModel model) {
		this.model = model;
	}
 
	protected String getOpPre() {
		return opPre;
	}
 
	protected void setOpPre(String opPre) {
		this.opPre = opPre;
	}
 
	protected boolean isNouveauChiffre() {
		return nouveauChiffre;
	}
 
	protected void setNouveauChiffre(boolean nouveauChiffre) {
		if(nouveauChiffre)
			this.setNegatif(false);
		this.nouveauChiffre = nouveauChiffre;
	}
 
	public String getRgx() {
		return rgx;
	}
 
	public void setRgx(String rgx) {
		this.rgx = rgx;
	}
 
	public boolean isNegatif() {
		return negatif;
	}
 
	public void setNegatif(boolean negatif) {
		this.negatif = negatif;
	}
 
 
 
}

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
package apj.p3.calculatrice;
 
public class CalcModel extends AbstractModel{
 
 
	@Override
	public boolean reset() {
		this.setRslt(0);
		return false;
	}
 
 
	@Override
	public boolean operationAdditionner(float nbr) {
		this.setRslt(this.getRslt() + nbr);
 
		return false;
	}
 
 
 
	@Override
	public boolean operationSoustraire(float nbr) {
		this.setRslt(this.getRslt() - nbr);
		return false;
	}
 
 
 
	@Override
	public boolean operationDiviser(float nbr) {
		this.setRslt(this.getRslt() / nbr);
		return false;
	}
 
 
 
	@Override
	public boolean operationMultiplier(float nbr) {
		this.setRslt(this.getRslt() * nbr);
		return false;
	}
 
 
 
 
 
 
}

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
package apj.p3.calculatrice;
 
import java.util.regex.Pattern;
 
public class CalcController extends AbstractController {
 
	public CalcController(AbstractModel model) {
		this.setModel(model);
		this.setRgx("^-?[0-9]+\\.?[0-9]*$");
		this.pattern = Pattern.compile(this.rgx);
		this.setNouveauChiffre(true);
	}
 
	@Override
	public String controleChiffre(String chiffre) {
 
		/* Si le chiffre doit être négatif */
		String strNegation = "";
		if (this.isNegatif()) {
			strNegation = "-";
			this.setNegatif(false);
		}
 
		/* pour le premier chiffre, ou les chiffre juste après avoir appuyer sur un operateur */
		if (this.isNouveauChiffre())
			this.setChiffre(strNegation + chiffre);
		else
			this.setChiffre(strNegation + this.getChiffre() + chiffre);
		this.setNouveauChiffre(false);
		return this.getChiffre();
	}
 
	@Override
	public void controleOp(String operateur) {
 
		/* Si on appuie plusieurs fois sur un operateur à la suite (gestion des chiffres négatifs qui utilisent le même bouton) */
		if ((this.isNouveauChiffre() && operateur != "-")
				|| (this.isNouveauChiffre() && operateur == "-" && this.isNegatif())) {
			throw new IllegalArgumentException("Erreur : formule incorrecte");
		}
 
		/* On gère les chiffres négatifs autrement qu les operateur */
		if (this.isNouveauChiffre() && operateur == "-") {
			this.setNegatif(true);
		} else {
			float nbr;
			/* l'affichage du zero initial doit etre géré de facon particulière */
			if (this.getChiffre() == null || this.getChiffre().isEmpty())
				nbr = 0;
			else
				nbr = (Float.valueOf(this.getChiffre()));
 
			/* On ne fait pas d'operation au premier appui sur un opérateur */
			if (opPre != null) {
				switch (opPre) {
				case "+" -> this.getModel().operationAdditionner(nbr);
				case "-" -> this.getModel().operationSoustraire(nbr);
				case "/" -> this.getModel().operationDiviser(nbr);
				case "*" -> this.getModel().operationMultiplier(nbr);
 
				}
			} else {
				this.getModel().setRslt(nbr);
			}
			this.setOpPre(operateur);
			this.setNouveauChiffre(true);
		}
 
	}
 
	@Override
	public void controleCancel() {
 
		this.setNouveauChiffre(true);
		this.setChiffre("0");
		this.getModel().reset();
	}
 
	@Override
	public void controleEgal() {
		if (this.isNouveauChiffre()) {
			throw new IllegalArgumentException("Erreur : formule incorrecte");
		}
 
		float nbr = (Float.valueOf(this.getChiffre()));
		switch (this.getOpPre()) {
		case "+" -> this.getModel().operationAdditionner(nbr);
		case "-" -> this.getModel().operationSoustraire(nbr);
		case "/" -> this.getModel().operationDiviser(nbr);
		case "*" -> this.getModel().operationMultiplier(nbr);
		}
		this.setOpPre(null);
		this.setNouveauChiffre(true);
		this.setChiffre("0");
 
	}
 
}

**gervais.b** · 24/02/2021, 10h41

Au niveau du MVC ca me semble bon.

Par contre en terme de simplicité, les AbstractModel et AbstractController ne font qu'augmenter la difficulté de compréhensionn particulièrement pour le contrôleur. Notez que les getters et setters ne sont pas une obligation, surtout au sein d'une même classe.

**bbsebb** · 24/02/2021, 11h01

Merci pour votre réponse.

J'ai utilisé des classes abstraites pour bien mettre en évidence la possibilité de changer de vue ou du contrôleur/modèle indépendamment grace design patterns mvc meme si dans cette exemple des classes simples auraient été plus compréhensible.

Pour les getter et setter, j'ai pris l'habitude de mettre des getter et setter même pour les attributs privés. Est ce que c'est une bonne ou mauvaise pratique ?

**gervais.b** · 24/02/2021, 12h32

Je ne sais pas si c'est une bonne habitude. Posez-vous la question de savoir ce que ça vous apporte..

**professeur shadoko** · 24/02/2021, 13h33

Envoyé par bbsebb

Pour les getter et setter, j'ai pris l'habitude de mettre des getter et setter même pour les attributs privés. Est ce que c'est une bonne ou mauvaise pratique ?

c'est une légende urbaine désastreuse! (voir les critiques sur les Beans utilisés comme pattern généraliste) pourquoi avoir un mutateur si un champ est privé et qui plus est immuable? Les classes de Java elles-mêmes (sauf les vrais Beans) ne sont pas conçues comme ça: ça devrait mettre la puce à l'oreille.

**bbsebb** · 24/02/2021, 14h56

Je le faisais surtout pour bien différencier les variables locales sur des fonctions des variables générales pcq c'est vrai qu'au début, je ne fractionnais pas assez mon code donc j'avais souvent des fonctions à rallonge. Mais il est temps de modifier cette habitude inutile plus que problèmatique. D'ailleurs, j'ai le même problème sur la variable this

que je met systématiquement. Est ce une bonne ou mauvaise méthode ?

Je me posais aussi la question, mais je vais chercher sur la doc, pour les vrais beans, si vrmt les variables privées doivent avoir un getter et un setter.

Après je pense que tt le monde est d'accord, une variable publique devrait tjs être récupérée par un getter ou modifiée par un setter ?

[EDIT : Je m'exprime mal, quand je parle de variable publique ou privé, je veux dire celles que j'utilise uniquement dans la classe ou celles dont j'ai besoin à l'extérieur et non la porté de la variable en java (private, public)]

**professeur shadoko** · 24/02/2021, 17h01

la question est qu'est-ce qu'un vrai Bean et à quoi ça sert?
pour des codes graphiques manipulable par des outils de mise en forme il existe un design time pendant lequel les caractéristiques de l'objet sont manipulées.
mais pour des classes qui ne sont pas destinées à être manipulées par ces outils 1) ça ne sert à rien 2) c'est une violation formelle de l'encapsulation
à la rigueur certains outils de reconstitution d'instances (depuis un B.D.D par ex.) peuvent nécessiter des mutateurs (setter) privés mais c'est à peu près tout.

nota: mettre this partout ne fait de mal à personne et même si ça semble "bavard" c'est plutôt bien pour la relecture des codes.

**bbsebb** · 24/02/2021, 18h06

merci pour vos réponses

**bbsebb** · 27/02/2021, 13h03

Envoyé par professeur shadoko

c'est une légende urbaine désastreuse! (voir les critiques sur les Beans utilisés comme pattern généraliste) pourquoi avoir un mutateur si un champ est privé et qui plus est immuable? Les classes de Java elles-mêmes (sauf les vrais Beans) ne sont pas conçues comme ça: ça devrait mettre la puce à l'oreille.

Je rebondis sur votre commentaire. Si par exemple, j'ai une variable de classe utilisée uniquement à l'intérieur de la classe et que j'ai besoin qu'à chaque modification de cette variable, une opération se fasse, n'est il pas intéressant d'utiliser un setter ?

**professeur shadoko** · 27/02/2021, 14h25

Envoyé par bbsebb

Je rebondis sur votre commentaire. Si par exemple, j'ai une variable de classe utilisée uniquement à l'intérieur de la classe et que j'ai besoin qu'à chaque modification de cette variable, une opération se fasse, n'est il pas intéressant d'utiliser un setter ?

je n'ai pas dis qu'il ne fallait pas de mutateur pour les variables car ce peut être bien d'avoir un code de modification spécifique ...j'ai voulu dire ceci: il y a des très nombreux cas où il ne faut pas le faire par ex. si le champs est immuable ou si les modifications ne dépendent pas directement d'un mutateur (ex. "solde" d'un compte en banque, il y a des méthodes "dépôt", "retrait" qui modifient le solde mais pas de "setSolde" public )
par ailleurs il y a aussi des accesseurs qui dépendent d'un attribut calculé (ex. "getAge" pour une Personne alors qu'il n'y a pas de champ "age" mais une date de naissance) ; des accesseurs qui rendent une vision non modifiable d'un objet; etc...
donc se méfier des réflexes get/set c'est une convention utile mais qu'il faut utiliser à bon escient. Certes la convention concerne les variables d'instances mais pourquoi pas pour des variables partagées (variables de classe)....
dans ton cas en plus tu me dis qu'elle est uniquement utilisée dans la classe donc ça veut dire que dans ton propre code tu te donnes comme consigne de ne modifier qu'en passant par ton set (que tu peux même mettre private pour faire bonne mesure ).

**bbsebb** · 27/02/2021, 14h43

merci, c'est bien claire cette fois

Design pattern MVC - est ce que je suis dans le bon ?

Langage Java

Discussions similaires

Partager

Partager