Decorator (Design Pattern) - Versionsgeschichte

L-ectron-X am 28. März 2018 um 09:00 Uhr

2018-03-28T09:00:31Z

← Nächstältere Version		Version vom 28. März 2018, 09:00 Uhr
Zeile 1:		Zeile 1:
	In unserer Designs ist es oft nützlich, das Verhalten eines Objektes zur Laufzeit zu erweitern, ohne vorhandenen Code ändern zu müssen. Wir können die Komposition und die Delegation benutzen, um neue Verhaltensweisen zur Laufzeit hinzuzufügen.		In unserer Designs ist es oft nützlich, das Verhalten eines [[Objekt\|Objektes]] zur [[Laufzeit]] zu erweitern, ohne vorhandenen [[Code]] ändern zu müssen. Wir können die [[Komposition]] und die [[Delegation]] benutzen, um neue Verhaltensweisen zur Laufzeit hinzuzufügen.

	Das Decorator Design Pattern fügt einem Objekt dynamisch Verantwortung hinzu. Zwecks Erweiterung der Funktionalität eines Objekts, bietet das Decorator Design Pattern eine flexible Alternative zur Vererbung.		Das Decorator Design Pattern fügt einem Objekt dynamisch Verantwortung hinzu. Zwecks Erweiterung der Funktionalität eines Objekts, bietet das Decorator Design Pattern eine flexible Alternative zur [[Vererbung]].

	Das Decorator Design Pattern impliziert die Schaffung einer Reihe von Decorator-Klassen, welche die Komponenten umhüllen.		Das Decorator Design Pattern impliziert die Schaffung einer Reihe von Decorator-Klassen, welche die Komponenten umhüllen.
Zeile 12:		Zeile 12:
	Nehmen wir zum Beispiel den abstrakten Obertyp "Pet"		Nehmen wir zum Beispiel den abstrakten Obertyp "Pet"

	<~~code~~=java>package tierschau;		<syntaxhighlight lang="java">package tierschau;

	public abstract class Pet		public abstract class Pet
Zeile 48:		Zeile 48:
	}		}
	}		}
	</~~code=java~~>		</syntaxhighlight>

	und den konkrete Untertyp "Katze", der von "Pet" abgeleitet ist:		und den konkrete Untertyp "Katze", der von "Pet" abgeleitet ist:

	<~~code~~=java>package tierschau;		<syntaxhighlight lang="java">package tierschau;

	public class Katze extends Pet		public class Katze extends Pet
Zeile 69:		Zeile 69:
	}		}
	}		}
	</~~code=java~~>		</syntaxhighlight>

	Wir haben den Namen der konkreten Klasse in der Eigenschaft "species" der abstrakten Klasse "Pet" gespeichert (um zu vermeiden, dass wir uns zu einem späteren Zeitpunkt auf die konkrete Klasse "Katze" beziehen müssen).		Wir haben den Namen der konkreten [[Klasse]] in der Eigenschaft "species" der abstrakten Klasse "Pet" gespeichert (um zu vermeiden, dass wir uns zu einem späteren Zeitpunkt auf die konkrete Klasse "Katze" beziehen müssen).

	Um das Verhalten eines "Pet" zu erweitern, führen wir den abstrakten Decorator "PetBehavior" hinzu. Erinnern wir uns daran, dass der Decorator den gleichen Typ hat wie die Komponente, die er umhüllt. Das ist der Grund, weshalb wir ihn von "Pet" ableiten:		Um das Verhalten eines "Pet" zu erweitern, führen wir den abstrakten Decorator "PetBehavior" hinzu. Erinnern wir uns daran, dass der Decorator den gleichen Typ hat wie die Komponente, die er umhüllt. Das ist der Grund, weshalb wir ihn von "Pet" ableiten:

	<~~code~~=java>package tierschau;		<syntaxhighlight lang="java">package tierschau;

	public abstract class PetBehavior extends Pet		public abstract class PetBehavior extends Pet
