[GO] Ich habe ein Designmuster in der Kotlin Factory 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 über Factory schreiben.

Was ist Fabrik?

Vorlagenmuster ist so konzipiert, dass die Oberklasse das Verarbeitungsframework definiert (ähnliche gemeinsam genutzte Verarbeitung) und die Unterklasse den spezifischen Inhalt definiert. Während es ein Muster war, ist es ein Entwurfsmuster, das den Rahmen für die Instanziierung definiert. Im Folgenden wird das Framework zum Erstellen einer Instanz und die Unterklasse implementiert, die tatsächlich einen Ausweis (eine Instanz) erstellt.

Produktklasse

Diese Klasse ist eine abstrakte Klasse, die "Produkt" definiert, und die Verwendungsmethode wird unter der Voraussetzung definiert, dass das Produkt "verwendet" wird. Die Abstraktion kann auch dazu führen, dass es als Produktrolle "verwendet" wird. (Ich fühlte die Absicht.)

Selbst wenn Sie in kotlin Unit nicht als void angeben, ist der Typ der Funktion, die den Rückgabewert nicht angibt, Unit. Es wurde auch darauf hingewiesen, dass es in der IDE redundant ist.

Referenz: Kenntnis des Kotlin-Typs ~ Teil 1 ~

`Product.java`


abstract class Product {
	public abstract void use();
}

`Product.kt`


abstract class Product {
    abstract fun use()
}

Fabrikklasse

Hier werden wir das Framework für die Instanziierung implementieren. Der Punkt ist, dass "Erstellen eines Produkts" und "Registrieren mit einem Produkt" der Implementierung der Unterklasse überlassen bleiben, aber die Prozedur in der Erstellungsmethode kann die Absicht lesen, dass "die Definition entschieden wird" als endgültig in der Factory-Klasse. Ich werde.

Der Unterschied zwischen Kotlin und Java Protected besteht darin, dass auf Java von einer Unterklasse oder einer Klasse desselben Pakets aus zugegriffen werden kann, während auf Kotlin nur von einer Unterklasse aus zugegriffen werden kann. Hier verwenden wir kotlin protected, auf das nur von Unterklassen aus zugegriffen werden kann.

Referenz: Beziehung zwischen Kotlin- und Java-Zugriffsmodifikatoren

In Java ist es auch eine öffentliche endgültige Erstellungsmethode, aber Kotlin ist "Standard" und eine öffentliche endgültige Methode, daher wird sie nicht angegeben.

`Factory.java`


abstract class Factory {
	public final Product create(String owner) {
		Product p = createProduct(owner);
		registerProduct(p);
		return p;
	}
	protected abstract Product createProduct(String owner);
	protected abstract void registerProduct(Product product);
}

`Factory.kt`


abstract class Factory {
    fun create(owner: String): Product {
        val p = createProduct(owner)
        registerProduct(p)
        return  p
    }
    protected abstract fun createProduct(owner: String): Product
    protected abstract fun registerProduct(product: Product)
}

IDCard-Klasse

Wir definieren Unterklassen als tatsächliche Produkte, die von der Produktklasse erben.

Definieren Sie "init", wenn Sie den Konstruktor mit kotlin initialisieren.

Referenz: [Kotlin] So schreiben Sie einen Konstruktor

`IDCard.java`


class IDCard extends Product {
	private String owner;
	public IDCard(String owner) {
		System.out.println(owner + "Eine Karte machen.");
		this.owner = owner;
	}
	public void use() {
		System.out.println(owner + "Verwenden Sie die Karte.");
	}
	public String getOwner() {
		return owner;
	}
}

`IDCard.kt`


class IDCard (private val owner: String): Product() {
    init { println(owner + "Eine Karte machen.") }
    override fun use() = println(owner + "Verwenden Sie die Karte.")
    fun getOwner() = owner
}

IDCardFactory-Klasse

Es erbt die Factory-Klasse, die das Framework zum Erstellen einer Instanz darstellt, und implementiert eine bestimmte Verarbeitung. Die Methode createProduct, mit der eine Instanz erstellt und das Produkt tatsächlich erstellt wird, und die Methode registerProduct, mit der die Registrierung im Feld "Eigentümer" realisiert wird, sind implementiert.

