创建完美的代码：理解创建模式

本篇文章向大家介绍《创建完美的代码：理解创建模式》，主要包括，具有一定的参考价值，需要的朋友可以参考一下。

这是有关设计模式的一系列博客的开始。在本博客中，我们将讨论第一种设计模式，即创建模式。这里将通过一些现实世界的例子来讨论属于创造模式的类型。我将使用 java 作为我的选择语言。

什么是设计模式？

设计模式在软件开发中发挥着至关重要的作用，为常见问题提供经过验证的解决方案并推广最佳实践。它们就像预制的蓝图，您可以自定义它们来解决代码中反复出现的设计问题。

探索 java 中的创意设计模式

在面向对象编程中，创建设计模式发挥着重要作用，因为它们使对象实例化与其使用分离成为可能，从而提高了对象创建的灵活性和可扩展性。这篇博文将重点关注五种主要类型的创建设计模式：工厂方法、抽象工厂、构建器、原型和单例。为了展示每个方法的工作原理，我们将使用 java 中的真实示例。

1.工厂方法

工厂方法模式定义了一个用于创建对象的接口，但允许子类更改将创建的对象的类型。此模式支持 java 中的松耦合，无需将特定于应用程序的类绑定到代码中。

现实场景：假设一家物流公司使用卡车和船舶等各种车辆运输货物。车辆类型取决于所需的运输方式。

// product interface
interface transport {
    void deliver();
}

// concrete products
class truck implements transport {
    @override
    public void deliver() {
        system.out.println("deliver by land in a truck.");
    }
}

class ship implements transport {
    @override
    public void deliver() {
        system.out.println("deliver by sea in a ship.");
    }
}

// creator
abstract class logistics {
    public abstract transport createtransport();

    public void plandelivery() {
        transport transport = createtransport();
        transport.deliver();
    }
}

// concrete creators
class roadlogistics extends logistics {
    @override
    public transport createtransport() {
        return new truck();
    }
}

class sealogistics extends logistics {
    @override
    public transport createtransport() {
        return new ship();
    }
}

// let's call the main class
public class main {
    public static void main(string[] args) {
        logistics logistics = new roadlogistics();
        logistics.plandelivery();

        logistics = new sealogistics();
        logistics.plandelivery();
    }
}

2.抽象工厂

抽象工厂模式提供了一个接口，用于创建相关或依赖对象系列，而无需指定它们的具体类。当系统需要独立于其对象的创建方式时，它非常有用。

现实生活场景：想象一家家具店，出售不同类型的家具套装，例如维多利亚式和现代式。每套都包含椅子和沙发等产品。

// abstract products
interface chair {
    void siton();
}

interface sofa {
    void lieon();
}

// concrete products
class victorianchair implements chair {
    @override
    public void siton() {
        system.out.println("sitting on a victorian chair.");
    }
}

class modernchair implements chair {
    @override
    public void siton() {
        system.out.println("sitting on a modern chair.");
    }
}

class victoriansofa implements sofa {
    @override
    public void lieon() {
        system.out.println("lying on a victorian sofa.");
    }
}

class modernsofa implements sofa {
    @override
    public void lieon() {
        system.out.println("lying on a modern sofa.");
    }
}

// abstract factory
interface furniturefactory {
    chair createchair();
    sofa createsofa();
}

// concrete factories
class victorianfurniturefactory implements furniturefactory {
    @override
    public chair createchair() {
        return new victorianchair();
    }

    @override
    public sofa createsofa() {
        return new victoriansofa();
    }
}

class modernfurniturefactory implements furniturefactory {
    @override
    public chair createchair() {
        return new modernchair();
    }

    @override
    public sofa createsofa() {
        return new modernsofa();
    }
}

// client code
public class main {
    private static void createfurniture(furniturefactory factory) {
        chair chair = factory.createchair();
        sofa sofa = factory.createsofa();
        chair.siton();
        sofa.lieon();
    }

    public static void main(string[] args) {
        furniturefactory victorianfactory = new victorianfurniturefactory();
        createfurniture(victorianfactory);

        furniturefactory modernfactory = new modernfurniturefactory();
        createfurniture(modernfactory);
    }
}

3.建设者

builder 模式将复杂对象的构造与其表示分离，允许相同的构造过程创建不同的表示。它对于创建具有许多可选属性的对象特别有用。

现实生活场景：考虑一个在线披萨订购系统，客户可以使用各种配料、尺寸和外皮类型定制披萨。

// product
class pizza {
    private 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; }

    @override
    public string tostring() {
        return "pizza [dough=" + dough + ", sauce=" + sauce + ", topping=" + topping + "]";
    }
}

// builder interface
interface pizzabuilder {
    void builddough();
    void buildsauce();
    void buildtopping();
    pizza getpizza();
}

// concrete builders
class hawaiianpizzabuilder implements pizzabuilder {
    private pizza pizza;