Zeile 85:		Zeile 85:
	}		}
	}		}
	</~~code=java~~>		</syntaxhighlight>

	Wir verwirklichen den abstrakten "Decorator" durch die zwei konkreten Implementierungen "PetSchnurrend" und "PetFauchend":		Wir verwirklichen den abstrakten "Decorator" durch die zwei konkreten Implementierungen "PetSchnurrend" und "PetFauchend":

	<~~code~~=java>package tierschau;		<syntaxhighlight lang="java">package tierschau;

	public class PetSchnurrend extends PetBehavior		public class PetSchnurrend extends PetBehavior
Zeile 109:		Zeile 109:
	}		}
	}		}
	</~~code=java~~>		</syntaxhighlight>


	<~~code~~=java>package tierschau;		<syntaxhighlight lang="java">package tierschau;

	public class PetFauchend extends PetBehavior		public class PetFauchend extends PetBehavior
Zeile 132:		Zeile 132:
	}		}
	}		}
	</~~code=java~~>		</syntaxhighlight>

	Beachten wir in diesen konkreten "Decorators":		Beachten wir in diesen konkreten "Decorators":

	* die Anwesenheit der Eigenschaft "pet", die sich auf die Komponente bezieht, die vom Decorator umhüllt wird.		* die Anwesenheit der Eigenschaft "pet", die sich auf die Komponente bezieht, die vom Decorator umhüllt wird.
	* das Hinzufügen eines neuen Verhaltens in der Methode laut() nach dem Aufruf der Methode laut() der Komponente: '''return pet.laut() + ", schnurren", ''' (in PetSchnurrend) und '''return pet.laut() + ", fauchen"; ''' (in PetFauchend)		* das Hinzufügen eines neuen Verhaltens in der [[Methode]] laut() nach dem Aufruf der Methode laut() der Komponente: '''return pet.laut() + ", schnurren", ''' (in PetSchnurrend) und '''return pet.laut() + ", fauchen"; ''' (in PetFauchend)

	Schließlich zeigen wir hier die Startklasse der Anwendung "MeineTierschau":		Schließlich zeigen wir hier die Startklasse der Anwendung "MeineTierschau":

	<~~code~~=java>package tierschau;		<syntaxhighlight lang="java">package tierschau;

	public class MeineTierschau		public class MeineTierschau
Zeile 156:		Zeile 156:
	}		}
	}		}
	</~~code=java~~>		</syntaxhighlight>

	Das Programm gibt die folgenden Zeilen auf der Konsole aus:		Das Programm gibt die folgenden Zeilen auf der Konsole aus:
Zeile 169:		Zeile 169:
	Die '''Java I/O''' Klassen sind übrigens auch nach dem Decorator-Prinzip aufgebaut. Wir finden dort zum Beispiel den abstrakten Obertyp '''InputStream''' mit den konkreten Untertypen FileInputStream, ByteArrayInputStream, ObjectInputStream, ... Die abstrakte Decorator-Klasse heißt '''FilterInputStream''', die logischerweise auch von InputStream abgeleitet ist. Konkrete "Decorators" sind: PushbackInputStream, BufferedInputStream, DataInputStream, ... Man kann auch leicht eigene konkrete "Decorators" hinzufügen, etwa einen "LowercaseInputStream", der alle Großbuchstaben in Kleinbuchstaben umwandelt...		Die '''Java I/O''' Klassen sind übrigens auch nach dem Decorator-Prinzip aufgebaut. Wir finden dort zum Beispiel den abstrakten Obertyp '''InputStream''' mit den konkreten Untertypen FileInputStream, ByteArrayInputStream, ObjectInputStream, ... Die abstrakte Decorator-Klasse heißt '''FilterInputStream''', die logischerweise auch von InputStream abgeleitet ist. Konkrete "Decorators" sind: PushbackInputStream, BufferedInputStream, DataInputStream, ... Man kann auch leicht eigene konkrete "Decorators" hinzufügen, etwa einen "LowercaseInputStream", der alle Großbuchstaben in Kleinbuchstaben umwandelt...

	~~[[Kategorie:Java]]~~
	[[Kategorie:Design Pattern]]		[[Kategorie:Design Pattern]]
	[[Kategorie:Design Patterns]]		[[Kategorie:Design Patterns]]
	[[Kategorie:Gang of Four Pattern]]		[[Kategorie:Gang of Four Pattern]]

