IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Langage Java Discussion :

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


Sujet :

Langage Java

  1. #1
    Membre du Club
    Profil pro
    Inscrit en
    juillet 2007
    Messages
    87
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : juillet 2007
    Messages : 87
    Points : 66
    Points
    66
    Par défaut Design pattern MVC - est ce que je suis dans le bon ?
    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");
     
    	}
     
    }

  2. #2
    Membre actif
    Homme Profil pro
    Architecte technique
    Inscrit en
    mai 2020
    Messages
    161
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Architecte technique

    Informations forums :
    Inscription : mai 2020
    Messages : 161
    Points : 205
    Points
    205
    Par défaut
    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.

  3. #3
    Membre du Club
    Profil pro
    Inscrit en
    juillet 2007
    Messages
    87
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : juillet 2007
    Messages : 87
    Points : 66
    Points
    66
    Par défaut
    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 ?

  4. #4
    Membre actif
    Homme Profil pro
    Architecte technique
    Inscrit en
    mai 2020
    Messages
    161
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Architecte technique

    Informations forums :
    Inscription : mai 2020
    Messages : 161
    Points : 205
    Points
    205
    Par défaut
    Je ne sais pas si c'est une bonne habitude. Posez-vous la question de savoir ce que ça vous apporte..

  5. #5
    Membre chevronné
    Avatar de professeur shadoko
    Homme Profil pro
    retraité nostalgique Java SE
    Inscrit en
    juillet 2006
    Messages
    1 239
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 72
    Localisation : France, Hauts de Seine (Île de France)

    Informations professionnelles :
    Activité : retraité nostalgique Java SE

    Informations forums :
    Inscription : juillet 2006
    Messages : 1 239
    Points : 1 821
    Points
    1 821
    Par défaut
    Citation Envoyé par bbsebb Voir le message
    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.
    J'ai des principes: je peux toujours trouver une bonne raison pour les contredire .... mais j'ai des principes!
    (mon excellent bouquin sur Java : https://eska-publishing.com/fr/livre...822407076.html)

  6. #6
    Membre du Club
    Profil pro
    Inscrit en
    juillet 2007
    Messages
    87
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : juillet 2007
    Messages : 87
    Points : 66
    Points
    66
    Par défaut
    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)]

  7. #7
    Membre chevronné
    Avatar de professeur shadoko
    Homme Profil pro
    retraité nostalgique Java SE
    Inscrit en
    juillet 2006
    Messages
    1 239
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 72
    Localisation : France, Hauts de Seine (Île de France)

    Informations professionnelles :
    Activité : retraité nostalgique Java SE

    Informations forums :
    Inscription : juillet 2006
    Messages : 1 239
    Points : 1 821
    Points
    1 821
    Par défaut
    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.
    J'ai des principes: je peux toujours trouver une bonne raison pour les contredire .... mais j'ai des principes!
    (mon excellent bouquin sur Java : https://eska-publishing.com/fr/livre...822407076.html)

  8. #8
    Membre du Club
    Profil pro
    Inscrit en
    juillet 2007
    Messages
    87
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : juillet 2007
    Messages : 87
    Points : 66
    Points
    66
    Par défaut
    merci pour vos réponses

  9. #9
    Membre du Club
    Profil pro
    Inscrit en
    juillet 2007
    Messages
    87
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : juillet 2007
    Messages : 87
    Points : 66
    Points
    66
    Par défaut
    Citation Envoyé par professeur shadoko Voir le message
    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 ?

  10. #10
    Membre chevronné
    Avatar de professeur shadoko
    Homme Profil pro
    retraité nostalgique Java SE
    Inscrit en
    juillet 2006
    Messages
    1 239
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 72
    Localisation : France, Hauts de Seine (Île de France)

    Informations professionnelles :
    Activité : retraité nostalgique Java SE

    Informations forums :
    Inscription : juillet 2006
    Messages : 1 239
    Points : 1 821
    Points
    1 821
    Par défaut
    Citation Envoyé par bbsebb Voir le message
    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 ).
    J'ai des principes: je peux toujours trouver une bonne raison pour les contredire .... mais j'ai des principes!
    (mon excellent bouquin sur Java : https://eska-publishing.com/fr/livre...822407076.html)

  11. #11
    Membre du Club
    Profil pro
    Inscrit en
    juillet 2007
    Messages
    87
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : juillet 2007
    Messages : 87
    Points : 66
    Points
    66
    Par défaut
    merci, c'est bien claire cette fois

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Réponses: 16
    Dernier message: 04/01/2010, 00h10
  2. [AC-2007] Création d'un BdD, est ce que je suis dans la bonne voie
    Par Hitman_11 dans le forum Modélisation
    Réponses: 2
    Dernier message: 01/11/2009, 17h38
  3. Réponses: 4
    Dernier message: 24/02/2009, 12h06
  4. Réponses: 7
    Dernier message: 19/11/2007, 18h22
  5. Problème d'accessibilité avec le design patterns MVC
    Par radical_bombtracks dans le forum JSF
    Réponses: 5
    Dernier message: 24/07/2007, 13h15

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo