Wzorce projektowe Marcin Orchel AGH University of Science and Technology in Poland 1 / 84
1 Diagramy UML 2 Wzorce konstrukcyjne 3 Wzorce strukturalne Agenda 2 / 84
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, 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 3 / 84
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 Diagramy UML 4 / 84
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 5 / 84
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 6 / 84
Schemat wzorca singleton Singleton static uniqueinstance singletondata static instance() singletonoperation() getsingletondata() return uniqueinstance Wzorce konstrukcyjne 7 / 84
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 8 / 84
Schemat wzorca metody wytwórczej Creator «use» Product # factorymethod() : Product + anoperation() ConcreteCreator «create» ConcreteProduct + factorymethod() : Product Rysunek 3 : Źródło: wikipedia Wzorce konstrukcyjne 9 / 84
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 10 / 84
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 11 / 84
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 12 / 84
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 13 / 84
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 14 / 84
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 15 / 84
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 16 / 84
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 17 / 84
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 18 / 84
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 19 / 84
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 20 / 84
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 21 / 84
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 22 / 84
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 23 / 84
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 24 / 84
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 25 / 84
Prototyp (ang. prototype) określa na podstawie prototypowego egzemplarza rodzaje tworzonych obiektów i generuje nowe obiekty przez kopiowanie tego prototypu Wzorce konstrukcyjne 26 / 84
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 27 / 84
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 28 / 84
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 29 / 84
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 30 / 84
Schemat adaptera Rysunek 7 : Źródło: wikipedia Wzorce strukturalne 31 / 84
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 32 / 84
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 33 / 84
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 34 / 84
Most (ang. bridge) oddziela abstrakcję od jej implementacji, dzięki czemu można modyfikować te dwa elementy niezależnie od siebie Wzorce strukturalne 35 / 84
Schemat mostu Abstraction - impl : Implementor + function() Implementor + implementation() this.impl.implementation(); RefinedAbstraction + refinedfunction() ConcreteImplementor + implementation() Rysunek 8 : Źródło: wikipedia Wzorce strukturalne 36 / 84
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 37 / 84
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 38 / 84
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 39 / 84
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 40 / 84
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 41 / 84
Wzorce strukturalne Rysunek 9 : Źródło: wikipedia 42 / 84 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 43 / 84
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 44 / 84
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 45 / 84
Kompozyt graphic2.add(ellipse4); graphic.add(graphic1); graphic.add(graphic2); //Prints the complete graphic (four times the string "Ellipse"). graphic.print(); Wzorce strukturalne 46 / 84
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 47 / 84
Schemat dekoratora Component + operation() ConcreteComponent + operation() Decorator - component + operation() ConcreteDecorator + operation() Wzorce strukturalne 48 / 84
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 49 / 84
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 50 / 84
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 51 / 84
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 52 / 84
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 53 / 84
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 54 / 84
Schemat fasady Rysunek 11 : Źródło: wikipedia Wzorce strukturalne 55 / 84
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 56 / 84
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 57 / 84
Fasada /* Client */ class You { public static void main(string[] args) { ComputerFacade computer = new ComputerFacade(); computer.start(); Wzorce strukturalne 58 / 84
Pyłek (ang. flyweight) wykorzystuje współdzielenie do wydajnej obsługi dużej liczby małych obiektów Wzorce strukturalne 59 / 84
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 60 / 84
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 61 / 84
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 62 / 84
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 63 / 84
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 64 / 84
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 65 / 84
Pyłek zamiast tworzyć do każdego zamówienia obiekty CoffeeFlavour, tworzymy tylko określoną liczbę obiektów CofeeFlavour Wzorce strukturalne 66 / 84
Pełnomocnik (ang. proxy) udostępnia zastępnik lub reprezentanta innego obiektu w celu kontrolowania dostępu do niego Wzorce strukturalne 67 / 84
Schemat pełnomocnika Subject request() RealSubject request() realsubject Proxy request() realsubject.request(); Wzorce strukturalne 68 / 84
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 69 / 84
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 70 / 84
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 71 / 84
Pełnomocnik /** * Displays the image */ public void displayimage() { if (image == null) { image = new RealImage(filename); image.displayimage(); Wzorce strukturalne 72 / 84
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 73 / 84
Bliźniak (ang. twin) cel: symulacja wielokrotnego dziedziczenia w językach, które go nie posiadają Wzorce strukturalne 74 / 84
Schemat wielokrotnego dziedziczenia Wzorce strukturalne 75 / 84
Schemat bliźniaka Wzorce strukturalne 76 / 84
Bliźniak public class Gameboard extends Canvas { public int width, height; public GameItem firstitem;... Wzorce strukturalne 77 / 84
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 78 / 84
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 79 / 84
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 80 / 84
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 81 / 84
Bliźniak public class BallThread extends Thread { BallItem twin; public void run() { while (true) { twin.draw(); /*erase*/ twin.move(); twin.draw(); Wzorce strukturalne 82 / 84
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 83 / 84
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 84 / 84