Strategie (Entwurfsmuster)
Strategie (englisch strategy) ist im Bereich der Softwareentwicklung ein Entwurfsmuster und gehört zur Kategorie der Verhaltensmuster (englisch behavioral design patterns). Die Strategie definiert eine Familie austauschbarer Algorithmen.[1] Es ist eines der sogenannten GoF-Muster (Gang of Four, siehe Viererbande).
Verwendung
Strategie-Objekte werden ähnlich wie Klassenbibliotheken verwendet. Im Gegensatz dazu handelt es sich jedoch nicht um externe Programmteile, sondern um integrale Bestandteile des eigentlichen Programms, die deshalb als eigene Objekte definiert wurden, damit sie durch andere Algorithmen ausgetauscht werden können.
Meistens wird eine Strategie durch Klassen umgesetzt, die eine bestimmte Schnittstelle implementieren. In Sprachen wie Smalltalk, in denen auch der Programmcode selbst in Objekten abgelegt werden kann, kann eine Strategie aber auch durch solche Code-Objekte realisiert werden.
Die Verwendung von Strategien bietet sich an, wenn
- viele verwandte Klassen sich nur in ihrem Verhalten unterscheiden.
- unterschiedliche (austauschbare) Varianten eines Algorithmus benötigt werden.
- Daten innerhalb eines Algorithmus vor Klienten verborgen werden sollen.
- verschiedene Verhaltensweisen innerhalb einer Klasse fest integriert sind (meist über Mehrfachverzweigungen), aber
- die verwendeten Algorithmen wiederverwendet werden sollen bzw.
- die Klasse flexibler gestaltet werden soll.
UML-Diagramm
Erklärung der Akteure
Die Klasse Strategie
definiert nur eine Schnittstelle (interface) für alle unterstützten Algorithmen. Die Implementierung der eigentlichen Algorithmen finden sich erst in den Ableitungen wieder (konkrete Strategie).
Der Kontext
hält eine Variable der Schnittstelle Strategie, die mit einer Referenz auf das gewünschte Strategieobjekt belegt ist. Auf diese Weise wird der konkrete Algorithmus über die Schnittstelle eingebunden und kann bei Bedarf selbst zur Laufzeit noch dynamisch gegen eine andere Implementierung ausgetauscht werden.
Vorteile
- Es wird eine Familie von Algorithmen definiert.
- Es wird die Auswahl aus verschiedenen Implementierungen ermöglicht und dadurch erhöhen sich die Flexibilität und die Wiederverwendbarkeit.
- Es können Mehrfachverzweigungen vermieden werden und dies erhöht die Übersicht des Codes.
- Strategien bieten eine Alternative zur Unterklassenbildung der Kontexte.
Nachteile
- Klienten müssen die unterschiedlichen Strategien kennen, um zwischen ihnen auswählen und den Kontext initialisieren zu können.
- Gegenüber der Implementierung der Algorithmen im Kontext entsteht hier ein zusätzlicher Kommunikationsaufwand zwischen Strategie und Kontext.
Beispiel
Als Beispiel kann ein Steuerberechnungsprogramm dienen, das die Berechnung von Steuersätzen möglichst in Strategie-Objekte auslagern sollte, um einfach länderabhängig konfigurierbar zu sein.
Ein anderes Beispiel wäre die Speicherung eines Dokuments oder einer Grafik in verschiedenen Dateiformaten.
Auch ein Packer, der verschiedene Kompressionsalgorithmen unterstützt, kann mit Hilfe von Strategie implementiert sein. Bei Java wird das Entwurfsmuster zum Beispiel zur Delegierung des Layouts von AWT-Komponenten an entsprechende LayoutManager (BorderLayout, FlowLayout etc.) verwendet.
Weitere Beispiele (außerhalb der OOP-Welt):
- Datenbanksysteme
- Dateisysteme
- Gerätetreiber
- Server-Programme
Programmbeispiele
Beispiel in C++
// // g++ -std=c++11 strategy.cpp -o strategy // #include <iostream> #include <memory> class Strategy { public: virtual void operator()() = 0; virtual ~Strategy() = default; }; class Context { std::unique_ptr<Strategy> strat_; public: Context() : strat_(nullptr) {} void setStrategy(std::unique_ptr<Strategy> strat) { strat_ = std::move(strat); } void strategy() { if (strat_) (*strat_)(); } }; class Strategy1 : public Strategy { public: void operator()() override { std::cout << "Foo\n"; } }; class Strategy2 : public Strategy { public: void operator()() override { std::cout << "Bar\n"; } }; class Strategy3 : public Strategy { public: void operator()() override { std::cout << "FooBar\n"; } }; int main() { Context c; c.setStrategy( std::unique_ptr<Strategy>(new Strategy1) ); c.strategy(); c.setStrategy( std::unique_ptr<Strategy>(new Strategy2) ); c.strategy(); c.setStrategy( std::unique_ptr<Strategy>(new Strategy3) ); c.strategy(); }
Java
class Client { public static void main(final String[] ARGS) { final Context c = new Context(); c.setStrategy(new StrategyA()); c.doSomething(); // "Strategie A" c.setStrategy(new StrategyB()); c.doSomething(); // "Strategie B" } } class Context { private Strategy strategy = null; public void setStrategy(final Strategy STRATEGY) { strategy = STRATEGY; } public void doSomething() { if (strategy != null) { strategy.execute(); } } } interface Strategy { void execute(); } class StrategyA implements Strategy { public void execute() { System.out.println("Strategie A"); } } class StrategyB implements Strategy { public void execute() { System.out.println("Strategie B"); } }
Ruby
class Context private attr_writer :strategy public def initialize(strategy) @strategy = strategy end def execute unless @strategy.respond_to?('execute') raise NotImplementedError,'Strategie-Objekt antwortet nicht auf die execute-Methode' end @strategy.execute end end class StrategyA def execute puts 'Der normale Weg' end end class StrategyB def execute puts 'Ein anderer Weg' end end class StrategyC def execute puts 'Noch ein anderer Weg' end end a = Context.new(StrategyA.new) a.execute # Der normale Weg b = Context.new(StrategyB.new) b.execute # Ein anderer Weg c = Context.new(StrategyC.new) c.execute # Noch ein anderer Weg
Python
class Context: def __init__(self, strategy): self.strategy = strategy def execute(self, a, b): return self.strategy(a, b) class AddStrategy: def __call__(self, a, b): return a + b class SubStrategy: def __call__(self, a, b): return a - b context = Context(AddStrategy()) print('4 + 3 =', context.execute(4, 3)) # 4 + 3 = 7 context.strategy = SubStrategy() print('4 - 3 =', context.execute(4, 3)) # 4 - 3 = 1
Verwandte Entwurfsmuster
- Abstrakte Fabrik
- Adapter
- Dekorierer
- Schablonenmethode
- Zustand
Weblinks
- Video zur Implementierung des Strategie-Entwurfsmusters für .NET Entwickler. Ehemals im Original (nicht mehr online verfügbar); abgerufen am 11. Juli 2024.@1@2Vorlage:Toter Link/devcouch.de (Seite nicht mehr abrufbar. Suche in Webarchiven)
- Strategy Pattern Tutorial with Java Examples
- Behavioral Patterns – Strategy
Einzelnachweise
- ↑ Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides: Entwurfsmuster. 5. Auflage. Addison-Wesley, München / Boston 1996, ISBN 3-8273-1862-9, S. 373.
Erzeugungsmuster | Abstrakte Fabrik | Erbauer | Fabrikmethode | Prototyp | Singleton | Multiton | Objektpool |
Strukturmuster | Adapter | Brücke | Decorator | Fassade | Fliegengewicht | Kompositum | Stellvertreter |
Verhaltensmuster | Beobachter | Besucher | Interpreter | Iterator | Kommando | Memento | Schablonenmethode | Strategie | Vermittler | Zustand | Zuständigkeitskette | Interceptor | Nullobjekt | Protokollstapel |
Muster für objektrelationale Abbildung | Datentransferobjekt | Table Data Gateway | Row Data Gateway | Active Record | Unit of Work | Identity Map | Lazy Loading | Identity Field | Dependent Mapping | Embedded Value | Serialized LOB | Inheritance Mapper | Metadata Mapping | Query Object | Command-Query-Responsibility-Segregation |
Nachrichtenübermittlungsmuster | Message | Command Message | Document Message | Event Message | Request-Reply | Return Address | Correlation Identifier | Message Sequence | Message Expiration | Format Indicator | Message Channel | Point-to-Point Channel | Publisher-Subscriber Channel | Datatype Channel | Invalid Message Channel | Dead Letter Channel | Guaranteed Delivery | Channel Adapter | Messaging Bridge | Message Bus | Pipes-and-Filters | Message Router | Content-based Router | Message Filter | Dynamic Router | Recipient List | Splitter | Aggregator | Resequencer | Composed Message Processor | Scatter-Gather | Routing Slip | Process Manager | Message Broker | Message Translator | Envelope Wrapper | Content Enricher | Content Filter | Claim Check | Normalizer | Canonical Data Model | Message Endpoint | Messaging Gateway | Messaging Mapper | Transactional Client | Polling Consumer | Event-driven Consumer | Competing Consumers | Message Dispatcher | Selective Consumer | Durable Subscriber | Idempotent Receiver | Service Activator | Control Bus | Detour | Wire Tap | Message History | Message Store | Smart Proxy | Test Message | Channel Purger |
Andere | Application Controller | Business Delegate | Data Access Object | Dependency Injection | Extension Interface | Fluent Interface | Inversion of Control (IoC) | Lock | Model View Controller (MVC) | Model View Presenter (MVP) | Model View Update (MVU) | Model View ViewModel (MVVM) | Page Controller | Registry | Remote Facade | Repository | Service Locator | Session State | Table Module | Template View | Threadpool | Transaction Script | Transform View | Two-Step View | Value Object |