    public hawaiianpizzabuilder() {
        this.pizza = new pizza();
    }

    @override
    public void builddough() { pizza.setdough("cross"); }
    @override
    public void buildsauce() { pizza.setsauce("mild"); }
    @override
    public void buildtopping() { pizza.settopping("ham+pineapple"); }
    @override
    public pizza getpizza() { return this.pizza; }
}

class spicypizzabuilder implements pizzabuilder {
    private pizza pizza;

    public spicypizzabuilder() {
        this.pizza = new pizza();
    }

    @override
    public void builddough() { pizza.setdough("pan baked"); }
    @override
    public void buildsauce() { pizza.setsauce("hot"); }
    @override
    public void buildtopping() { pizza.settopping("pepperoni+salami"); }
    @override
    public pizza getpizza() { return this.pizza; }
}

// director
class waiter {
    private pizzabuilder pizzabuilder;

    public void setpizzabuilder(pizzabuilder pb) { pizzabuilder = pb; }
    public pizza getpizza() { return pizzabuilder.getpizza(); }

    public void constructpizza() {
        pizzabuilder.builddough();
        pizzabuilder.buildsauce();
        pizzabuilder.buildtopping();
    }
}

// client code
public class main {
    public static void main(string[] args) {
        waiter waiter = new waiter();
        pizzabuilder hawaiianpizzabuilder = new hawaiianpizzabuilder();
        pizzabuilder spicypizzabuilder = new spicypizzabuilder();

        waiter.setpizzabuilder(hawaiianpizzabuilder);
        waiter.constructpizza();
        pizza pizza1 = waiter.getpizza();
        system.out.println("pizza built: " + pizza1);

        waiter.setpizzabuilder(spicypizzabuilder);
        waiter.constructpizza();
        pizza pizza2 = waiter.getpizza();
        system.out.println("pizza built: " + pizza2);
    }
}

4.原型

原型模式用于通过复制现有对象（称为原型）来创建新对象。当创建新对象的成本昂贵时，此模式很有用。

现实场景：想象一个图形编辑器，您可以在其中创建、复制和编辑形状。

import java.util.hashmap;
import java.util.map;

// prototype
abstract class shape implements cloneable {
    private string id;
    protected string type;

    abstract void draw();

    public string gettype() { return type; }
    public string getid() { return id; }
    public void setid(string id) { this.id = id; }

    public object clone() {
        object clone = null;
        try {
            clone = super.clone();
        } catch (clonenotsupportedexception e) {
            e.printstacktrace();
        }
        return clone;
    }
}

// concrete prototypes
class rectangle extends shape {
    public rectangle() { type = "rectangle"; }
    @override
    public void draw() { system.out.println("drawing a rectangle."); }
}

class circle extends shape {
    public circle() { type = "circle"; }
    @override
    public void draw() { system.out.println("drawing a circle."); }
}

// prototype registry
class shapecache {
    private static map<string, shape> shapemap = new hashmap<>();

    public static shape getshape(string shapeid) {
        shape cachedshape = shapemap.get(shapeid);
        return (shape) cachedshape.clone();
    }

    public static void loadcache() {
        rectangle rectangle = new rectangle();
        rectangle.setid("1");
        shapemap.put(rectangle.getid(), rectangle);

        circle circle = new circle();
        circle.setid("2");
        shapemap.put(circle.getid(), circle);
    }
}

// client code
public class main {
    public static void main(string[] args) {
        shapecache.loadcache();

        shape clonedshape1 = shapecache.getshape("1");
        system.out.println("shape: " + clonedshape1.gettype());

        shape clonedshape2 = shapecache.getshape("2");
        system.out.println("shape: " + clonedshape2.gettype());
    }
}

5.单例

单例模式确保一个类只有一个实例并提供对其的全局访问点。这种模式通常用于日志记录、缓存和线程池。

现实场景：想象一个打印机后台处理程序，其中只有一个实例应该管理所有打印作业。

class PrinterSpooler {
    private static PrinterSpooler instance;

    private PrinterSpooler() {
        // private constructor to prevent instantiation
    }

    public static PrinterSpooler getInstance() {
        if (instance == null) {
            instance = new PrinterSpooler();
        }
        return instance;
    }

    public void print(String document) {
        System.out.println("Printing document: " + document);
    }
}

// Client code
public class Main {
    public static void main(String[] args) {
        PrinterSpooler spooler1 = PrinterSpooler.getInstance();
        PrinterSpooler spooler2 = PrinterSpooler.getInstance();

        spooler1.print("Document 1");
        spooler2.print("Document 2");

        System.out.println("Are both spoolers the same instance? " + (spooler1 == spooler2));
    }
}

参考

https://refactoring.guru/

https://www.javatpoint.com/design-patterns-in-java

https://www.digitalocean.com/community/tutorials/java-design-patterns-example-tutorial

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于文章的相关知识，也可关注golang学习网公众号。