Design Pattern

Design Pattern Un Design Pattern è una soluzione assodata (ossia convalidata dal suo utilizzo con successo in più di un progetto) ad un problema ricorrente in un contesto specifico (condizioni al contorno che vincolano la scelta della soluzione). Un pattern Descrive un problema di progettazione comune Descrive la soluzione al problema Discute i risultati ed i vantaggi dell’utilizzo del pattern I pattern Permettono il riutilizzo di tecniche di progettazione e architetture di successo Conducono a sistemi più contenibili Aumentano la produttività Forniscono un linguaggio comune

Design Pattern I Design Pattern si distinguono in base allo scopo in: Pattern di creazione : si applicano al processo di creazione degli oggetti Pattern strutturali : trattano la composizione degli oggetti Pattern comportamentali : modellano le modalità di interazione e le responsabilità tra le classi

Pattern di Creazione Factory : definisce una classe che crea una delle possibili sottoclassi di una classe astratta di base in funzione dei dati forniti Abstract Factory : fornisce un’interfaccia per creare famiglie di oggetti correlati senza specificare le loro classi concreti Singleton : assicura che una classe abbia una sola istanza e ne fornisce un punto globale di accesso Builder : consente di separare la procedura di costruzione di un oggetto complesso dalla sua rappresentazione, in modo che tale procedura possa creare più rappresentazioni differenti del medesimo oggetto

Pattern Strutturali Adapter : converte l’interfaccia di una classe in un’altra interfaccia che si attende un certo cliente; consente l’interazione tra classi che non potrebbero altrimenti cooperare in quanto hanno interfacce incompatibili Bridge : separa un’astrazione dalle sue implementazioni in modo da consentire ad entrambe di cambiare in modo indipendente Composite : compone oggetti in strutture ad albero che rappresentano gerarchie di tipo parte-per-il-tutto. Consente di trattare singoli oggetti e composizioni di oggetti Flyweigth : utilizza la condivisione per gestire in modo efficiente grandi numeri di oggetti Facade : Fornisce un’interaccia comune ad un insieme di interfacce in un sotto insieme. Facade definisce un’interfaccia di alto livello che rende un sottosistema più facile da utilizzare

Pattern Comportamentali Observer : definisce una dipendenza uno-a-molti tra oggetti in modo che quando un oggetto cambia stato, tutti gli oggetti che dipendono da esso ricevono una notifica e si aggiornano Strategy : definisce una famiglia di algoritmi, incapsula ciascuno di essi in una classe opportuna e li rende intercambiabili. Strategy fa si che gli algoritmi possano variare in modo indipendente dal codice che li utilizza. Command : incapsula le richieste di servizi in oggetti, consentendo di controllarne la selezione e la sequenza di attivazione, l’accodamento, l’annullamento Interpreter : dato un linguaggio, definisce una rappresentazione della sua grammatica e di un interprete che usa tale rappresentazione per valutare le frasi in quel linguaggio Iterator : fornisce un punto di accesso sequenziale agli elementi di un oggetto aggregato, senza rendere pubblica la sua organizzazione interna

Pattern Comportamentali Template : definisce lo scheletro di un algoritmo in un’operazione, delegando alcuni passi alle sotto classi; in pratica consente alle sotto classi di ridefinire alcuni passi di un algoritmo senza modificarne la struttura. Mediator : definisce un oggetto che incapsula la logica di interazione di un insieme di oggetti; favorisce il disaccoppiamento evitando agli oggetti di riferirsi esplicitamente l’un l’altro e consentendo così di variare in modo indipendente le loro interazioni.

