这是有关设计模式的一系列博客的开始。在本博客中，我们将讨论第一种设计模式，即创建模式。这里将通过一些现实世界的例子来讨论属于创造模式的类型。我将使用 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
