[JAVA] Modèle de conception ~ Interprète ~

1.Tout d'abord

Voici un résumé du ** modèle d'interprétation ** du modèle de conception du GoF.

2. Quel est le modèle d'interprétation?

Le mot anglais interprète signifie ** interprète **. ――Le modèle Interpreter est une méthode qui ** analyse et exprime le contenu d'un fichier écrit dans un certain format avec un programme qui agit comme un "interpréteur" **.
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

Un programme qui analyse la langue écrite dans un fichier texte. La notation BNF est utilisée dans la grammaire de la langue utilisée dans le texte à analyser.

<program> ::= program <command list>
<command list> ::= <command>* end
<command> ::= <repeat command> | <primitive command>
<repeat command> ::= repeat <number> <command list>
<primitive command> ::= go | right | left

--<programme>・・・ Le programme de jetons est suivi de la colonne de commande . --<liste de commandes>・・・ est répétée à 0 ou plus, suivie de la fin du jeton. --<commande>・・・ Soit la commande de répétition <commande de répétition> soit la commande de base . (| Représente ou) --<commande de répétition>・・・ La répétition du jeton est suivie du nombre de répétitions , suivi de la colonne de commande . --<commande primitive>・・・ aller ou droite ou gauche.

4-1. Classe de contexte

Une classe qui représente le contexte de l'analyse syntaxique.

`Context.java`


import java.util.StringTokenizer;

public class Context {

	private StringTokenizer tokenizer;
	private String currentToken;

	public Context(String text) {
		tokenizer = new StringTokenizer(text);
		nextToken();
	}

	public String nextToken() {
		if (tokenizer.hasMoreTokens()) {
			currentToken = tokenizer.nextToken();
		} else {
			currentToken = null;
		}
		return currentToken;
	}

	public String currentToken() {
		return currentToken;
	}

	public void skipToken(String token) throws Exception {
		if (!token.equals(currentToken)) {
			throw new Exception("Warning: " + token + " is expected, but " + currentToken + " is found.");
		}
		nextToken();
	}

	public int currentNumber() throws Exception {
		int number = 0;
		try {
			number = Integer.parseInt(currentToken);
		} catch (NumberFormatException e) {
			throw new Exception("Warning: " + e);
		}
		return number;
	}
}

4-2. Classe de nœud

Cette classe est le "nœud" de l'arbre syntaxique.

`Node.java`


public abstract class Node {
	public abstract void parse(Context context) throws Exception;
}

4-3. Classe ProgramNode

Cette classe correspond à .

`ProgramNode.java`


// <program> ::= program <command list>
public class ProgramNode extends Node {

	private Node commandListNode;

	public void parse(Context context) throws Exception {
		context.skipToken("program");
		commandListNode = new CommandListNode();
		commandListNode.parse(context);
	}

	public String toString() {
		return "[program " + commandListNode + "]";
	}
}

4-4. Classe CommandNode

Cette classe correspond à .

`CommandNode.java`


// <command> ::= <repeat command> | <primitive command>
public class CommandNode extends Node {

	private Node node;

	public void parse(Context context) throws Exception {
		if (context.currentToken().equals("repeat")) {
			node = new RepeatCommandNode();
			node.parse(context);
		} else {
			node = new PrimitiveCommandNode();
			node.parse(context);
		}
	}

	public String toString() {
		return node.toString();
	}
}

4-5. Classe RepeatCommandNode

Cette classe correspond à la <commande de répétition>.

`RepeatCommandNode.java`


// <repeat command> ::= repeat <number> <command list>
public class RepeatCommandNode extends Node {

	private int number;
	private Node commandListNode;

	public void parse(Context context) throws Exception {
		context.skipToken("repeat");
		number = context.currentNumber();
		context.nextToken();
		commandListNode = new CommandListNode();
		commandListNode.parse(context);
	}

	public String toString() {
		return "[repeat " + number + " " + commandListNode + "]";
	}
}

4-6. Classe CommandListNode

Cette classe correspond à .

`CommandListNode.java`


import java.util.ArrayList;

// <command list> ::= <command>* end
public class CommandListNode extends Node {

	private ArrayList list = new ArrayList();

	public void parse(Context context) throws Exception {
		while (true) {
			if (context.currentToken() == null) {
				throw new Exception("Missing 'end'");
			} else if (context.currentToken().equals("end")) {
				context.skipToken("end");
				break;
			} else {
				Node commandNode = new CommandNode();
				commandNode.parse(context);
				list.add(commandNode);
			}
		}
	}

	public String toString() {
		return list.toString();
	}
}

4-7. Classe PrimitiveCommandNode

Cette classe correspond à .

`PrimitiveCommandNode.java`


// <primitive command> ::= go | right | left
public class PrimitiveCommandNode extends Node {

	private String name;

	public void parse(Context context) throws Exception {
		name = context.currentToken();
		context.skipToken(name);
		if (!name.equals("go") && !name.equals("right") && !name.equals("left")) {
			throw new Exception(name + " is undefined");
		}
	}

	public String toString() {
		return name;
	}
}

4-8. Texte à analyser

Le texte à analyser syntaxiquement.

`program.txt`


program end
program go end
program go right go right go right go right end
program repeat 4 go right end end
program repeat 4 repeat 3 go right go left end right end end

4-9. Classe principale

Cette classe effectue le traitement principal.

`Main.java`


import java.io.BufferedReader;
import java.io.FileReader;

public class Main {
	public static void main(String[] args) {
		try {
			BufferedReader reader = new BufferedReader(new FileReader("program.txt"));
			String text;
			while ((text = reader.readLine()) != null) {
				System.out.println("text = \"" + text + "\"");
				Node node = new ProgramNode();
				node.parse(new Context(text));
				System.out.println("node = " + node);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

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

text = "program end"
node = [program []]
text = "program go end"
node = [program [go]]
text = "program go right go right go right go right end"
node = [program [go, right, go, right, go, right, go, right]]
text = "program repeat 4 go right end end"
node = [program [[repeat 4 [go, right]]]]
text = "program repeat 4 repeat 3 go right go left end right end end"
node = [program [[repeat 4 [[repeat 3 [go, right, go, left]], right]]]]

5. Avantages

Le modèle Interpreter facilite l'ajout ou la modification de règles. L'une des caractéristiques du modèle Interpreter est qu '"une règle est représentée par une classe". En d'autres termes, si vous souhaitez ajouter une nouvelle règle, tout ce que vous avez à faire est d'ajouter une sous-classe de la classe Node. De plus, si vous modifiez la règle, il vous suffit de modifier la sous-classe de la classe Node.

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.