AndreUhres am 13. Oktober 2012 um 06:24 Uhr

2012-10-13T06:24:40Z

← Nächstältere Version		Version vom 13. Oktober 2012, 06:24 Uhr
Zeile 171:		Zeile 171:
	[[Kategorie:Java]]		[[Kategorie:Java]]
	[[Kategorie:Design Pattern]]		[[Kategorie:Design Pattern]]
			[[Kategorie:Design Patterns]]
	[[Kategorie:Gang of Four Pattern]]		[[Kategorie:Gang of Four Pattern]]

AndreUhres am 5. Oktober 2012 um 11:25 Uhr

2012-10-05T11:25:20Z

← Nächstältere Version		Version vom 5. Oktober 2012, 11:25 Uhr
Zeile 167:		Zeile 167:
	Damit haben wir das Verhalten der Katze zur Laufzeit erweitert, ohne vorhandenen Code ändern zu müssen.		Damit haben wir das Verhalten der Katze zur Laufzeit erweitert, ohne vorhandenen Code ändern zu müssen.

	Die '''Java I/O''' Klassen sind übrigens auch nach dem Decorator-Prinzip aufgebaut. Wir finden dort zum Beispiel den abstrakten Obertyp '''InputStream''' mit den konkreten Untertypen FileInputStream~~, StringBufferInputStream~~, ByteArrayInputStream, ObjectInputStream, ... Die abstrakte Decorator-Klasse heißt '''FilterInputStream''', die logischerweise auch von InputStream abgeleitet ist. Konkrete "Decorators" sind: PushbackInputStream, BufferedInputStream, DataInputStream~~, LineNumberInputStream~~, ... Man kann auch leicht eigene konkrete "Decorators" hinzufügen, etwa einen "LowercaseInputStream", der alle Großbuchstaben in Kleinbuchstaben umwandelt...		Die '''Java I/O''' Klassen sind übrigens auch nach dem Decorator-Prinzip aufgebaut. Wir finden dort zum Beispiel den abstrakten Obertyp '''InputStream''' mit den konkreten Untertypen FileInputStream, ByteArrayInputStream, ObjectInputStream, ... Die abstrakte Decorator-Klasse heißt '''FilterInputStream''', die logischerweise auch von InputStream abgeleitet ist. Konkrete "Decorators" sind: PushbackInputStream, BufferedInputStream, DataInputStream, ... Man kann auch leicht eigene konkrete "Decorators" hinzufügen, etwa einen "LowercaseInputStream", der alle Großbuchstaben in Kleinbuchstaben umwandelt...

	[[Kategorie:Java]]		[[Kategorie:Java]]
	[[Kategorie:Design Pattern]]		[[Kategorie:Design Pattern]]
	[[Kategorie:Gang of Four Pattern]]		[[Kategorie:Gang of Four Pattern]]

AndreUhres am 5. Oktober 2012 um 10:09 Uhr

2012-10-05T10:09:51Z