Singleton Il Singleton è un design pattern creazionale che ha lo scopo di garantire che di una determinata classe venga creata una e una sola istanza, e di fornire un punto di accesso globale a tale istanza. ( http://it.wikipedia.org/wiki/Singleton ) public class MySingleton { private static MySingleton istanza = null ; private MySingleton () {} public static MySingleton getMySingleton () { if (istanza == null ) istanza = new MySingleton (); return istanza; } } singleton.jpg

Factory Fornisce un metodo per istanziare un oggetto senza sapere a priori la sua esatta classe. Questo pattern raggiunge il suo scopo fornendo un'interfaccia per creare un oggetto, ma lascia che le sottoclassi decidano quale oggetto istanziare. ( http://it.wikipedia.org/wiki/Factory_method ) factory.jpg

Factory abstract class Pizza { public abstract double getPrice(); } class PizzaMargherita extends Pizza { private double price = 8.5; public double getPrice() { return price; } } class PizzaMarinara extends Pizza { private double price = 10.5; public double getPrice() { return price; } } class PizzaCapricciosa extends Pizza { private double price = 11.5; public double getPrice() { return price; } } class PizzaFactory { public String [] pizzaType = {"Margherita","Marinara", "Capricciosa"}; public static Pizza createPizza(String pizzaType) { if (pizzaType.equals("Margherita")) return new PizzaMargherita(); else if (pizzaType.equals("Marinara")) return new PizzaMarinara(); else if (pizzaType.equals("Capricciosa")) return new PizzaCapricciosa(); else throw new IllegalArgumentException("La pizza " + pizzaType + " non esiste."); } } public class PizzaLover { public static void main (String avg[]) { System.out.println(PizzaFactory.createPizza("Margherita").getPrice()); } }

Adapter Il fine dell‘Adapter è di fornire una soluzione astratta al problema dell'interoperabilità tra interfacce differenti. Il problema si presenta ogni qual volta nel progetto di un software si debbano utilizzare librerie dotate di interfacce non perfettamente compatibili con quelle richieste da applicazioni già esistenti. Può essere comodo scrivere un Adapter che faccia da tramite tra le diverse interfacce, rendendole così compatibili. ( http://it.wikipedia.org/wiki/Adapter ) Possiamo distinguere 2 tipi di adapter: Object Adapter : quando l’Adapter istanzia la classe da adattare Class Adapter : quando l’Adapter implementa entrambe le interfacce da adattare

Object Adapter class RoundPeg { public void insertIntoHole(String str) { System.out.println("RoundPeg insertIntoHole(): " + str); } } class SquarePeg { public void insert(String str) { System.out.println("SquarePeg insert(): " + str); } } class PegAdapter extends SquarePeg { private RoundPeg roundPeg; public PegAdapter(RoundPeg peg) {this.roundPeg = peg;} public void insert(String str) {roundPeg.insertIntoHole(str);} } public class TestPegs { public static void main(String args[]) { SquarePeg squarePeg = new SquarePeg(); squarePeg.insert("Inserting square peg..."); PegAdapter adapter = new PegAdapter(new RoundPeg()); adapter.insert("Inserting round peg..."); } } adapter2.jpg

Class Adapter interface RoundPegInterface { void insertIntoHole(String str); } interface SquarePegInterface { void insert(String str); } class RoundPeg implements RoundPegInterface { public void insertIntoHole(String str) { System.out.println("RoundPeg insertIntoHole(): " + str); } } class SquarePeg implements SquarePegInterface { public void insert(String str) { System.out.println("SquarePeg insert(): " + str); } } class PegAdapter implements RoundPegInterface, SquarePegInterface { private RoundPeg roundPeg; private SquarePeg squarePeg; public PegAdapter(RoundPeg peg) {this.roundPeg = peg;} public PegAdapter(SquarePeg peg) {this.squarePeg = peg;} public void insert(String str) {roundPeg.insertIntoHole(str);} public void insertIntoHole(String str){squarePeg.insert(str);} } public class TestPegs { public static void main(String args[]) { SquarePeg squarePeg = new SquarePeg(); squarePeg.insert("Inserting square peg..."); RoundPeg roundPeg = new RoundPeg(); roundPeg.insertIntoHole("Inserting round peg..."); SquarePegInterface roundToSquare = new PegAdapter(new RoundPeg()); roundToSquare.insert("Inserting round peg..."); RoundPegInterface squareToRound = new PegAdapter(new SquarePeg()); squareToRound.insertIntoHole("Inserting square peg..."); } }

Flyweight Flyweight è un Design pattern che permette di separare la parte variabile di una classe dalla parte che può essere riutilizzata, in modo tale da poter avere quest'ultima condivisa fra istanze differenti della parte variabile. ( http://it.wikipedia.org/wiki/Flyweight_pattern ) flyweight.jpg

Flyweight abstract class Pizza { public abstract double getPrice(); } class PizzaMargherita extends Pizza { private double price = 8.5; public double getPrice() { return price; } } class PizzaMarinara extends Pizza { private double price = 10.5; public double getPrice() { return price; } } class PizzaCapricciosa extends Pizza { private double price = 11.5; public double getPrice() { return price; } } class PizzaFactory { private static PizzaMargherita pizzaMargherita = new PizzaMargherita(); private static PizzaMarinara pizzaMarinara = new PizzaMarinara(); private static PizzaCapricciosa pizzaCapricciosa = new PizzaCapricciosa(); public Pizza createPizzaMargherita() { return pizzaMargherita; } public Pizza createPizzaMarinara() { return pizzaMarinara; } public Pizza createPizzaCapricciosa() { return pizzaCapricciosa; } } public class PizzaLover { public static void main (String avg[]) { PizzaFactory pizzaFactory = new PizzaFactory(); System.out.println((new PizzaFactory()).createPizzaMarinara().getPrice()); } }

Command Il Command pattern è uno dei design pattern che permette di isolare la porzione di codice che effettua un'azione (eventualmente molto complessa) dal codice che ne richiede l'esecuzione; l'azione è incapsulata nell'oggetto Command. ( http://it.wikipedia.org/wiki/Command_pattern ) command.jpg

Command class Switch { private Command flipUpCommand; private Command flipDownCommand; public Switch(Command flipUpCmd,Command flipDownCmd){ this.flipUpCommand=flipUpCmd; this.flipDownCommand=flipDownCmd; } public void flipUp(){ flipUpCommand.execute(); } public void flipDown(){ flipDownCommand.execute(); } } class Light { public Light(){ } public void turnOn(){ System.out.println("The light is on"); } public void turnOff(){ System.out.println("The light is off"); } } interface Command { void execute(); } class TurnOnLightCommand implements Command{ private Light theLight; public TurnOnLightCommand(Light light){ this.theLight=light; } public void execute(){ theLight.turnOn(); } } class TurnOffLightCommand implements Command{ private Light theLight; public TurnOffLightCommand(Light light){ this.theLight=light; } public void execute(){ theLight.turnOff(); } } public class TestCommand { public static void main(String[] args){ Light l=new Light(); Command switchUp=new TurnOnLightCommand(l); Command switchDown=new TurnOffLightCommand(l); Switch s=new Switch(switchUp,switchDown); s.flipUp(); s.flipDown(); } }

Strategy Il pattern Strategy è utile in quelle situazioni dove è necessario modificare dinamicamente gli algoritmi utilizzati da un'applicazione. ( http://it.wikipedia.org/wiki/Strategy_pattern ) strategy1.png

Strategy abstract class Strategy { } class ConcreteStrategyA extends Strategy { public ConcreteStrategyA() { System.out.println("Called ConcreteStrategyA's execute()"); } } class ConcreteStrategyB extends Strategy { public ConcreteStrategyB() { System.out.println("Called ConcreteStrategyB's execute()"); } } class ConcreteStrategyC extends Strategy { public ConcreteStrategyC() { System.out.println("Called ConcreteStrategyC's execute()"); } } class ContextManager { public static Strategy getStrategy(String context) { Strategy strategy = null; if (context.equals("A")) strategy = new ConcreteStrategyA(); else if (context.equals("B")) strategy = new ConcreteStrategyB(); else if (context.equals("C")) strategy = new ConcreteStrategyB(); return strategy; } } public class StrategyExample { public static void main(String[] args) { Strategy strategy = ContextManager.getStrategy("A"); } }

Template Questo pattern permette di definire la struttura di un algoritmo lasciando alle sottoclassi il compito di implementarne alcuni passi come preferiscono. In questo modo si può ridefinire e personalizzare parte del comportamento nelle varie sottoclassi senza dover riscrivere più volte il codice in comune. ( http://it.wikipedia.org/wiki/Template_method ) template.png

Template abstract class Template { abstract void execute(); void metodoTemplate() { System.out.println("Called metodoTemplate()"); } } class ConcreteTemplateA extends Template { public void execute() { System.out.println("Called ConcreteTemplateA's execute()"); metodoTemplate(); } } class ConcreteTemplateB extends Template { public void execute() { System.out.println("Called ConcreteTemplateB's execute()"); metodoTemplate(); } } class ConcreteTemplateC extends Template { public void execute() { System.out.println("Called ConcreteTemplateC's execute()"); metodoTemplate(); } } class Context { Template template; public Context(Template template) { this.template = template; } public void execute() { this.template.execute(); } } public class TemplateExample { public static void main(String[] args) { Context context; context = new Context(new ConcreteTemplateA()); context.execute(); context = new Context(new ConcreteTemplateB()); context.execute(); context = new Context(new ConcreteTemplateC()); context.execute(); } }

Design Pattern

More Related Content

What's hot (20)

Similar to Design Pattern (20)

Design Pattern