Wzorce projektowe Marcin Orchel AGH University of Science and Technology in Poland 1 / 95
Agenda Agenda 2 / 95
1 Diagramy UML 2 Wzorce konstrukcyjne 3 Wzorce strukturalne Agenda 3 / 95
Diagramy UML Diagramy UML 4 / 95
Wprowadzenie do diagramów klas UML diagram klas, ang. class diagram podstawowymi elementami diagramu są klasy, diagram strukturalny zależność, ang. dependency to relacja podkreślająca, że pojedynczy element modelu wymaga innych elementów modelu do specyfikacji lub implementacji, zależny od generalizacja, ang. generalization uogólnienie, dziedziczenie asocjacja, ang. association powiązanie między obiektami danych klas, strzałka obok nazwy oznacza kierunek asocjacji, powiązanie początku z końcem agregacja, ang. aggregation typ asocjacji, całość-część, jedna instancja jest używana do grupowania razem zbioru instancji kompozycja, ang. composition typ asocjacji, silniejsza forma agregacji, obiekt całość jest odpowiedzialny za istnienie i zapis obiektu części, część musi być zawarta maksymalnie w jednym obiekcie całość w danym czasie. Jeśli obiekt całość jest usuwany, to wszystkie instancje części też są usuwane. komentarz, ang. comment inaczej note symbol Diagramy UML 5 / 95
Wprowadzenie do diagramów klas UML cd. Zależność vs asocjacja: asocjacja prawie zawsze oznacza, że jeden obiekt posiada drugi obiekt jako atrybut, natomiast zależność oznacza zazwyczaj, że obiekt akceptuje inny obiekt jako parametr do metody, instancjonuje go, albo używa tego obiektu, ten pierwszy obiekt jest zależny od drugiego. Jeśli mamy do czynienia z asocjacją to ze względu na poźniejsze użycie tego obiektu będziemy mieli do czynienia z zależnością. agregacja vs kompozycja, w kompozycji obiekt część nie może istnieć bez obiektu całość - death relationship Diagramy UML 6 / 95
Schemat przykładowego diagramu klas UML Class1 +Public attribute -Private attribute #Protected attribute Package +Public operation(parameter1) dependency Abstract class 2 +Public attribute -Private attribute #Protected attribute Package +Public abstract operation(parameter1) Aggregation Class2 +Public attribute -Private attribute #Protected attribute Package +Public operation(parameter1) Class3 +Public attribute -Private attribute #Protected attribute Package +Public operation(parameter1) Association Class4 +Public attribute -Private attribute #Protected attribute Package +Public operation(parameter1) Composition Class5 +Public attribute -Private attribute #Protected attribute Package +Public operation(parameter1) Note Diagramy UML 7 / 95
Wzorce konstrukcyjne Wzorce konstrukcyjne 8 / 95
Singleton (ang. singleton) gwarantuje, że klasa będzie miała tylko jeden egzemplarz, i zapewnia globalny dostęp do niego w matematyce niezmienny zbiór z jednym elementem public static <T> Set<T> Collections.singleton(T o) public static <T> List<T> Collections.singletonList(T o) public static <K,V> Map<K,V> Collections.singletonMap(K key, V value) java.lang.runtime#getruntime() java.lang.system#getsecuritymanager() Wzorce konstrukcyjne 9 / 95
Schemat wzorca singleton Singleton static uniqueinstance singletondata static instance() singletonoperation() getsingletondata() return uniqueinstance Wzorce konstrukcyjne 10 / 95
Metoda wytwórcza (ang. factory method) Określa interfejs do tworzenia obiektów, przy czym umożliwia podklasom wyznaczenie klasy danego obiektu. Metoda wytwórcza umożliwia klasom przekazanie procesu tworzenia egzemplarzy podklasom. przykłady z jdk NumberFormat.getInstance() Wzorce konstrukcyjne 11 / 95
Schemat wzorca metody wytwórczej Product Creator +factorymethod() +anoperation() product=factorymethod() ConcreteProduct ConcreteCreator +factorymethod() return new ConcreteProduct() Wzorce konstrukcyjne 12 / 95
Metoda wytwórcza public abstract class MazeGame { public MazeGame() { Room room1 = makeroom(); Room room2 = makeroom(); room1.connect(room2); abstract protected Room makeroom(); public class MagicMazeGame extends MazeGame { @Override protected Room makeroom() { return new MagicRoom(); Wzorce konstrukcyjne 13 / 95
Metoda wytwórcza public class OrdinaryMazeGame extends MazeGame { @Override protected Room makeroom() { return new OrdinaryRoom(); MazeGame ordinarygame = new OrdinaryMazeGame(); MazeGame magicgame = new MagicMazeGame(); Wzorce konstrukcyjne 14 / 95
Fabryka abstrakcyjna (ang. abstract factory) udostępnia interfejs do tworzenia rodzin powiązanych ze sobą lub zależnych od siebie obiektów bez określania ich konkretnych klas Wzorce konstrukcyjne 15 / 95
Schemat fabryki abstrakcyjnej «interface» AbstractFactory «import» Client CreateProductA() CreateProductB() ConcreteFactory2 ConcreteFactory1 «interface» AbstractProductA «import» «import» CreateProductA() CreateProductA() CreateProductB() CreateProductB() «instantiate» ProductA1 ProductA2 «instantiate» «instantiate» «interface» AbstractProductB ProductB1 ProductB2 «instantiate» Wzorce konstrukcyjne 16 / 95
Fabryka abstrakcyjna abstract class GUIFactory { public static GUIFactory getfactory() { int sys = readfromconfigfile("os_type"); if (sys == 0) { return new WinFactory(); else { return new OSXFactory(); public abstract Button createbutton(); class WinFactory extends GUIFactory { public Button createbutton() { return new WinButton(); Wzorce konstrukcyjne 17 / 95
Fabryka abstrakcyjna class OSXFactory extends GUIFactory { public Button createbutton() { return new OSXButton(); abstract class Button { public abstract void paint(); class WinButton extends Button { public void paint() { System.out.println("Przycisk WinButton"); class OSXButton extends Button { public void paint() { System.out.println("Przycisk OSXButton"); Wzorce konstrukcyjne 18 / 95
Fabryka abstrakcyjna public class Application { public static void main(string[] args) { GUIFactory factory = GUIFactory.getFactory(); Button button = factory.createbutton(); button.paint(); // Wyświetlony zostanie tekst: // "Przycisk WinButton" // lub: // "Przycisk OSXButton" Wzorce konstrukcyjne 19 / 95
Metoda wytwórcza vs fabryka abstrakcyjna w metodzie wytwórczej klasa tworząca posiada tylko jedną metodę do tworzenia jednego rodzaju obiektów, natomiast w fabryce abstrakcyjnej mamy wiele metod do tworzenia różnych rodzajów obiektów nazwa metoda wytwórcza wskazuje na metodę, a fabryka na obiekt Wzorce konstrukcyjne 20 / 95
Budowniczy (ang. builder) oddziela tworzenie złożonego obiektu od jego reprezentacji, dzięki temu ten sam proces konstrukcji może prowadzić do powstawania różnych reprezentacji. Wzorce konstrukcyjne 21 / 95
Schemat budowniczego Director builder : Builder construct() Builder buildpart() ConcreteBuilder buildpart() getresult() : Product this.builder.buildpart(); << create >> Product Rysunek 5: Źródło: wikipedia Wzorce konstrukcyjne 22 / 95
Budowniczy /** "Produkt" */ class Pizza { String dough = ""; private String sauce = ""; private String topping = ""; public void setdough(string dough) { this.dough = dough; public void setsauce(string sauce) { this.sauce = sauce; public void settopping(string topping) { this.topping = topping; Wzorce konstrukcyjne 23 / 95
Budowniczy /** "Abstrakcyjny budowniczy" */ abstract class PizzaBuilder { protected Pizza pizza; public Pizza getpizza() { return pizza; public void createnewpizzaproduct() { pizza = new Pizza(); public abstract void builddough(); public abstract void buildsauce(); public abstract void buildtopping(); Wzorce konstrukcyjne 24 / 95
Budowniczy /** "Konkretny budowniczy" */ class HawaiianPizzaBuilder extends PizzaBuilder { public void builddough() { pizza.setdough("cross"); public void buildsauce() { pizza.setsauce("mild"); public void buildtopping() { pizza.settopping("ham+pineapple"); /** "Konkretny budowniczy" */ class SpicyPizzaBuilder extends PizzaBuilder { public void builddough() { pizza.setdough("pan baked"); public void buildsauce() { pizza.setsauce("hot"); public void buildtopping() { pizza.settopping("pepperoni+salami"); Wzorce konstrukcyjne 25 / 95
Budowniczy /** "Nadzorca" */ class Waiter { private PizzaBuilder pizzabuilder; public void setpizzabuilder(pizzabuilder pb) { pizzabuilder = pb; public Pizza getpizza() { return pizzabuilder.getpizza(); public void constructpizza() { pizzabuilder.createnewpizzaproduct(); pizzabuilder.builddough(); pizzabuilder.buildsauce(); pizzabuilder.buildtopping(); Wzorce konstrukcyjne 26 / 95
Budowniczy /** Klient zamawiający pizzę. */ class BuilderExample { public static void main(string[] args) { Waiter waiter = new Waiter(); PizzaBuilder hawaiian_pizzabuilder = new HawaiianPizzaBuilder(); PizzaBuilder spicy_pizzabuilder = new SpicyPizzaBuilder(); waiter.setpizzabuilder( hawaiian_pizzabuilder ); waiter.constructpizza(); Pizza pizza = waiter.getpizza(); Wzorce konstrukcyjne 27 / 95
Budowniczy vs fabryka abstrakcyjna budowniczy rozdziela tworzenie obiektu na części, fabryka abstrakcyjna skupia się na tworzeniu rodziny obiektów we wzorcu budowniczy nadzorca najpierw konstruuje wszystkie części, i później zwraca produkt, fabryka abstrakcyjna nie tworzy części, tylko bezpośrednio produkt. Wzorce konstrukcyjne 28 / 95
Prototyp (ang. prototype) określa na podstawie prototypowego egzemplarza rodzaje tworzonych obiektów i generuje nowe obiekty przez kopiowanie tego prototypu Wzorce konstrukcyjne 29 / 95
Schemat prototypu «interface» I Prototype clone() «import» Client operation() Object p = prototype.clone(); ConcretePrototype1 ConcretePrototype2 clone() clone() return copy of self return copy of self Rysunek 6: Źródło: wikipedia Wzorce konstrukcyjne 30 / 95
Prototyp /** Prototype Class **/ public class Cookie implements Cloneable { public Object clone() { try { Cookie copy = (Cookie)super.clone(); //In an actual implementation of this pattern you might now change references to //the expensive to produce parts from the copies that are held inside the prototype. return copy; catch(clonenotsupportedexception e) { e.printstacktrace(); return null; Wzorce konstrukcyjne 31 / 95
Prototyp /** Concrete Prototypes to clone **/ public class CoconutCookie extends Cookie { /** Client Class**/ public class CookieMachine { private Cookie cookie;//could have been a private Cloneable cookie; public CookieMachine(Cookie cookie) { this.cookie = cookie; public Cookie makecookie() { return (Cookie)cookie.clone(); public static void main(string args[]) { Cookie tempcookie = null; Cookie prot = new CoconutCookie(); CookieMachine cm = new CookieMachine(prot); for (int i=0; i<100; i++) tempcookie = cm.makecookie(); Wzorce konstrukcyjne 32 / 95
Prototyp vs metoda wytwórcza prototyp nie tworzy od nowa obiektów, tylko kopiuje siebie, nie ma produktu Wzorce konstrukcyjne 33 / 95
Wzorce strukturalne Wzorce strukturalne 34 / 95
Adapter (ang. adapter) Przekształca interfejs klasy na inny, oczekiwany przez klienta. Adapter umożliwia współdziałanie klasom, które z uwagi na niezgodne interfejsy standardowo nie mogą współpracować ze sobą. przykłady z jdk: java.util.arrays#aslist(), java.io.inputstreamreader(inputstream) (zwraca Reader), java.io.outputstreamwriter(outputstream) (zwraca Writer) adapter obiektowy: adapter zawiera instancję klasy, którą adaptuje adapter klasowy: wielokrotne dziedziczenie Wzorce strukturalne 35 / 95
Schemat adaptera klasowego Client Target +request() Adaptee +specificrequest() Adapter +request() specificrequest() Wzorce strukturalne 36 / 95
Schemat adaptera obiektowego Client Target +request() Adaptee +specificrequest() Adapter +request() adaptee.specificrequest() Wzorce strukturalne 37 / 95
Adapter class LegacyLine { public void draw(int x1, int y1, int x2, int y2) { System.out.println("line from (" + x1 +, + y1 + ") to (" + x2 +, + y2 + ) ); class LegacyRectangle { public void draw(int x, int y, int w, int h) { System.out.println("rectangle at (" + x +, + y + ") with width " + w + " and height " + h); interface Shape { void draw(int x1, int y1, int x2, int y2); Wzorce strukturalne 38 / 95
Adapter class Line implements Shape { private LegacyLine adaptee = new LegacyLine(); public void draw(int x1, int y1, int x2, int y2) { adaptee.draw(x1, y1, x2, y2); class Rectangle implements Shape { private LegacyRectangle adaptee = new LegacyRectangle(); public void draw(int x1, int y1, int x2, int y2) { adaptee.draw( Math.min(x1, x2), Math.min(y1, y2), Math.abs(x2 - x1), Math.abs(y2 - y1) ); Wzorce strukturalne 39 / 95
Adapter public class AdapterDemo { public static void main(string[] args) { Shape[] shapes = { new Line(), new Rectangle() ; // A begin and end point from a graphical editor int x1 = 10, y1 = 20; int x2 = 30, y2 = 60; for (Shape shape : shapes) shape.draw(x1, y1, x2, y2); Wzorce strukturalne 40 / 95
Most (ang. bridge) oddziela abstrakcję od jej implementacji, dzięki czemu można modyfikować te dwa elementy niezależnie od siebie Wzorce strukturalne 41 / 95
Schemat mostu Client Abstraction +operation() Implementor +operationimp() imp->operationimp(); RefinedAbstraction ConcreteImplementorA +operationimp() ConcreteImplementorB +operationimp() Wzorce strukturalne 42 / 95
Most /** "Implementor" */ interface DrawingAPI { public void drawcircle(double x, double y, double radius); /** "ConcreteImplementor" 1/2 */ class DrawingAPI1 implements DrawingAPI { public void drawcircle(double x, double y, double radius) { System.out.printf("API1.circle at %f:%f radius %f\n", x, y, radius); /** "ConcreteImplementor" 2/2 */ class DrawingAPI2 implements DrawingAPI { public void drawcircle(double x, double y, double radius) { System.out.printf("API2.circle at %f:%f radius %f\n", x, y, radius); Wzorce strukturalne 43 / 95
Most /** "Abstraction" */ abstract class Shape { protected DrawingAPI drawingapi; protected Shape(DrawingAPI drawingapi){ this.drawingapi = drawingapi; public abstract void draw(); // low-level public abstract void resizebypercentage(double pct); // high-level Wzorce strukturalne 44 / 95
Most /** "Refined Abstraction" */ class CircleShape extends Shape { private double x, y, radius; public CircleShape(double x, double y, double radius, DrawingAPI drawingapi) { super(drawingapi); this.x = x; this.y = y; this.radius = radius; // low-level i.e. Implementation specific public void draw() { drawingapi.drawcircle(x, y, radius); // high-level i.e. Abstraction specific public void resizebypercentage(double pct) { radius *= (1.0 + pct/100.0); Wzorce strukturalne 45 / 95
Most /** "Client" */ class BridgePattern { public static void main(string[] args) { Shape[] shapes = new Shape[] { new CircleShape(1, 2, 3, new DrawingAPI1()), new CircleShape(5, 7, 11, new DrawingAPI2()) ; for (Shape shape : shapes) { shape.resizebypercentage(2.5); shape.draw(); Wzorce strukturalne 46 / 95
Kompozyt (ang. composite) Składa obiekty w struktury drzewiaste odzwierciedlające hierarchię typu część-całość. Wzorzec ten umożliwia klientom traktowanie poszczególnych obiektów i ich złożeń w taki sam sposób. przykład z jdk: java.awt.container#add(component) Wzorce strukturalne 47 / 95
Wzorce strukturalne Rysunek 10: Źródło: wikipedia 48 / 95 Schemat kompozytu Component + operation() 0..* child Leaf + operation() Composite + operation() + add() + remove() + getchild() 1 parent
Kompozyt /** "Component" */ interface Graphic { //Prints the graphic. public void print(); /** "Composite" */ import java.util.list; import java.util.arraylist; class CompositeGraphic implements Graphic { //Collection of child graphics. private List<Graphic> childgraphics = new ArrayList<Graphic>(); //Prints the graphic. public void print() { for (Graphic graphic : childgraphics) { graphic.print(); Wzorce strukturalne 49 / 95
Kompozyt //Adds the graphic to the composition. public void add(graphic graphic) { childgraphics.add(graphic); //Removes the graphic from the composition. public void remove(graphic graphic) { childgraphics.remove(graphic); /** "Leaf" */ class Ellipse implements Graphic { //Prints the graphic. public void print() { System.out.println("Ellipse"); Wzorce strukturalne 50 / 95
Kompozyt /** Client */ public class Program { public static void main(string[] args) { //Initialize four ellipses Ellipse ellipse1 = new Ellipse(); Ellipse ellipse2 = new Ellipse(); Ellipse ellipse3 = new Ellipse(); Ellipse ellipse4 = new Ellipse(); //Initialize three composite graphics CompositeGraphic graphic = new CompositeGraphic(); CompositeGraphic graphic1 = new CompositeGraphic(); CompositeGraphic graphic2 = new CompositeGraphic(); //Composes the graphics graphic1.add(ellipse1); graphic1.add(ellipse2); graphic1.add(ellipse3); Wzorce strukturalne 51 / 95
Kompozyt graphic2.add(ellipse4); graphic.add(graphic1); graphic.add(graphic2); //Prints the complete graphic (four times the string "Ellipse"). graphic.print(); Wzorce strukturalne 52 / 95
Dekorator (ang. decorator) Dynamicznie dołącza dodatkowe obowiązki do obiektu. Wzorzec ten udostępnia alternatywny elastyczny sposób tworzenia podklas o wzbogaconych funkcjach. Przykłady z jdk wszystkie podklasy java.io.inputstream, OutputStream, Reader and Writer mają konstruktor, który przyjmuje instancję tego samego typu. java.util.collections, metody checkedxxx(), synchronizedxxx() i unmodifiablexxx(). Wzorce strukturalne 53 / 95
Schemat dekoratora Component +operation() ConcreteComponent +operation() Decorator +operation() component.operation(); ConcreteDecoratorA +addedstate +operation() ConcreteDecoratorB +operation() +addedbehavior() super.operation(); addedbehavior(); Wzorce strukturalne 54 / 95
Dekorator // The Window interface class public interface Window { public void draw(); // Draws the Window public String getdescription(); // Returns a description of the Window // Extension of a simple Window without any scrollbars class SimpleWindow implements Window { public void draw() { // Draw window public String getdescription() { return "simple window"; Wzorce strukturalne 55 / 95
Dekorator // abstract decorator class - note that it implements Window abstract class WindowDecorator implements Window { protected Window windowtobedecorated; // the Window being decorated public WindowDecorator (Window windowtobedecorated) { this.windowtobedecorated = windowtobedecorated; public void draw() { windowtobedecorated.draw(); //Delegation public String getdescription() { return windowtobedecorated.getdescription(); //Delegation Wzorce strukturalne 56 / 95
Dekorator // The first concrete decorator which adds vertical scrollbar functionality class VerticalScrollBarDecorator extends WindowDecorator { public VerticalScrollBarDecorator (Window windowtobedecorated) { super(windowtobedecorated); @Override public void draw() { super.draw(); drawverticalscrollbar(); private void drawverticalscrollbar() { // Draw the vertical scrollbar @Override public String getdescription() { return super.getdescription() + ", including vertical scrollbars"; Wzorce strukturalne 57 / 95
Dekorator // The second concrete decorator which adds horizontal scrollbar functionality class HorizontalScrollBarDecorator extends WindowDecorator { public HorizontalScrollBarDecorator (Window windowtobedecorated) { super(windowtobedecorated); @Override public void draw() { super.draw(); drawhorizontalscrollbar(); private void drawhorizontalscrollbar() { // Draw the horizontal scrollbar @Override public String getdescription() { return super.getdescription() + ", including horizontal scrollbars"; Wzorce strukturalne 58 / 95
Dekorator public class DecoratedWindowTest { public static void main(string[] args) { // Create a decorated Window with horizontal and vertical scrollbars Window decoratedwindow = new HorizontalScrollBarDecorator ( new VerticalScrollBarDecorator (new SimpleWindow())); // Print the Window s description System.out.println(decoratedWindow.getDescription()); Wzorce strukturalne 59 / 95
Dekorator public abstract class DataVectorDecorator implements DataVector { protected DataVector datavectortobedecorated; public DataVectorDecorator(DataVector datavector) { assert datavector!= null; this.datavectortobedecorated = datavector; Wzorce strukturalne 60 / 95
Dekorator @SuppressWarnings("unchecked") @Override public <T> T getdecorator(class<t> clazz) { if (clazz.equals(this.getclass())) { return (T) this; else { return datavectortobedecorated.getdecorator(clazz); Wzorce strukturalne 61 / 95
Dekorator @Override public boolean isdecorator() { return true; @Override public DataVector getdatavectorwithoutdecorator() { return datavectortobedecorated.getdatavectorwithoutdecorator(); Wzorce strukturalne 62 / 95
Dekorator DataVectorCiDecorator decorator = datavector.getdecorator(datavectorcidecorator.class); if (decorator!= null) { decorator.setci(1.0); else { DataVectorCiDecorator datavectorcidecorator = new DataVectorCiDecorator(dataVector, 1.0); newdatamatrix.getdatavectors().set(i, datavectorcidecorator); Wzorce strukturalne 63 / 95
Dekorator vs dziedziczenie W przypadku podklas może powstawać wiele podklas z różnym zestawem atrybutów. Można byłoby zgrupować wszystkie atrybuty w jednej klasie i używać ich wybiórczo, ale związane byłoby to z kosztem pamięciowym nieużywanych atrybutów. Zamiast tworzenia dużej ilości podklas, można dynamicznie dołączać potrzebną funkcjonalność. Wzorce strukturalne 64 / 95
Fasada (ang. facade) Udostępnia jednolity interfejs dla zbioru interfejsów z podsystemu. Fasada określa interfejs wyższego poziomu ułatwiający korzystanie z podsystemów. Wzorce strukturalne 65 / 95
Schemat fasady Rysunek 12: Źródło: wikipedia Wzorce strukturalne 66 / 95
Fasada /* Complex parts */ class CPU { public void freeze() {... public void jump(long position) {... public void execute() {... class Memory { public void load(long position, byte[] data) {... class HardDrive { public byte[] read(long lba, int size) {... Wzorce strukturalne 67 / 95
Fasada /* Facade */ class ComputerFacade { private CPU processor; private Memory ram; private HardDrive hd; public ComputerFacade() { this.processor = new CPU(); this.ram = new Memory(); this.hd = new HardDrive(); public void start() { processor.freeze(); ram.load(boot_address, hd.read(boot_sector, SECTOR_SIZE)); processor.jump(boot_address); processor.execute(); Wzorce strukturalne 68 / 95
Fasada /* Client */ class You { public static void main(string[] args) { ComputerFacade computer = new ComputerFacade(); computer.start(); Wzorce strukturalne 69 / 95
Pyłek (ang. flyweight) wykorzystuje współdzielenie do wydajnej obsługi dużej liczby małych obiektów Wzorce strukturalne 70 / 95
Schemat pyłka FlyweightFactory +GetFlyweight(key) Flyweight +Operation(extrinsicState) if (flyweight(key) exists) { return existing flyweight; else { create new flyweight; add it to pool of flyweights; return the new flyweight; Client ConcreteFlyweight +IntrinsicState +Operation(extrinsicState) UnsharedConcreteFlyweight +allstate +Operation(extrinsicState) Wzorce strukturalne 71 / 95
Pyłek import java.util.list; import java.util.map; import java.util.vector; import java.util.concurrent.concurrenthashmap; // Instances of CoffeeFlavour will be the Flyweights class CoffeeFlavour { private final String name; CoffeeFlavour(String newflavor) { this.name = newflavor; @Override public String tostring() { return name; Wzorce strukturalne 72 / 95
Pyłek // Menu acts as a factory and cache for CoffeeFlavour flyweight objects class Menu { private Map<String, CoffeeFlavour> flavours = new ConcurrentHashMap<String, CoffeeFlavour>(); CoffeeFlavour lookup(string flavorname) { if (!flavours.containskey(flavorname)) flavours.put(flavorname, new CoffeeFlavour(flavorName)); return flavours.get(flavorname); int totalcoffeeflavoursmade() { return flavours.size(); Wzorce strukturalne 73 / 95
Pyłek class Order { private final int tablenumber; private final CoffeeFlavour flavour; Order(int tablenumber, CoffeeFlavour flavor) { this.tablenumber = tablenumber; this.flavour = flavor; void serve() { System.out.println("Serving " + flavour + " to table " + tablenumber); Wzorce strukturalne 74 / 95
Pyłek public class CoffeeShop { private final List<Order> orders = new Vector<Order>(); private final Menu menu = new Menu(); void takeorder(string flavourname, int table) { CoffeeFlavour flavour = menu.lookup(flavourname); Order order = new Order(table, flavour); orders.add(order); void service() { for (Order order : orders) order.serve(); String report() { return "\ntotal CoffeeFlavour objects made: " + menu.totalcoffeeflavoursmade(); Wzorce strukturalne 75 / 95
Pyłek public static void main(string[] args) { CoffeeShop shop = new CoffeeShop(); shop.takeorder("cappuccino", 2); shop.takeorder("frappe", 1); shop.takeorder("espresso", 1); shop.takeorder("frappe", 897); shop.takeorder("cappuccino", 97); shop.takeorder("frappe", 3); shop.takeorder("espresso", 3); shop.takeorder("cappuccino", 3); shop.takeorder("espresso", 96); shop.takeorder("frappe", 552); shop.takeorder("cappuccino", 121); shop.takeorder("espresso", 121); shop.service(); System.out.println(shop.report()); Wzorce strukturalne 76 / 95
Pyłek zamiast tworzyć do każdego zamówienia obiekty CoffeeFlavour, tworzymy tylko określoną liczbę obiektów CofeeFlavour Wzorce strukturalne 77 / 95
Pełnomocnik (ang. proxy) udostępnia zastępnik lub reprezentanta innego obiektu w celu kontrolowania dostępu do niego Wzorce strukturalne 78 / 95
Schemat pełnomocnika Subject request() RealSubject request() realsubject Proxy request() realsubject.request(); Wzorce strukturalne 79 / 95
Pełnomocnik interface Image { public void displayimage(); //on System A class RealImage implements Image { private String filename = null; /** * Constructor * @param filename */ public RealImage(final String filename) { this.filename = filename; loadimagefromdisk(); Wzorce strukturalne 80 / 95
Pełnomocnik /** * Loads the image from the disk */ private void loadimagefromdisk() { System.out.println("Loading " + filename); /** * Displays the image */ public void displayimage() { System.out.println("Displaying " + filename); Wzorce strukturalne 81 / 95
Pełnomocnik //on System B class ProxyImage implements Image { private RealImage image = null; private String filename = null; /** * Constructor * @param filename */ public ProxyImage(final String filename) { this.filename = filename; Wzorce strukturalne 82 / 95
Pełnomocnik /** * Displays the image */ public void displayimage() { if (image == null) { image = new RealImage(filename); image.displayimage(); Wzorce strukturalne 83 / 95
Pełnomocnik class ProxyExample { /** * Test method */ public static void main(string[] args) { final Image IMAGE1 = new ProxyImage("HiRes_10MB_Photo1"); final Image IMAGE2 = new ProxyImage("HiRes_10MB_Photo2"); IMAGE1.displayImage(); // loading necessary IMAGE1.displayImage(); // loading unnecessary IMAGE2.displayImage(); // loading necessary IMAGE2.displayImage(); // loading unnecessary IMAGE1.displayImage(); // loading unnecessary Wzorce strukturalne 84 / 95
Bliźniak (ang. twin) cel: symulacja wielokrotnego dziedziczenia w językach, które go nie posiadają Wzorce strukturalne 85 / 95
Schemat wielokrotnego dziedziczenia Wzorce strukturalne 86 / 95
Schemat bliźniaka Wzorce strukturalne 87 / 95
Bliźniak public class Gameboard extends Canvas { public int width, height; public GameItem firstitem;... Wzorce strukturalne 88 / 95
Bliźniak public abstract class GameItem { Gameboard board; int posx, posy; GameItem next; public abstract void draw(); // M1 public abstract void click (MouseEvent e); public abstract boolean intersects (GameItem other); public abstract void collidewith (GameItem other); public void check() { GameItem x; for (x = board.firstitem; x!= null; x = x.next) if (intersects(x)) collidewith(x); Wzorce strukturalne 89 / 95
Bliźniak public static BallItem newball (int posx, int posy, int radius) {//method of GameBoard BallItem ballitem = new BallItem(posX, posy, radius); BallThread ballthread = new BallThread(); ballitem.twin = ballthread; ballthread.twin = ballitem; return ballitem; Wzorce strukturalne 90 / 95
Bliźniak public class BallItem extends GameItem { BallThread twin; int radius; int dx, dy; boolean suspended; public void draw() { // M1 board.getgraphics().drawoval(posx-radius, posy-radius, 2*radius, 2*radius); public void move() { posx += dx; posy += dy; public void click() { if (suspended) twin.resume(); else twin.suspend(); suspended =! suspended; Wzorce strukturalne 91 / 95
Bliźniak public boolean intersects (GameItem other) { if (other instanceof Wall) return posx - radius <= other.posx && other.posx <= posx + radius posy - radius <= other.posy && other.posy <= posy + radius; else return false; public void collidewith (GameItem other) { Wall wall = (Wall) other; if (wall.isvertical) dx = - dx; else dy = - dy; Wzorce strukturalne 92 / 95
Bliźniak public class BallThread extends Thread { BallItem twin; public void run() { while (true) { twin.draw(); /*erase*/ twin.move(); twin.draw(); Wzorce strukturalne 93 / 95
Inne wzorce konstrukcyjne leniwa inicjalizacja, ang. lazy initialization opóźnienie tworzenia obiektu, obliczania wartości aż do momentu zapotrzebowania na nie multiton jest to singleton, ale rozszerzony o mapę nazwanych obiektów jako pary klucz-wartość, zapewniona jest jedna instancja na dany klucz pula obiektów ang. object pool pula obiektów, które są trzymane w gotowości do użycia inicjalizacja przy pozyskaniu zasobu, ang. resource acquisition is initialization technika łączy przejęcie i zwolnienie zasobu z inicjowaniem i usuwaniem zmiennych, czas używania zasobu jest czasem życia obiektu, zasób jest alokowany podczas tworzenia obiektu przez konstruktor, a zwalniany podczas usuwania obiektu w destruktorze Wzorce strukturalne 94 / 95
Inne wzorce strukturalne front controller istnieje jeden, centralny obiekt (np. serwlet), który zarządza wszystkimi żądaniami przychodzącymi od klienta, przykładowo centralna nawigacja w aplikacjach webowych, zarządzanie sesją, caching, filtracja wejścia, wzorzec MVC marker informacja w czasie działania programu o obiektach w postaci metadanych. Realizacja: klasa implementuje interfejs marker i metody które wykorzystują obiekty tej klasy testują istnienie tego interfejsu, przykład interfejs Serializable, metoda writeobject() sprawdza czy jest implementowany ten interfejs. wzorzec modułu implementacja modułów w języku, który je nie wspiera, np. wykorzystując wzorzec singleton, pakiety w Javie Wzorce strukturalne 95 / 95