← Nächstältere Version		Version vom 5. Oktober 2012, 10:09 Uhr
Zeile 166:		Zeile 166:
	Am Ende sehen wir, dass die Katze sowohl von PetSchnurrend als auch von PetFauchend umhüllt wurde. Auf diese Weise könnte sie mit einer beliebige Anzahl von Decorators umhüllt werden.		Am Ende sehen wir, dass die Katze sowohl von PetSchnurrend als auch von PetFauchend umhüllt wurde. Auf diese Weise könnte sie mit einer beliebige Anzahl von Decorators umhüllt werden.
	Damit haben wir das Verhalten der Katze zur Laufzeit erweitert, ohne vorhandenen Code ändern zu müssen.		Damit haben wir das Verhalten der Katze zur Laufzeit erweitert, ohne vorhandenen Code ändern zu müssen.

			Die '''Java I/O''' Klassen sind übrigens auch nach dem Decorator-Prinzip aufgebaut. Wir finden dort zum Beispiel den abstrakten Obertyp '''InputStream''' mit den konkreten Untertypen FileInputStream, StringBufferInputStream, ByteArrayInputStream, ObjectInputStream, ... Die abstrakte Decorator-Klasse heißt '''FilterInputStream''', die logischerweise auch von InputStream abgeleitet ist. Konkrete "Decorators" sind: PushbackInputStream, BufferedInputStream, DataInputStream, LineNumberInputStream, ... Man kann auch leicht eigene konkrete "Decorators" hinzufügen, etwa einen "LowercaseInputStream", der alle Großbuchstaben in Kleinbuchstaben umwandelt...

	[[Kategorie:Java]]		[[Kategorie:Java]]
	[[Kategorie:Design Pattern]]		[[Kategorie:Design Pattern]]
	[[Kategorie:Gang of Four Pattern]]		[[Kategorie:Gang of Four Pattern]]

AndreUhres am 4. Oktober 2012 um 18:36 Uhr

2012-10-04T18:36:06Z

← Nächstältere Version		Version vom 4. Oktober 2012, 18:36 Uhr
Zeile 139:		Zeile 139:
	* das Hinzufügen eines neuen Verhaltens in der Methode laut() nach dem Aufruf der Methode laut() der Komponente: '''return pet.laut() + ", schnurren", ''' (in PetSchnurrend) und '''return pet.laut() + ", fauchen"; ''' (in PetFauchend)		* das Hinzufügen eines neuen Verhaltens in der Methode laut() nach dem Aufruf der Methode laut() der Komponente: '''return pet.laut() + ", schnurren", ''' (in PetSchnurrend) und '''return pet.laut() + ", fauchen"; ''' (in PetFauchend)

	Schließlich ~~ist~~ hier die Startklasse der Anwendung "MeineTierschau"		Schließlich zeigen wir hier die Startklasse der Anwendung "MeineTierschau":

	<code=java>package tierschau;		<code=java>package tierschau;

AndreUhres am 4. Oktober 2012 um 18:22 Uhr

2012-10-04T18:22:48Z

← Nächstältere Version		Version vom 4. Oktober 2012, 18:22 Uhr
Zeile 1:		Zeile 1:
	In unserer Designs ist es oft nützlich, das Verhalten eines Objektes zur Laufzeit zu erweitern, ohne vorhandenen Code ändern zu müssen. Wir können die Komposition und die Delegation benutzen, um neue Verhaltensweisen zur Laufzeit ~~hinzufügen~~.		In unserer Designs ist es oft nützlich, das Verhalten eines Objektes zur Laufzeit zu erweitern, ohne vorhandenen Code ändern zu müssen. Wir können die Komposition und die Delegation benutzen, um neue Verhaltensweisen zur Laufzeit hinzuzufügen.

	Das Decorator Design Pattern fügt einem Objekt dynamisch Verantwortung hinzu. Zwecks Erweiterung der Funktionalität eines Objekts, bietet das Decorator Design Pattern eine flexible Alternative zur Vererbung.		Das Decorator Design Pattern fügt einem Objekt dynamisch Verantwortung hinzu. Zwecks Erweiterung der Funktionalität eines Objekts, bietet das Decorator Design Pattern eine flexible Alternative zur Vererbung.

AndreUhres am 4. Oktober 2012 um 13:22 Uhr

2012-10-04T13:22:09Z