In Kotlin scheint List schreibgeschützt zu sein und verwendet mutableList, das hinzugefügt werden kann.

Referenz: Kotlin und Liste

Außerdem verwendet Kotlin beim Instanziieren nicht new.

Referenz: Kotlin-Syntaxklassen, Vererbung, Eigenschaften

Außerdem haben wir anstelle der Instanz in der Besetzung eine intelligente Besetzung implementiert, mit der der Compiler gut umgehen kann.

Referenz: Wo Java-Programmierer dazu neigen, über Kotlin zu stolpern

`IDCardFactory.java`


class IDCardFactory extends Factory {
	private List<String> owners = new ArrayList<String>();

	@Override
	protected Product createProduct(String owner) {
		return new IDCard(owner);
	}

	@Override
	protected void registerProduct(Product product) {
		owners.add(((IDCard)product).getOwner());
	}
	
	public List<String> getOwners() {
		return owners;
	}
}

`IDCardFactory.kt`


class IDCardFactory: Factory() {
    private var owners: MutableList<String> = mutableListOf()
    override fun createProduct(owner: String) = IDCard(owner)
    override fun registerProduct(product: Product) {
        if(product is IDCard) owners.add(product.getOwner()) //smart cast
    }
    fun getOwners() = owners
}

Hauptklasse

Ich werde einen Ausweis erstellen.

`FactorySample.java`


public class FactorySample {
	public static void main(String[] args) {
		Factory factory = new IDCardFactory();
		Product card1 = factory.create("Sato");
		Product card2 = factory.create("Suzuki");
		Product card3 = factory.create("Tanaka");
		card1.use();
		card2.use();
		card3.use();
		((IDCardFactory)factory).getOwners().stream().forEach(System.out::println);
	}
}

`FactorySample.kt`


fun main(args: Array<String>){
    val factory = IDCardFactory()
    val card1 = factory.create("Sato")
    val card2 = factory.create("Suzuki")
    val card3 = factory.create("Tanaka")
    card1.use()
    card2.use()
    card3.use()
    factory.getOwners().forEach(System.out::println)
}

`Ausführungsergebnis`


Mach Satos Karte.
Ich werde eine Suzuki-Karte machen.
Mach Tanakas Karte.
Ich werde Satos Karte benutzen.
Ich werde Suzukis Karte benutzen.
Ich werde Tanakas Karte benutzen.
Sato
Suzuki
Tanaka

Klassen Diagramm

Impressionen

Die Factory-Klasse beschreibt nicht die IDCard-Klasse, die tatsächlich generiert wird, und das Produkt wird durch Aufrufen der Produkt- und Instanzerstellungsmethoden generiert. Daher habe ich festgestellt, dass es von Vorteil ist, dass keine Bindung durch einen bestimmten Klassennamen besteht. Es ist.
Wie oben nicht erwähnt, sollte es keine Bindung nach einer bestimmten Klasse oder einem bestimmten Paket geben, wenn Factory und Product im selben Paket sind und IDCard und IDCardFactory in unterschiedlichen Paketen definiert sind (z. B. Framework-Paket und IDcard-Paket). Ich habe gelernt auszudrücken, dass "Framwork-Paket nicht vom IDcard-Paket abhängt".
Ich habe die folgenden Punkte über Kotlin gelernt

Wenn Sie keinen Rückgabewert angeben, wird standardmäßig "Unit" (ungültig) angegeben, sodass Sie ihn nicht definieren müssen.
Die Spezifikation von "protected" unterscheidet sich von Java
Die Methodendefinition ist standardmäßig "public final"
Verwenden Sie init, um den Konstruktor zu initialisieren
"List" kann schreibgeschützt sein, "mutableList" kann hinzugefügt werden
Verwenden Sie beim Erstellen einer Instanz nicht new
"Smart Cast" ist praktisch für das Casting

Referenz

Es war sehr leicht zu lesen und zu verstehen, wenn man sich auf Folgendes bezog.

Kenntnis des Kotlin-Typs ~ Teil 1 ~ Beziehung zwischen Kotlin- und Java-Zugriffsmodifikatoren [Kotlin] Wie schreibe ich einen Konstruktor? Kotlin und Liste Kotlin-Syntaxklassen, Vererbung, Eigenschaften Wo Java-Programmierer dazu neigen, über Kotlin zu stolpern