Cum Să Implementezi Strategy Pattern — Algoritmi Interschimbabili
In this tutorial, you'll learn about Cum Să Implementezi Strategy Pattern. We cover key concepts, practical examples, and best practices.
Vei învăța cum să implementezi Strategy pattern pentru a face algoritmii interschimbabili la runtime, permițând selectarea dinamică a comportamentului.
Problema
Când ai multiple moduri de a executa o operație (filtrare, sortare, plată), utilizarea if-else sau switch-case face codul greu de extins și de testat.
Abordarea Greșită
Logica condițională masivă cu if-else sau switch-case.
// Greșit: switch-case care crește cu fiecare nouă metodă de plată
public void plateste(String metoda, double suma) {
switch (metoda) {
case "card":
// logica card
break;
case "paypal":
// logica paypal
break;
case "bitcoin":
// logica bitcoin
break;
}
}
Abordarea Corectă
Folosește Strategy pattern pentru a encapsula fiecare algoritm.
from abc import ABC, abstractmethod
class PaymentStrategy(ABC):
@abstractmethod
def pay(self, amount: float) -> str:
pass
class CardPayment(PaymentStrategy):
def pay(self, amount: float) -> str:
return f"Platit {amount} RON cu cardul"
class PayPalPayment(PaymentStrategy):
def pay(self, amount: float) -> str:
return f"Platit {amount} RON cu PayPal"
class BitcoinPayment(PaymentStrategy):
def pay(self, amount: float) -> str:
return f"Platit {amount} RON cu Bitcoin"
Rezolvare Pas cu Pas
1. Definește interfața Strategy
class SortStrategy(ABC):
@abstractmethod
def sort(self, data: list) -> list:
pass
2. Implementează strategiile concrete
class QuickSort(SortStrategy):
def sort(self, data: list) -> list:
if len(data) <= 1:
return data
pivot = data[0]
left = [x for x in data[1:] if x <= pivot]
right = [x for x in data[1:] if x > pivot]
return self.sort(left) + [pivot] + self.sort(right)
class MergeSort(SortStrategy):
def sort(self, data: list) -> list:
if len(data) <= 1:
return data
mid = len(data) // 2
left = self.sort(data[:mid])
right = self.sort(data[mid:])
return self._merge(left, right)
def _merge(self, left, right):
result = []
i = j = 0
while i < len(left) and j < len(right):
if left[i] <= right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
return result + left[i:] + right[j:]
3. Implementează Context-ul
class Sorter:
def __init__(self, strategy: SortStrategy):
self._strategy = strategy
def set_strategy(self, strategy: SortStrategy):
self._strategy = strategy
def sort(self, data: list) -> list:
return self._strategy.sort(data)
4. Folosește pattern-ul
data = [5, 3, 8, 1, 9, 2]
sorter = Sorter(QuickSort())
print(sorter.sort(data))
sorter.set_strategy(MergeSort())
print(sorter.sort(data))
Sfaturi de Prevenție
- Nu crea strategii pentru variații simple — uneori un parametru e suficient
- Documentează clar ce face fiecare strategie și când se aplică
- Consideră strategii cu stare internă minimă (preferă stateless)
Greșeli Comune
- Strategii prea granulare — fiecare linie de cod e o strategie separată
- Context care cunoaște detaliile strategiilor (încălcarea scopului)
- Schimbarea frecventă a strategiei la runtime cu costuri de inițializare
- Strategii care partajează stare mutable — efecte laterale neașteptate
- Interfața strategy prea specifică sau prea generică
Întrebări Frecvente
Construit de dezvoltatorii Doda Browser, DodaZIP și Durga Antivirus Pro. Uneltele DodaTech folosesc Strategy pattern pentru algoritmi de compresie și criptare.
Built by the developers of DodaTech
Doda Browser, DodaZIP & Durga Antivirus Pro