← Nächstältere Version		Version vom 4. Oktober 2012, 13:22 Uhr
Zeile 165:		Zeile 165:

	Am Ende sehen wir, dass die Katze sowohl von PetSchnurrend als auch von PetFauchend umhüllt wurde. Auf diese Weise könnte sie mit einer beliebige Anzahl von Decorators umhüllt werden.		Am Ende sehen wir, dass die Katze sowohl von PetSchnurrend als auch von PetFauchend umhüllt wurde. Auf diese Weise könnte sie mit einer beliebige Anzahl von Decorators umhüllt werden.
			Damit haben wir das Verhalten der Katze zur Laufzeit erweitert, ohne vorhandenen Code ändern zu müssen.

	[[Kategorie:Java]]		[[Kategorie:Java]]
	[[Kategorie:Design Pattern]]		[[Kategorie:Design Pattern]]
	[[Kategorie:Gang of Four Pattern]]		[[Kategorie:Gang of Four Pattern]]

AndreUhres am 4. Oktober 2012 um 13:01 Uhr

2012-10-04T13:01:52Z

← Nächstältere Version		Version vom 4. Oktober 2012, 13:01 Uhr
Zeile 137:		Zeile 137:

	* die Anwesenheit der Eigenschaft "pet", die sich auf die Komponente bezieht, die vom Decorator umhüllt wird.		* die Anwesenheit der Eigenschaft "pet", die sich auf die Komponente bezieht, die vom Decorator umhüllt wird.
	* das Hinzufügen eines neuen Verhaltens in der Methode laut() nach dem Aufruf der Methode laut() der Komponente: '''return pet.laut() + "schnurren", ''' (in PetSchnurrend) und '''return pet.laut() + "fauchen"; ''' (in PetFauchend)		* das Hinzufügen eines neuen Verhaltens in der Methode laut() nach dem Aufruf der Methode laut() der Komponente: '''return pet.laut() + ", schnurren", ''' (in PetSchnurrend) und '''return pet.laut() + ", fauchen"; ''' (in PetFauchend)

	Schließlich ist hier die Startklasse der Anwendung "MeineTierschau"		Schließlich ist hier die Startklasse der Anwendung "MeineTierschau"

AndreUhres: Die Seite wurde neu angelegt: „In unserer Designs ist es oft nützlich, das Verhalten eines Objektes zur Laufzeit zu erweitern, ohne vorhandenen Code ändern zu müssen. Wir können die Komp…“

2012-10-04T12:56:11Z

Die Seite wurde neu angelegt: „In unserer Designs ist es oft nützlich, das Verhalten eines Objektes zur Laufzeit zu erweitern, ohne vorhandenen Code ändern zu müssen. Wir können die Komp…“

Neue Seite

In unserer Designs ist es oft nützlich, das Verhalten eines Objektes zur Laufzeit zu erweitern, ohne vorhandenen Code ändern zu müssen. Wir können die Komposition und die Delegation benutzen, um neue Verhaltensweisen zur Laufzeit hinzufügen.

Das Decorator Design Pattern fügt einem Objekt dynamisch Verantwortung hinzu. Zwecks Erweiterung der Funktionalität eines Objekts, bietet das Decorator Design Pattern eine flexible Alternative zur Vererbung.

Das Decorator Design Pattern impliziert die Schaffung einer Reihe von Decorator-Klassen, welche die Komponenten umhüllen.

* Decorator-Klassen sind vom gleichen Typ wie die Komponenten, die sie umhüllen (der Typ wird entweder durch Vererbung oder durch die Implementierung einer Schnittstelle festgelegt).
* Die "Decorators" verändern das Verhalten ihrer Komponenten durch Hinzufügen neuer Features vor, nach oder anstelle von Aufrufen von Methoden der Komponente.
* Wir können eine Komponente mit einer beliebige Anzahl von "Decorators" umhüllen.
* Die "Decorators" sind transparent für den Kunden, sofern der Kunde auf dem abstrakten Obertyp der Komponente aufbaut, und nicht auf konkreten Untertypen.

Nehmen wir zum Beispiel den abstrakten Obertyp "Pet"

<code=java>package tierschau;

