Strategy-patroon: uitwisselbare algoritmen
Kapsel sorteer- of betaalalgoritmen in achter een Strategy-interface om tijdens runtime te kunnen wisselen.
Strategy-patroon: uitwisselbare algoritmen is een gratis Java Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Java Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Java Academy bevat in totaal 4 lessen.
De intentie van Strategy
Strategy definieert een familie van algoritmen, kapselt elk algoritme in en maakt ze onderling verwisselbaar. Hierdoor kan het algoritme onafhankelijk variëren van de context die het gebruikt.
Het probleem zonder Strategy
Zonder Strategy zit de keuze van het algoritme verborgen in if-else-ketens. Een nieuw algoritme toevoegen betekent dat je de contextklasse moet aanpassen — een schending van het open-geslotenprincipe.
public double sort(List<Integer> data, String method) {
if (method.equals("bubble")) { /* bubble sort */ }
else if (method.equals("merge")) { /* merge sort */ }
// adding quicksort requires editing this class
}De Strategy-interface
Definieer een @FunctionalInterface of gewone interface die het contract van het algoritme beschrijft. Elke implementatie kapselt een ander algoritme in.
public interface SortStrategy {
void sort(List<Integer> data);
}
public class BubbleSortStrategy implements SortStrategy {
public void sort(List<Integer> data) { /* bubble sort logic */ }
}
public class QuickSortStrategy implements SortStrategy {
public void sort(List<Integer> data) { Collections.sort(data); }
}De contextklasse
De context bevat een verwijzing naar een strategie en delegeert de uitvoering van het algoritme eraan. De strategie kan tijdens runtime worden verwisseld.
public class Sorter {
private SortStrategy strategy;
public Sorter(SortStrategy strategy) { this.strategy = strategy; }
public void setStrategy(SortStrategy s) { this.strategy = s; }
public void sort(List<Integer> data) { strategy.sort(data); }
}Strategieën tijdens runtime wisselen
Wijzig de strategie tijdens het uitvoeren zonder de context aan te passen. Hierdoor kun je het gedrag van buiten de klasse configureren.
Sorter sorter = new Sorter(new BubbleSortStrategy());
sorter.sort(data); // uses bubble sort
sorter.setStrategy(new QuickSortStrategy());
sorter.sort(data); // now uses quick sortLambdastrategieën
Als de strategie-interface een @FunctionalInterface is, kun je rechtstreeks lambdas gebruiken — voor eenvoudige strategieën zijn expliciete klassen dan niet nodig.
Sorter sorter = new Sorter(data -> Collections.sort(data)); // lambda strategy
// or method reference:
Sorter sorter2 = new Sorter(Collections::sort);Strategy voor betalingsverwerking
Een klassiek voorbeeld uit de praktijk: een betalingscontext accepteert verschillende betalingsstrategieën (creditcard, PayPal, cryptovaluta) zonder de details van elke strategie te kennen.
public interface PaymentStrategy {
void pay(double amount);
}
new PaymentProcessor(new CreditCardStrategy("4111...")).pay(99.99);
new PaymentProcessor(new PayPalStrategy("user@email.com")).pay(99.99);Strategy voor compressie
Een bestandsverwerker kan een CompressionStrategy gebruiken. Je kunt GZIP, ZIP of LZ4 aansluiten zonder de bestandsverwerkingspijplijn te wijzigen.
public interface CompressionStrategy {
byte[] compress(byte[] data) throws IOException;
}
public class GzipStrategy implements CompressionStrategy {
public byte[] compress(byte[] data) throws IOException { /* gzip */ return new byte[0]; }
}Strategy combineren met Factory
Gebruik een fabriek om de strategie op basis van de configuratie te selecteren, zodat de selectielogica gescheiden blijft van zowel de context als de strategieën zelf.
SortStrategy strategy = switch (config.getSortMethod()) {
case "bubble" -> new BubbleSortStrategy();
case "merge" -> new MergeSortStrategy();
default -> Collections::sort;
};
new Sorter(strategy).sort(data);Strategy versus Template Method
Template Method gebruikt overerving: het skelet staat in de basisklasse en subklassen overschrijven stappen. Strategy gebruikt compositie: het algoritme bevindt zich volledig buiten de context. Geef de voorkeur aan Strategy voor meer flexibiliteit.
Strategie in de JDK
Comparator is het standaardvoorbeeld van het strategiepatroon in de JDK. Geef verschillende comparatoren door aan Collections.sort om het sorteeralgoritme te wijzigen zonder de code van de verzameling aan te passen.
List<String> names = List.of("Bob", "Alice", "Charlie");
names.stream().sorted(Comparator.comparingInt(String::length)).forEach(System.out::println);Strategieën testen
Strategieën zijn eenvoudig afzonderlijk te testen — roep strategy.sort(data) gewoon aan in een eenheidstest. Injecteer mockstrategieën in de context om de coördinatielogica van de context te testen.
Korte controle
Wat is het belangrijkste structurele verschil tussen het strategiepatroon en de sjabloonmethode?
Samenvatting
Het strategiepatroon kapselt verwisselbare algoritmen in achter een gemeenschappelijke interface. Gebruik lambda's voor eenvoudige strategieën en klassen voor complexe strategieën. Combineer ze met fabrieken voor selectie op basis van configuratie.
Leer Java met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 104
- Lessen
- 374
Veelgestelde vragen
Is de les “Strategy-patroon: uitwisselbare algoritmen” gratis?
Ja — de volledige tekst van “Strategy-patroon: uitwisselbare algoritmen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Java Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Java Academy bevat in totaal 4 lessen.
Wat leer ik in “Strategy-patroon: uitwisselbare algoritmen”?
Kapsel sorteer- of betaalalgoritmen in achter een Strategy-interface om tijdens runtime te kunnen wisselen. Je oefent met Java Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Java Academy te beginnen?
Ervaring vooraf is niet nodig. Java Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.
Hoe lang duurt de les “Strategy-patroon: uitwisselbare algoritmen”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Java Academy?
Ja. Elke les over Java Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Observer-patroon: gebeurtenismeldingen
- Strategy-patroon: uitwisselbare algoritmen
- Command-patroon: acties inkapselen
- Template Method: algoritmeskeletten definiëren