[GO] Ich habe ein Designmuster in der Kotlin Template Edition geschrieben
Erlernen des Konzepts der Schnittstelle und der Wiederverwendbarkeit von Objekten, die für die Objektorientierung wichtig sind ["Einführung in in Java-Sprache erlernte Entwurfsmuster"](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 & Schlüsselwörter = 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 Ich habe% 85% A5% E9% 96% 80 & qid = 1559563427 & s = gateway & sr = 8-1) kennengelernt und mich entschieden, in Kotlin zu schreiben, während ich in Java war. Dieses Mal werde ich die Vorlage zusammenfassen.
Was ist eine Vorlage?
Ein Entwurfsmuster, in dem die Oberklasse das Verarbeitungsframework definiert (ähnliche gemeinsame Verarbeitung) und die Unterklasse den spezifischen Inhalt definiert. Im Folgenden werden wir den allgemeinen Prozess des "5-maligen wiederholten Anzeigens von Zeichen und Zeichenketten" als konkreten Prozess in jeder Unterklasse implementieren.
AbstractDisplay-Klasse
Es werden vier abstrakte Methoden definiert, die als Typen dienen, und die spezifische Verarbeitung von Öffnen, Drucken und Schließen wird in der Unterklasse implementiert.
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()
}
}
CharDisplay-Klasse
Es ist eine Unterklasse, die AbstractDisplay, eine Vorlage, erbt. Diese Klasse implementiert eine bestimmte Verarbeitung, z. B. das Formatieren und Anzeigen eines im Konstruktor übergebenen Zeichens.
Beim Erben einer Schnittstelle mit Kotlin wurde () nicht benötigt, aber bei einer abstrakten Klasse muss beim Erben () wie AbstractDisplay () hinzugefügt werden, was bedeutet, dass die Schnittstelle keinen Konstruktor hat. Abstrakte Klassen werden standardmäßig angehängt, da Konstruktoren implementiert werden können.
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(">>")
}
StringDisplay-Klasse
Es ist eine Unterklasse, die AbstractDisplay, eine Vorlage, erbt. Diese Klasse implementiert eine bestimmte Verarbeitung, z. B. das Formatieren und Anzeigen der im Konstruktor übergebenen Zeichenfolge. Wenn Sie in Kotlin eine beliebige Zahl in der for-Anweisung angeben und umdrehen möchten, geben Sie "for i..width" an.
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("+")
}
}
Hauptklasse
Da es sich um eine Unterklasse handelt, die AbstractDisplay erbt, kann die Anzeigemethode aufgerufen werden, und die Ausgabe wird mit den in jeder implementierten Unterklasse definierten Inhalten ausgegeben.
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!!|
+-------------+
Klassen Diagramm
Impressionen
- Es gibt zwei Vorteile, Logik gemeinsam nutzen zu können. Da der Algorithmus durch die Vorlagenmethode der abstrakten Klasse definiert wird, muss er nicht in der Unterklasse beschrieben werden. Wenn die Vorlagenmethode einen Fehler enthält, nur die Vorlagenmethode Ich habe gelernt, dass der Einflussbereich begrenzt ist, weil er korrigiert werden kann.
- Wenn beispielsweise die Anzeigevorlagenmethode (Ausführungsmethode) in jeder Klasse kopiert und eingefügt wird, wird im Beispiel erwähnt, dass Änderungen in allen einzelnen Klassen erforderlich sind.
- Ich habe auch gelernt, dass das Prinzip, dass jede einer Variablen vom Typ einer Oberklasse zugewiesene Unterklasseninstanz ordnungsgemäß funktioniert, als Liskov-Substitutionsprinzip (LSP) bezeichnet wird.
- Ich habe gelernt, dass beim Schreiben einer for-Anweisung in Kotlin "for i..width" angegeben wird, add "()" beim Erben einer abstrakten Klasse und nicht beim Erben von Interface.
Referenz
Es war sehr leicht zu lesen und zu verstehen, wenn man sich auf Folgendes bezog.
Einführung in Kotlin für Java-Programmierer Reverse Kotlin
Recommended Posts