[GO] Dekorationsmuster in Java

Einführung

Einführung in die Entwurfsmuster von [GoF](https://ja.wikipedia.org/wiki/Gang of for _ (Information Engineering)) ["Einführung in Entwurfsmuster, die in der erweiterten und überarbeiteten Java-Sprache gelernt wurden"]( https://www.amazon.co.jp/ Ergänzende überarbeitete Ausgabe Einführung in in Java gelernte Entwurfsmuster-Yuki-Hiroshi / dp / 4797327030 / ref = pd_lpo_sbs_14_t_0? _ Encoding = UTF8 & psc = 1 & refRID = 2ZE4GPYNN55JGR Ich werde über zusammenfassen.

Dekorationsmuster

Was ist Dekorateur?

Übersetzt ins Japanische bedeutet es "Dekorateur". ** Ein Muster, das die Funktion erweitert, indem das Originalobjekt immer mehr dekoriert wird **, wird als ** Dekorationsmuster ** bezeichnet. Durch Anwenden dieses Musters können Sie die Funktionalität flexibel erweitern, ohne die Klasse zu ändern, von der aus sie erweitert wird.

Charakter

Das Decorator-Muster wird von den Klassen verwendet, die im folgenden Klassendiagramm angezeigt werden.

Abstrakte Klasse

• Component
  Stellt die zugrunde liegende abstrakte Klasse dar, die dekoriert (erweitert) werden soll.

• Decorator
  Eine abstrakte Klasse, die von der "Component" -Klasse erbt und die Basisklasse für die Dekorationsklasse ist. Besonders hervorzuheben ist, dass das Feld die zu dekorierende Klasse "Component" hat **.

Implementierungsklasse

• ConcreteComponent Eine Implementierungsklasse für die Klasse "Component". Implementiert alle abstrakten Methoden der Component-Klasse.

• ConcreteDecorator Eine Implementierungsklasse der Klasse "Decorator". Da die Decorator-Klasse von der Component-Klasse erbt, muss die abstrakte Methode der Component-Klasse implementiert werden.

Konkretes Beispiel

Als konkretes Beispiel werden wir anhand der folgenden Klasse erklären.

Abstrakte Klasse

• ** SpongeCake Klasse **

SpongeCake.java

public abstract class SpongeCake {
	public abstract String getName(); //Holen Sie sich einen Namen

	public abstract int getPrice(); //Holen Sie sich den Preis

	public void show() { //Name und Preis anzeigen
		System.out.println(getName() + ":" + getPrice() + "Kreis");
	}
}

Die SpongeCake -Klasse definiert eine Methode, um den Namen und den Preis als abstrakte Methode abzurufen, und eine Methode, um sie als konkrete Methode anzuzeigen. Es ist nur ein Biskuitkuchen ohne Dekoration. Die eigentliche Verarbeitung der abstrakten Klasse wird in der später beschriebenen Unterklasse implementiert. Es gibt nichts besonders Schwieriges.

• ** Dekorateurklasse **

Decorator.java

public abstract class Decorator extends SpongeCake {
	protected SpongeCake spongeCake; //Bezieht sich auf den "Inhalt", in den dieser dekorative Rahmen eingewickelt ist

	protected Decorator(SpongeCake spongeCake) { //Geben Sie beim Erstellen einer Instanz "Inhalt" als Argument an
		this.spongeCake = spongeCake;
	}
}

Die Decorator-Klasse erbt die oben beschriebene SpongeCake-Klasse, ist jedoch eine abstrakte Klasse, da sie die abstrakte Methode nicht überschreibt. ** Der Punkt ist, dass das zu dekorierende SpongeCake-Objekt im Feld gehalten und als Argument angegeben wird, wenn das Objekt vom Konstruktor erstellt wird **.

Implementierungsklasse

• ** ShortCake Klasse **

ShortCake.java

public class ShortCake extends SpongeCake {

	@Override
	public String getName() { //Überschreiben Sie die Methode, um den Namen der übergeordneten Klasse abzurufen
		return "Shortcake";
	}

	@Override
	public int getPrice() { //Überschreiben Sie die Methode, um den Preis der übergeordneten Klasse zu erhalten
		return 500;
	}

}

• ** ChocolateCake Klasse **

ChocolateCake.java

public class ChocolateCake extends SpongeCake {

	@Override
	public String getName() { //Überschreiben Sie die Methode, um den Namen der übergeordneten Klasse abzurufen
		return "Schokoladenkuchen";
	}

	@Override
	public int getPrice() { //Überschreiben Sie die Methode, um den Preis der übergeordneten Klasse zu erhalten
		return 700;
	}

}

Die "ShortCake" -Klasse und die "ChocolateCake" -Klasse sind Implementierungsklassen der "SpongeCake" -Klasse. Es ist ein Bild eines konkreteren Kuchens, indem ein Kuchen mit nur einem Schwamm leicht dekoriert wird. Es überschreibt die abstrakten Methoden "getName ()" und "getPrice ()" und gibt den Namen bzw. den Preis zurück. Auch hier gibt es nichts besonders Schwieriges.

• ** Strawberry Decorator Klasse **

StrawberryDecorator.java

public class StrawberryDecorator extends Decorator {

	public StrawberryDecorator(SpongeCake spongeCake) { //Übergeben Sie das Dekorationsziel im Konstruktor
		super(spongeCake);
	}

	@Override
	public String getName() { //Erdbeere am Anfang des Namens des Inhalts hinzugefügt
		return "Erdbeere" + spongeCake.getName();
	}

	@Override
	public int getPrice() { //Der Preis des Inhalts plus 100
		return spongeCake.getPrice() + 100;
	}

}

• ** Banana Decorator Klasse **

BananaDecorator.java

public class BananaDecorator extends Decorator {

	public BananaDecorator(SpongeCake spongeCake) { //Übergeben Sie das Dekorationsziel im Konstruktor
		super(spongeCake);
	}

	@Override
	public String getName() { //Banane am Anfang des Namens des Inhalts hinzugefügt
		return "Banane" + spongeCake.getName();
	}

	@Override
	public int getPrice() { //Der Preis des Inhalts plus 300
		return spongeCake.getPrice() + 300;
	}

}

Die StrawberryDecorator-Klasse und die BananaDecorator-Klasse sind Implementierungsklassen der Decorator-Klasse. Fügen Sie Erdbeeren und Bananen zu dem Biskuitkuchen (oder seinen Unterklassen) hinzu, der im Konstruktor als Dekoration angegeben ist. Fügen Sie den Preis auf die gleiche Weise hinzu.

Der Punkt ist, dass ** das Argument des Konstruktors vom Typ SpongeCake ** ist. Daraus können wir ersehen, dass die Argumente, die an den Konstruktor übergeben werden können, die SpongeCake-Klasse oder ihre Unterklassen ShortCake-Klasse und ChocolateCake-Klasse sind. Beachten Sie außerdem, dass die Decorator-Klasse auch eine Unterklasse der SpongeCake-Klasse ist. Mit anderen Worten, ** die "StrawberryDecorator" -Klasse und die "BananaDecorator" -Klasse, die von der Decorator-Klasse erben, können als Argumente des Konstruktors der "StrawberryDecorator" -Klasse angegeben werden, die die Dekoration ausführt **. Dies ermöglicht es, dem dekorierten Objekt mehr Dekoration hinzuzufügen.

Ausführungsklasse

-** Hauptklasse **

Main.java

public class Main {
	public static void main(String[] args) {
		//Erzeugung eines kurzen Kuchens
		SpongeCake s1 = new ShortCake();
		SpongeCake s2 = new StrawberryDecorator(s1);
		SpongeCake s3 = new BananaDecorator(s1);
		SpongeCake s4 = new StrawberryDecorator(new ShortCake());
		SpongeCake s5 = new StrawberryDecorator(new BananaDecorator(new ShortCake()));
		s1.show();
		s2.show();
		s3.show();
		s4.show();
		s5.show();
		System.out.println("--------------------------------------------");
		//Erzeugung von Schokoladenkuchen
		SpongeCake c1 = new ChocolateCake();
		SpongeCake c2 = new StrawberryDecorator(c1);
		SpongeCake c3 = new BananaDecorator(c1);
		SpongeCake c4 = new StrawberryDecorator(new ChocolateCake());
		SpongeCake c5 = new StrawberryDecorator(new BananaDecorator(new ChocolateCake()));
		c1.show();
		c2.show();
		c3.show();
		c4.show();
		c5.show();
	}
}

Wir haben Instanzen der "ShortCake" -Klasse und der "ChocolateCake" -Klasse erstellt und jeweils dekoriert. Wie in der Erläuterung der Klasse "StrawberryDecorator" und der Klasse "BananaDecorator" erwähnt, ist der Punkt, dass ** Da die zu dekorierende Klasse im Argument des Konstruktors angegeben werden kann, ist es möglich, mehrere Dekorationen durchzuführen. Das ist **.

Ebenfalls,

4,5. Zeile

SpongeCake s1 = new ShortCake();
SpongeCake s2 = new StrawberryDecorator(s1);

Wann

7. Zeile

SpongeCake s4 = new StrawberryDecorator(new ShortCake());

Gibt nur den "ShortCake" an, der im Konstruktor dekoriert werden soll, und obwohl die Schreibmethode unterschiedlich ist, handelt es sich tatsächlich um denselben Vorgang.

Ausführungsergebnis

Das Ergebnis der Ausführung von "Main.java" ist wie folgt. Sie können sehen, dass der ursprüngliche Kurzkuchen und der Schokoladenkuchen immer mehr dekoriert werden.

Ausführungsergebnis

Shortcake:500 Yen
Erdbeer-Kurzkuchen:600 Yen
Bananen-Kurzkuchen:800 Yen
Erdbeer-Kurzkuchen:600 Yen
Erdbeer-Bananen-Kurzkuchen:900 Yen
--------------------------------------------
Schokoladenkuchen:700 Yen
Erdbeer-Schokoladenkuchen:800 Yen
Bananenschokoladenkuchen:1000 Yen
Erdbeer-Schokoladenkuchen:800 Yen
Erdbeer-Bananen-Schokoladenkuchen:1100 Yen

verdienen

Die Vorteile des Dekorationsmusters sind wie folgt. ** 1. ** Funktionen können hinzugefügt werden, ohne die geerbte Klasse zu ändern. ** 2. ** Durch Kombinieren der erforderlichen Teile können verschiedene Funktionen hinzugefügt werden.

Zusammenfassung

Ich habe etwas über das Dekorationsmuster gelernt, bei dem es sich um eine Reihe von Dekorationen auf Objekten handelt. Der Beispielcode wird unten hochgeladen. Wenn Sie möchten, lesen Sie ihn bitte.

• Decorator-Beispielcode

Darüber hinaus sind unten weitere Entwurfsmuster zusammengefasst. Bitte beziehen Sie sich auch auf diese.

• [Von Zeit zu Zeit aktualisiert] Zusammenfassung der Entwurfsmuster in Java

Verweise

• [Einführung in Entwurfsmuster, die in der erweiterten und überarbeiteten Java-Sprache gelernt wurden](https://www.amazon.co.jp/ Einführung in Entwurfsmuster, die in der erweiterten und überarbeiteten Java-Sprache gelernt wurden - Yuki-Hiroshi / dp / 4797327030 / ref = pd_lpo_sbs_14_t_0? _Encoding = UTF8 & psc = 1 & refRID = 2ZE4GPYNN55JGDR5QMHP)