这是有关设计模式的一系列博客的开始。在本博客中，我们将讨论第一种设计模式，即创建模式。这里将通过一些现实世界的例子来讨论属于创造模式的类型。我将使用 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
以上是创建完美的代码：理解创建模式的详细内容。更多信息请关注PHP中文网其他相关文章！
