{"id":250,"date":"2018-05-03T14:49:41","date_gmt":"2018-05-03T02:49:41","guid":{"rendered":"https:\/\/content.ronella.xyz\/apps\/wordpress\/?p=250"},"modified":"2023-10-16T09:59:07","modified_gmt":"2023-10-15T20:59:07","slug":"structural-design-patterns","status":"publish","type":"post","link":"https:\/\/www.ronella.xyz\/?p=250","title":{"rendered":"Structural Design Patterns"},"content":{"rendered":"

Structural design patterns deal with the composition of classes and objects<\/strong> to create larger, more complex structures while keeping the system flexible and easy to maintain. They are concerned with object relationships and the assembly of objects to form more significant structures. These patterns help to solve common design problems by promoting object reusability and flexibility.<\/p>\n

Adapter Pattern<\/h2>\n

The Adapter Pattern allows incompatible interfaces to work together. It acts as a bridge between two incompatible interfaces, making them work seamlessly.<\/p>\n

Example<\/strong><\/p>\n

interface NewInterface {\n    void doSomethingNew();\n}\n\nclass LegacyLibrary {\n    void doSomethingOld() {\n        \/\/ Legacy implementation\n        System.out.println("Legacy implementation");\n    }\n}\n\nclass LegacyAdapter implements NewInterface {\n    private LegacyLibrary legacyLibrary;\n\n    public LegacyAdapter(LegacyLibrary legacyLibrary) {\n        this.legacyLibrary = legacyLibrary;\n    }\n\n    @Override\n    public void doSomethingNew() {\n        legacyLibrary.doSomethingOld();\n    }\n}\n\npublic class Main {\n    public static void main(String[] args) {\n        NewInterface newObject = new LegacyAdapter(new LegacyLibrary());\n        newObject.doSomethingNew();\n    }\n}<\/code><\/pre>\n
Bridge Pattern<\/h2>\n
The Bridge Pattern separates an object's abstraction from its implementation, allowing them to vary independently.<\/p>\n
Example<\/strong><\/p>\n
interface DrawingAPI {\n    void drawCircle(double x, double y, double radius);\n}\n\nclass DrawingAPI1 implements DrawingAPI {\n    public void drawCircle(double x, double y, double radius) {\n        System.out.println("Implementation 1");\n    }\n}\n\nclass DrawingAPI2 implements DrawingAPI {\n    public void drawCircle(double x, double y, double radius) {\n        System.out.println("Implementation 2");\n    }\n}\n\nabstract class Shape {\n    protected DrawingAPI drawingAPI;\n\n    protected Shape(DrawingAPI drawingAPI) {\n        this.drawingAPI = drawingAPI;\n    }\n\n    public abstract void draw();\n}\n\nclass Circle extends Shape {\n    private double x, y, radius;\n\n    public Circle(double x, double y, double radius, DrawingAPI drawingAPI) {\n        super(drawingAPI);\n        this.x = x;\n        this.y = y;\n        this.radius = radius;\n    }\n\n    public void draw() {\n        drawingAPI.drawCircle(x, y, radius);\n    }\n}\n\npublic class Main {\n    public static void main(String[] args) {\n        DrawingAPI api1 = new DrawingAPI1();\n        Shape circle1 = new Circle(1, 2, 3, api1);\n        circle1.draw();\n    }\n}<\/code><\/pre>\n
Composite Pattern<\/h2>\n
The Composite Pattern allows you to compose objects into tree structures to represent part-whole hierarchies. It treats individual objects and compositions of objects uniformly.<\/p>\n
Example<\/strong><\/p>\n
import java.util.ArrayList;\nimport java.util.List;\n\ninterface Graphic {\n    void draw();\n}\n\nclass Circle implements Graphic {\n    public void draw() {\n        System.out.println("Drawing circle.");\n    }\n}\n\nclass Square implements Graphic {\n    public void draw() {\n        System.out.println("Drawing square.");\n    }\n}\n\nclass CompositeGraphic implements Graphic {\n    private List<Graphic> graphics = new ArrayList<>();\n\n    public void add(Graphic graphic) {\n        graphics.add(graphic);\n    }\n\n    public void draw() {\n        System.out.println("Drawing all graphics.");\n        for (Graphic graphic : graphics) {\n            graphic.draw();\n        }\n    }\n}\n\npublic class Main {\n    public static void main(String[] args) {\n        CompositeGraphic composite = new CompositeGraphic();\n        composite.add(new Circle());\n        composite.add(new Square());\n        composite.draw();\n    }\n}<\/code><\/pre>\n
Decorator Pattern<\/h2>\n
The Decorator Pattern allows you to add behavior to objects dynamically, without altering their class.<\/p>\n
Example<\/strong><\/p>\n
interface Coffee {\n    double cost();\n    String description();\n}\n\nclass SimpleCoffee implements Coffee {\n    public double cost() {\n        return 2.0;\n    }\n\n    public String description() {\n        return "Simple Coffee";\n    }\n}\n\nabstract class CoffeeDecorator implements Coffee {\n    protected Coffee decoratedCoffee;\n\n    public CoffeeDecorator(Coffee decoratedCoffee) {\n        this.decoratedCoffee = decoratedCoffee;\n    }\n\n    public double cost() {\n        return decoratedCoffee.cost();\n    }\n\n    public String description() {\n        return decoratedCoffee.description();\n    }\n}\n\nclass MilkDecorator extends CoffeeDecorator {\n    public MilkDecorator(Coffee decoratedCoffee) {\n        super(decoratedCoffee);\n    }\n\n    public double cost() {\n        return super.cost() + 1.0;\n    }\n\n    public String description() {\n        return super.description() + ", Milk";\n    }\n}\n\npublic class Main {\n    public static void main(String[] args) {\n        Coffee coffee = new MilkDecorator(new SimpleCoffee());\n        System.out.println("Cost: $" + coffee.cost());\n        System.out.println("Description: " + coffee.description());\n    }\n}<\/code><\/pre>\n
Facade Pattern<\/h2>\n
The Facade Pattern provides a simplified interface to a complex system of classes, making it easier to use and understand. It acts as a "facade" or entry point to access a group of related interfaces and classes.<\/p>\n
Example<\/strong><\/p>\n
class CPU {\n    public void start() {\n        System.out.println("CPU start");\n    }\n\n    public void shutdown() {\n        System.out.println("CPU shutdown");\n    }\n}\n\nclass Memory {\n    public void load() {\n        System.out.println("Memory load");\n    }\n\n    public void unload() {\n        System.out.println("Memory unload");\n    }\n}\n\nclass HardDrive {\n    public void read() {\n        System.out.println("Hard drive read");\n    }\n\n    public void write() {\n        System.out.println("Hard drive write");\n    }\n}\n\nclass ComputerFacade {\n    private CPU cpu;\n    private Memory memory;\n    private HardDrive hardDrive;\n\n    public ComputerFacade() {\n        this.cpu = new CPU();\n        this.memory = new Memory();\n        this.hardDrive = new HardDrive();\n    }\n\n    public void start() {\n        cpu.start();\n        memory.load();\n        hardDrive.read();\n    }\n\n    public void shutdown() {\n        cpu.shutdown();\n        memory.unload();\n        hardDrive.write();\n    }\n}\n\npublic class Main {\n    public static void main(String[] args) {\n        ComputerFacade computer = new ComputerFacade();\n        computer.start();\n        computer.shutdown();\n    }\n}<\/code><\/pre>\n
Filter Pattern<\/h2>\n
The Filter Pattern allows you to create a chain of filter objects to process a request. Each filter performs some filtering or processing on the request and passes it to the next filter in the chain.<\/p>\n
Example<\/strong><\/p>\n
import java.util.ArrayList;\nimport java.util.List;\n\nclass Product {\n    private String name;\n    private String category;\n    private double price;\n\n    public Product(String name, String category, double price) {\n        this.name = name;\n        this.category = category;\n        this.price = price;\n    }\n\n    public String getName() {\n        return name;\n    }\n\n    public String getCategory() {\n        return category;\n    }\n\n    public double getPrice() {\n        return price;\n    }\n}\n\ninterface Filter {\n    List<Product> filter(List<Product> products);\n}\n\nclass CategoryFilter implements Filter {\n    private String category;\n\n    public CategoryFilter(String category) {\n        this.category = category;\n    }\n\n    @Override\n    public List<Product> filter(List<Product> products) {\n        List<Product> filteredProducts = new ArrayList<>();\n        for (Product product : products) {\n            if (product.getCategory().equalsIgnoreCase(category)) {\n                filteredProducts.add(product);\n            }\n        }\n        return filteredProducts;\n    }\n}\n\nclass PriceRangeFilter implements Filter {\n    private double minPrice;\n    private double maxPrice;\n\n    public PriceRangeFilter(double minPrice, double maxPrice) {\n        this.minPrice = minPrice;\n        this.maxPrice = maxPrice;\n    }\n\n    @Override\n    public List<Product> filter(List<Product> products) {\n        List<Product> filteredProducts = new ArrayList<>();\n        for (Product product : products) {\n            double price = product.getPrice();\n            if (price >= minPrice && price <= maxPrice) {\n                filteredProducts.add(product);\n            }\n        }\n        return filteredProducts;\n    }\n}\n\nclass ProductFilter {\n    public static List<Product> applyFilter(List<Product> products, Filter filter) {\n        return filter.filter(products);\n    }\n}\n\npublic class Main {\n    public static void main(String[] args) {\n        List<Product> products = new ArrayList<>();\n        products.add(new Product("Laptop", "Electronics", 1000.0));\n        products.add(new Product("Phone", "Electronics", 500.0));\n        products.add(new Product("Shirt", "Clothing", 25.0));\n        products.add(new Product("Dress", "Clothing", 50.0));\n        products.add(new Product("Book", "Books", 15.0));\n\n        System.out.println("Electronics products:");\n        List<Product> electronicsProducts = ProductFilter.applyFilter(products, new CategoryFilter("Electronics"));\n        printProducts(electronicsProducts);\n\n        System.out.println("\\nProducts in the price range $20 - $100:");\n        List<Product> priceRangeProducts = ProductFilter.applyFilter(products, new PriceRangeFilter(20.0, 100.0));\n        printProducts(priceRangeProducts);\n    }\n\n    public static void printProducts(List<Product> products) {\n        for (Product product : products) {\n            System.out.println("Name: " + product.getName() + ", Category: " + product.getCategory() +\n                    ", Price: $" + product.getPrice());\n        }\n    }\n}<\/code><\/pre>\n
Flyweight Pattern<\/h2>\n
The Flyweight Pattern is used to minimize memory usage or computational expenses by sharing as much as possible with related objects. It is particularly useful when you have a large number of similar objects, and you want to reduce memory usage by sharing common data among them.<\/p>\n
Example<\/strong><\/p>\n
import java.util.HashMap;\nimport java.util.Map;\n\nclass Character {\n    private char symbol;\n\n    public Character(char symbol) {\n        this.symbol = symbol;\n    }\n\n    public void display(int fontSize) {\n        System.out.println("Character: " + symbol + ", Font Size: " + fontSize);\n    }\n}\n\nclass CharacterFactory {\n    private Map<java.lang.Character, Character> characters = new HashMap<>();\n\n    public Character getCharacter(char symbol) {\n        if (!characters.containsKey(symbol)) {\n            characters.put(symbol, new Character(symbol));\n        }\n        return characters.get(symbol);\n    }\n}\n\npublic class Main {\n    public static void main(String[] args) {\n        CharacterFactory characterFactory = new CharacterFactory();\n        Character charA = characterFactory.getCharacter('A');\n        Character charB = characterFactory.getCharacter('B');\n        charA.display(12);\n        charB.display(16);\n    }\n}<\/code><\/pre>\n
Proxy Pattern<\/h2>\n
The Proxy Pattern provides a surrogate or placeholder for another object to control access to it. It allows you to add an additional level of control over object access, such as lazy loading, access control, or monitoring.<\/p>\n
Example<\/strong><\/p>\n
interface Image {\n    void display();\n}\n\nclass RealImage implements Image {\n    private String filename;\n\n    public RealImage(String filename) {\n        this.filename = filename;\n        loadFromDisk();\n    }\n\n    private void loadFromDisk() {\n        System.out.println("Loading " + filename);\n    }\n\n    public void display() {\n        System.out.println("Displaying " + filename);\n    }\n}\n\nclass ProxyImage implements Image {\n    private RealImage realImage;\n    private String filename;\n\n    public ProxyImage(String filename) {\n        this.filename = filename;\n    }\n\n    public void display() {\n        if (realImage == null) {\n            realImage = new RealImage(filename);\n        }\n        realImage.display();\n    }\n}\n\npublic class Main {\n    public static void main(String[] args) {\n        Image image = new ProxyImage("large_image.jpg");\n        image.display();\n    }\n}<\/code><\/pre>\n","protected":false},"excerpt":{"rendered":"
Structural design patterns deal with the composition of classes and objects to create larger, more complex structures while keeping the system flexible and easy to maintain. They are concerned with object relationships and the assembly of objects to form more significant structures. These patterns help to solve common design problems by promoting object reusability and […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[29],"tags":[],"_links":{"self":[{"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=\/wp\/v2\/posts\/250"}],"collection":[{"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=250"}],"version-history":[{"count":31,"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=\/wp\/v2\/posts\/250\/revisions"}],"predecessor-version":[{"id":1645,"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=\/wp\/v2\/posts\/250\/revisions\/1645"}],"wp:attachment":[{"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=250"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=250"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=250"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}