[JAVA] Modèle de conception ~ Commande ~

1.Tout d'abord

Voici un résumé du ** modèle de commande ** dans le modèle de conception du GoF.

2. Quel est le modèle de commande?

• Le mot anglais Command signifie ** commande **.
• Le modèle de commande est une méthode d'expression ** d'une instance d'une classe qui représente une instruction comme une seule **.
• Si vous souhaitez gérer l'historique des instructions, vous pouvez gérer la collection d'instances. Si vous enregistrez une collection d'instructions, vous pouvez exécuter la même instruction ou combiner plusieurs instructions et les réutiliser en tant que nouvelles instructions.
• Les modèles de conception du GoF sont classés comme des ** modèles de conception comportementale **.

3. Exemple de diagramme de classes

4. Exemple de programme

C'est un programme de dessin simple.

4-1. Interface de commande

Une interface qui exprime des instructions.

Command.java

package command;

public interface Command {
	public abstract void execute();
}

4-2. Classe MacroCommand

Cette classe exprime des "instructions qui combinent plusieurs instructions".

MacroCommand.java

package command;

import java.util.Iterator;
import java.util.Stack;

public class MacroCommand implements Command {

	//Jeu d'instructions
	private Stack commands = new Stack();

	public void execute() {
		Iterator it = commands.iterator();
		while (it.hasNext()) {
			((Command) it.next()).execute();
		}
	}

	//ajouter à
	public void append(Command cmd) {
		if (cmd != this) {
			commands.push(cmd);
		}
	}

	//Supprimer la dernière instruction
	public void undo() {
		if (!commands.empty()) {
			commands.pop();
		}
	}

	//Tout supprimer
	public void clear() {
		commands.clear();
	}
}

4-3. Interface dessinable

C'est une interface qui exprime la "cible de dessin".

Drawable.java

package drawer;

public interface Drawable {
	public abstract void draw(int x, int y);
}

4-4. Classe DrawCanvas

Cette classe implémente "dessin cible".

DrawCanvas.java

package drawer;

import java.awt.Canvas;
import java.awt.Color;
import java.awt.Graphics;

import command.MacroCommand;

public class DrawCanvas extends Canvas implements Drawable {

	//Couleur de dessin
	private Color color = Color.red;
	//Rayon des points à dessiner
	private int radius = 6;
	//Histoire
	private MacroCommand history;

	public DrawCanvas(int width, int height, MacroCommand history) {
		setSize(width, height);
		setBackground(Color.white);
		this.history = history;
	}

	//Redessinez toute l'histoire
	public void paint(Graphics g) {
		history.execute();
	}

	//dessin
	public void draw(int x, int y) {
		Graphics g = getGraphics();
		g.setColor(color);
		g.fillOval(x - radius, y - radius, radius * 2, radius * 2);
	}
}

4-5. Classe DrawCommand

Cette classe exprime la "commande de dessin de point".

DrawCommand.java

package drawer;

import java.awt.Point;

import command.Command;

public class DrawCommand implements Command {

	//Cible de dessin
	protected Drawable drawable;
	//Position du dessin
	private Point position;

	public DrawCommand(Drawable drawable, Point position) {
		this.drawable = drawable;
		this.position = position;
	}

	public void execute() {
		drawable.draw(position.x, position.y);
	}
}

4-6. Classe principale

Cette classe effectue le traitement principal.

Main.java

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;

import command.Command;
import command.MacroCommand;
import drawer.DrawCanvas;
import drawer.DrawCommand;

public class Main extends JFrame implements ActionListener, MouseMotionListener, WindowListener {

	//Histoire du dessin
	private MacroCommand history = new MacroCommand();
	//Zone de dessin
	private DrawCanvas canvas = new DrawCanvas(400, 400, history);
	//Bouton Annuler
	private JButton undoButton = new JButton("undo");
	//Bouton d'effacement
	private JButton clearButton = new JButton("clear");

	public Main(String title) {
		super(title);

		this.addWindowListener(this);
		canvas.addMouseMotionListener(this);
		undoButton.addActionListener(this);
		clearButton.addActionListener(this);

		Box buttonBox = new Box(BoxLayout.X_AXIS);
		buttonBox.add(undoButton);
		buttonBox.add(clearButton);
		Box mainBox = new Box(BoxLayout.Y_AXIS);
		mainBox.add(buttonBox);
		mainBox.add(canvas);
		getContentPane().add(mainBox);

		pack();
		show();
	}

	//Pour ActionListener
	public void actionPerformed(ActionEvent e) {
		Object source = e.getSource();
		if (source == undoButton) {
			history.undo();
			canvas.repaint();
		} else if (source == clearButton) {
			history.clear();
			canvas.repaint();
		}
	}

	//Pour MouseMotionListener
	public void mouseMoved(MouseEvent e) {
	}

	public void mouseDragged(MouseEvent e) {
		Command cmd = new DrawCommand(canvas, e.getPoint());
		history.append(cmd);
		cmd.execute();
	}

	//Pour WindowListener
	public void windowClosing(WindowEvent e) {
	}

	public void windowActivated(WindowEvent e) {
	}

	public void windowClosed(WindowEvent e) {
	}

	public void windowDeactivated(WindowEvent e) {
	}

	public void windowDeiconified(WindowEvent e) {
	}

	public void windowIconified(WindowEvent e) {
	}

	public void windowOpened(WindowEvent e) {
	}

	public static void main(String[] args) {
		new Main("Command Pattern Sample");
	}
}

4-7. Résultat de l'exécution

5. Avantages

En exprimant une "instruction" comme un objet, il est possible de conserver un historique de l'instruction et de réexécuter l'instruction. De plus, si vous souhaitez ajouter une nouvelle "instruction", il vous suffit de créer une classe qui implémente l'interface de commande, ce qui facilite l'extension de la fonctionnalité.

6. GitHub

• https://github.com/i-tanaka730/design_pattern

7. Liste des modèles de conception

• ** Résumé du modèle de conception du GoF **

8. Référence

Cet article et exemple de programme ont été créés à partir des livres suivants.

• ** Introduction aux modèles de conception appris en langage Java **

C'était très facile à comprendre et j'ai beaucoup appris. Je vous remercie. Les explications détaillées des modèles de conception et des exemples de programmes sont écrites, veuillez donc également consulter les livres.