public abstract class Pet
{

private int age;
private String species;

public Pet(final int age)
{
this.age = age;
}

public int age()
{
return age;
}

public String species()
{
return species;
}

public void setSpecies(final String species)
{
this.species = species;
}

public abstract String laut();

@Override
public String toString()
{
return "Ich bin ein(e) " + species + "; ich bin " + age + " Jahre alt; ich kann '" + laut() + "' !";
}
}
</code=java>

und den konkrete Untertyp "Katze", der von "Pet" abgeleitet ist:

<code=java>package tierschau;

public class Katze extends Pet
{

public Katze(final int age)
{
super(age);
super.setSpecies(getClass().getSimpleName());
}

@Override
public String laut()
{
return "miauen";
}
}
</code=java>

Wir haben den Namen der konkreten Klasse in der Eigenschaft "species" der abstrakten Klasse "Pet" gespeichert (um zu vermeiden, dass wir uns zu einem späteren Zeitpunkt auf die konkrete Klasse "Katze" beziehen müssen).

Um das Verhalten eines "Pet" zu erweitern, führen wir den abstrakten Decorator "PetBehavior" hinzu. Erinnern wir uns daran, dass der Decorator den gleichen Typ hat wie die Komponente, die er umhüllt. Das ist der Grund, weshalb wir ihn von "Pet" ableiten:

<code=java>package tierschau;

public abstract class PetBehavior extends Pet
{

public PetBehavior(final int age)
{
super(age);
}
}
</code=java>

Wir verwirklichen den abstrakten "Decorator" durch die zwei konkreten Implementierungen "PetSchnurrend" und "PetFauchend":

<code=java>package tierschau;

public class PetSchnurrend extends PetBehavior
{

private final Pet pet;

public PetSchnurrend(final Pet pet)
{
super(pet.age());
this.pet = pet;
setSpecies(pet.species());
}

@Override
public String laut()
{
return pet.laut() + ", schnurren";
}
}
</code=java>

<code=java>package tierschau;

public class PetFauchend extends PetBehavior
{

private final Pet pet;

public PetFauchend(final Pet pet)
{
super(pet.age());
this.pet = pet;
setSpecies(pet.species());
}

@Override
public String laut()
{
return pet.laut() + ", fauchen";
}
}
</code=java>

Beachten wir in diesen konkreten "Decorators":

* die Anwesenheit der Eigenschaft "pet", die sich auf die Komponente bezieht, die vom Decorator umhüllt wird.
* das Hinzufügen eines neuen Verhaltens in der Methode laut() nach dem Aufruf der Methode laut() der Komponente: '''return pet.laut() + "schnurren", ''' (in PetSchnurrend) und '''return pet.laut() + "fauchen"; ''' (in PetFauchend)

Schließlich ist hier die Startklasse der Anwendung "MeineTierschau"

<code=java>package tierschau;

public class MeineTierschau
{

public static void main(final String[] args)
{
Pet animal = new Katze(4);
System.out.println(animal);
animal = new PetSchnurrend(animal); //den Pet mit PetSchnurrend umhüllen
System.out.println(animal);
animal = new PetFauchend(animal); //den Pet mit PetFauchend umhüllen
System.out.println(animal);
}
}
</code=java>

Das Programm gibt die folgenden Zeilen auf der Konsole aus:

*'''Ich bin ein(e) Katze; ich bin 4 Jahre alt; ich kann 'miauen' !'''
*'''Ich bin ein(e) Katze; ich bin 4 Jahre alt; ich kann 'miauen, schnurren' !'''
*'''Ich bin ein(e) Katze; ich bin 4 Jahre alt; ich kann 'miauen, schnurren, fauchen' !'''

Am Ende sehen wir, dass die Katze sowohl von PetSchnurrend als auch von PetFauchend umhüllt wurde. Auf diese Weise könnte sie mit einer beliebige Anzahl von Decorators umhüllt werden.

[[Kategorie:Java]]
[[Kategorie:Design Pattern]]
[[Kategorie:Gang of Four Pattern]]