[GO] J'ai écrit un modèle de conception dans l'édition de modèle kotlin

Pour apprendre le concept d'interface et la réutilisabilité des objets, qui sont importants dans l'orientation des objets ["Introduction aux modèles de conception appris en langage Java"](https://www.amazon.co.jp/%E5%A2%97% E8% A3% 9C% E6% 94% B9% E8% A8% 82% E7% 89% 88Java% E8% A8% 80% E8% AA% 9E% E3% 81% A7% E5% AD% A6% E3% 81% B6% E3% 83% 87% E3% 82% B6% E3% 82% A4% E3% 83% B3% E3% 83% 91% E3% 82% BF% E3% 83% BC% E3% 83% B3% E5% 85% A5% E9% 96% 80-% E7% B5% 90% E5% 9F% 8E-% E6% B5% A9 / dp / 4797327030 / ref = sr_1_1? __Mk_ja_JP =% E3% 82% AB % E3% 82% BF% E3% 82% AB% E3% 83% 8A & mots-clés = java% E8% A8% 80% E8% AA% 9E% E3% 81% A7% E5% AD% A6% E3% 81% B6 % E3% 83% 87% E3% 82% B6% E3% 82% A4% E3% 83% B3% E3% 83% 91% E3% 82% BF% E3% 83% BC% E3% 83% B3% E5 J'ai appris à propos de% 85% A5% E9% 96% 80 & qid = 1559563427 & s = gateway & sr = 8-1) et j'ai décidé d'écrire en kotlin pendant que j'étais en Java. Cette fois, je vais résumer Template.

Quel est le modèle

Un modèle de conception dans lequel la superclasse définit le cadre de traitement (traitement partagé similaire) et la sous-classe définit le contenu spécifique. Dans ce qui suit, nous implémenterons le processus courant «d'afficher des caractères et des chaînes de caractères 5 fois de façon répétée» comme processus concret dans chaque sous-classe.

Classe AbstractDisplay

Quatre méthodes abstraites servant de types sont définies et le traitement spécifique d'ouverture, d'impression et de fermeture est implémenté dans la sous-classe.

AbstractDisplay.java

abstract class AbstractDisplay {
	public abstract void open();
	public abstract void print();
	public abstract void close();
	public final void display() {
		open();
		for(int i = 0; i < 5; i++) {
			print();
		}
		close();
	}
}

AbstractDisplay.kt

abstract class AbstractDisplay {
    abstract fun open(): Unit
    abstract fun print(): Unit
    abstract fun close(): Unit
    fun display(): Unit {
        open()
        for (i: Int in 1..5) print()
        close()
    }
}

Classe CharDisplay

C'est une sous-classe qui hérite de AbstractDisplay, qui est un modèle, et cette classe implémente un traitement spécifique tel que le formatage et l'affichage d'un caractère passé dans le constructeur. Lors de l'héritage d'une interface avec Kotlin, () n'était pas nécessaire, mais avec une classe abstraite, il est nécessaire d'ajouter () comme AbstractDisplay () lors de l'héritage, ce qui signifie que l'interface n'a pas de constructeur, Les classes abstraites sont attachées par défaut car les constructeurs peuvent être implémentés.

CharDisplay.java

class CharDisplay extends AbstractDisplay {
	private char ch;
	public CharDisplay(char ch) {
		this.ch = ch;
	}
	@Override
	public void open() {
		System.out.print("<<");
	}
	@Override
	public void print() {
		System.out.print(ch);
	}
	@Override
	public void close() {
		System.out.println(">>");
	}
}

CharDisplay.kt

class CharDisplay(private val ch: Char): AbstractDisplay() {
    override fun open() = print("<<")
    override fun print() = print(ch)
    override fun close() = println(">>")
}

Classe StringDisplay

C'est une sous-classe qui hérite de AbstractDisplay, qui est un modèle, et cette classe implémente un traitement spécifique tel que le formatage et l'affichage de la chaîne de caractères passée dans le constructeur. Dans Kotlin, si vous souhaitez spécifier un nombre arbitraire dans l'instruction for et l'activer, spécifiez for i..width.

StringDisplay.java

class StringDisplay extends AbstractDisplay {
	private String str;
	private int width;
	public StringDisplay(String str) {
		this.str = str;
		this.width = str.getBytes().length;
	}
	@Override
	public void open() {
		printLine();
	}
	@Override
	public void print() {
		System.out.println("|" + str + "|");
	}
	@Override
	public void close() {
		printLine();
	}
	private void printLine() {
		System.out.print("+");
		for(int i = 0; i < width; i++) {
			System.out.print("-");
		}
		System.out.println("+");
	}
}

StringDisplay.kt

class StringDisplay(private val str: String, private  val width: Int = str.length): AbstractDisplay() {
    override fun open()= printLine()
    override fun print() = println("|" + this.str + "|")
    override fun close() = printLine()
    private fun printLine() {
        print("+")
        for (i: Int in 1..width) print("-")
        println("+")
    }
}

Classe principale

Puisqu'il s'agit d'une sous-classe qui hérite de AbstractDisplay, la méthode d'affichage peut être appelée et la sortie est sortie avec le contenu défini dans chaque sous-classe implémentée.

TemplateSample.java

public class TemplateSample {
	public static void main(String[] args) {
		AbstractDisplay d1 = new CharDisplay('H');
		AbstractDisplay d2 = new StringDisplay("Hello, World");
		AbstractDisplay d3 = new StringDisplay("Hello World!!");
		
		d1.display();
		d2.display();
		d3.display();
	}
}

Template.kt

fun main(args: Array<String>){
    val d1: AbstractDisplay = CharDisplay('H')
    val d2: AbstractDisplay = StringDisplay("Hello, World")
    val d3: AbstractDisplay = StringDisplay("Hello World!!")

    d1.display()
    d2.display()
    d3.display()
}

<<HHHHH>>
+------------+
|Hello, World|
|Hello, World|
|Hello, World|
|Hello, World|
|Hello, World|
+------------+
+-------------+
|Hello World!!|
|Hello World!!|
|Hello World!!|
|Hello World!!|
|Hello World!!|
+-------------+

Diagramme de classe

Impressions

• Il y a deux avantages que la logique puisse être partagée, et comme l'algorithme est défini par la méthode template de la classe abstraite, il n'est pas nécessaire de le décrire dans la sous-classe, et s'il y a un bogue dans la méthode template, uniquement la méthode template J'ai appris que la plage d'influence est limitée car elle peut être corrigée.
• Par exemple, si la méthode de modèle d'affichage (méthode d'exécution) est écrite en copier-coller dans chaque classe, il est mentionné dans l'exemple que des modifications sont nécessaires dans toutes les classes individuelles.
• J'ai également appris que le principe selon lequel toute instance de sous-classe affectée à une variable de type superclasse fonctionne correctement s'appelle le principe de substitution de Liskov (LSP).
• J'ai appris que lors de l'écriture d'une instruction for dans Kotlin, spécifiez for i..width, add () lors de l'héritage d'une classe abstraite, et non lors de l'héritage d'Interface.

référence

C'était très facile à lire et à comprendre en se référant à ce qui suit.

Introduction à Kotlin pour les programmeurs Java Reverse Kotlin