工厂模式是一种创建型设计模式，它提供了一种创建对象的最佳实践，旨在将对象的创建过程与使用过程分离，以提高代码的灵活性、可维护性和可扩展性。工厂模式主要有以下三种类型：
简单工厂模式（Simple Factory）：
简单工厂不是一个GoF（设计模式的四人帮， Gang of Four）正式提出的设计模式，但它常被认为是工厂方法模式的简化版本。
提供一个统一的接口用于创建相关或依赖对象，而不需要暴露创建逻辑给客户端，也不需要客户端知道具体产品的类。
适用于产品种类不多，且不会频繁新增产品种类的情况。
工厂方法模式 （Factory Method）：
属于GoF提出的23种设计模式之一，属于创建型模式。
定义了一个用于创建对象的接口，但让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
提高了系统的扩展性，当需要添加新产品时，只需要添加相应的产品类和对应的工厂子类即可，无需修改现有代码。
抽象工厂模式
同样是GoF设计模式之一，也是创建型模式。
提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
适用于系统需要独立于产品的创建、组合和表示的情况下，强调的是“系列”对象的创建，而不是单一产品的创建。
这三种模式从简单到复杂，分别解决了不同复杂度的创建需求，提高了软件的结构灵活性和可维护性。在选择使用哪种工厂模式时，应根据项目的具体需求和未来可能的变化来决定。
优点 :
缺点:
简单工厂模式示例
// 产品接口
interface Product {
void show();
}
// 具体产品A
class ConcreteProductA implements Product {
@Override
public void show() {
System.out.println("ConcreteProductA");
}
}
// 具体产品B
class ConcreteProductB implements Product {
@Override
public void show() {
System.out.println("ConcreteProductB");
}
}
// 简单工厂
class SimpleFactory {
public static Product createProduct(String type) {
if ("A".equals(type)) {
return new ConcreteProductA();
} else if ("B".equals(type)) {
return new ConcreteProductB();
}
throw new IllegalArgumentException("Invalid type");
}
}
public class SimpleFactoryDemo {
public static void main(String[] args) {
Product productA = SimpleFactory.createProduct("A");
productA.show();
Product productB = SimpleFactory.createProduct("B");
productB.show();
}
}
优点:
缺点:
工厂方法模式示例
// 抽象工厂
interface Factory {
Product createProduct();
}
// 具体工厂A
class ConcreteFactoryA implements Factory {
@Override
public Product createProduct() {
return new ConcreteProductA();
}
}
// 具体工厂B
class ConcreteFactoryB implements Factory {
@Override
public Product createProduct() {
return new ConcreteProductB();
}
}
public class FactoryMethodDemo {
public static void main(String[] args) {
Factory factoryA = new ConcreteFactoryA();
Product productA = factoryA.createProduct();
productA.show();
Factory factoryB = new ConcreteFactoryB();
Product productB = factoryB.createProduct();
productB.show();
}
}
优点:
缺点:
抽象工厂模式示例// 抽象产品：操作系统
interface OperatingSystem {
void showOS();
}
// 具体产品：Windows操作系统
class Windows implements OperatingSystem {
@Override
public void showOS() {
System.out.println("Windows OS");
}
}
// 具体产品：Mac操作系统
class Mac implements OperatingSystem {
@Override
public void showOS() {
System.out.println("Mac OS");
}
}
// 抽象产品：浏览器
interface Browser {
void showBrowser();
}
// 具体产品：Chrome浏览器
class Chrome implements Browser {
@Override
public void showBrowser() {
System.out.println("Chrome");
}
}
// 具体产品：Safari浏览器
class Safari implements Browser {
@Override
public void showBrowser() {
System.out.println("Safari");
}
}
// 抽象工厂
interface AbstractFactory {
OperatingSystem createOperatingSystem();
Browser createBrowser();
}
// 具体工厂：Windows产品族
class WindowsFactory implements AbstractFactory {
@Override
public OperatingSystem createOperatingSystem() {
return new Windows();
}
@Override
public Browser createBrowser() {
return new Chrome();
}
}
// 具体工厂：Mac产品族
class MacFactory implements AbstractFactory {
@Override
public OperatingSystem createOperatingSystem() {
return new Mac();
}
@Override
public Browser createBrowser() {
return new Safari();
}
}
public class AbstractFactoryDemo {
public static void main(String[] args) {
AbstractFactory windowsFactory = new WindowsFactory();
windowsFactory.createOperatingSystem().showOS();
windowsFactory.createBrowser().showBrowser();
AbstractFactory macFactory = new MacFactory();
macFactory.createOperatingSystem().showOS();
macFactory.createBrowser().showBrowser();
}
}
每种工厂模式都有其适用场景和局限性，选择合适的模式需基于项目的需求、扩展性和维护性等因素综合考虑。
策略模式（Strategy Pattern）是一种行为设计模式，它定义了一系列算法，并将每一个算法封装起来，使它们可以互相替换。策略模式让算法的变化独立于使用算法的客户，使代码结构更加灵活，易于扩展。
优点
缺点
4. 客户端必须了解策略：客户端需要知道所有策略类的存在，并决定使用哪个策略，这可能会增加客户端的复杂度。
5. 类数量增加：每增加一个策略，就需要增加一个类，可能导致类的数量膨胀。
6. 过度设计风险：对于简单的场景，使用策略模式可能会导致设计过度复杂。
代码示例
假设我们有一个购物车系统，需要根据不同的支付策略计算订单的总金额，比如正常价格、会员折扣价、促销价等。
// 策略接口
interface PaymentStrategy {
double calculateTotal(double amount);
}
// 具体策略类：正常支付
class NormalPayment implements PaymentStrategy {
@Override
public double calculateTotal(double amount) {
return amount;
}
}
// 具体策略类：会员折扣支付
class MemberDiscountPayment implements PaymentStrategy {
@Override
public double calculateTotal(double amount) {
return amount * 0.9; // 会员享有10%折扣
}
}
// 具体策略类：促销支付
class PromotionPayment implements PaymentStrategy {
@Override
public double calculateTotal(double amount) {
return amount * 0.8; // 促销活动打8折
}
}
// 环境类（Context），使用策略的类
class ShoppingCart {
private PaymentStrategy strategy;
public void setPaymentStrategy(PaymentStrategy strategy) {
this.strategy = strategy;
}
public double calculateTotal(double amount) {
return strategy.calculateTotal(amount);
}
}
public class StrategyPatternDemo {
public static void main(String[] args) {
ShoppingCart cart = new ShoppingCart();
// 使用会员折扣策略
cart.setPaymentStrategy(new MemberDiscountPayment());
System.out.println("会员折扣总价：" + cart.calculateTotal(100));
// 切换到促销策略
cart.setPaymentStrategy(new PromotionPayment());
System.out.println("促销活动总价：" + cart.calculateTotal(100));
// 使用正常支付策略
cart.setPaymentStrategy(new NormalPayment());
System.out.println("正常支付总价：" + cart.calculateTotal(100));
}
}
责任链模式（Chain of Responsibility Pattern）是一种行为设计模式，它允许将请求沿着处理者链进行传递，直到找到能够处理该请求的处理者。每个处理者都包含对下个处理者的引用，如果一个处理者不能处理请求，则会将请求传递给链中的下一个处理者。这样，多个对象都有机会处理请求，从而避免了请求发送者与接收者之间的耦合。
优点
缺点
代码示例
假设我们有一个简单的审批系统，需要根据不同的金额级别由不同级别的经理进行审批。
// 定义处理请求的接口
interface Approver {
void setNextApprover(Approver nextApprover);
void processRequest(int amount);
}
// 具体处理者：部门经理
class DepartmentManager implements Approver {
private Approver nextApprover;
@Override
public void setNextApprover(Approver nextApprover) {
this.nextApprover = nextApprover;
}
@Override
public void processRequest(int amount) {
if (amount <= 5000) {
System.out.println("部门经理批准了 " + amount + " 元的请求。");
} else if (nextApprover != null) {
nextApprover.processRequest(amount);
}
}
}
// 具体处理者：总经理
class GeneralManager implements Approver {
private Approver nextApprover;
@Override
public void setNextApprover(Approver nextApprover) {
this.nextApprover = nextApprover;
}
@Override
public void processRequest(int amount) {
if (amount <= 10000) {
System.out.println("总经理批准了 " + amount + " 元的请求。");
} else if (nextApprover != null) {
nextApprover.processRequest(amount);
}
}
}
// 客户端代码
public class ChainOfResponsibilityDemo {
public static void main(String[] args) {
Approver departmentManager = new DepartmentManager();
Approver generalManager = new GeneralManager();
// 构建责任链
departmentManager.setNextApprover(generalManager);
// 提交请求
departmentManager.processRequest(3000); // 部门经理处理
departmentManager.processRequest(8000); // 总经理处理
departmentManager.processRequest(12000); // 未处理，超出了所有处理者的权限
}
}
模板方法模式（Template Method Pattern）是一种行为设计模式，它定义了一个操作中的算法骨架，而将一些步骤延迟到子类中实现。模板方法使得子类可以重新定义算法的某些步骤，而不改变算法的结构。
优点
缺点
代码举例// 抽象类，定义文件处理的模板方法
abstract class FileProcessor {
public final void processFile(String filePath) {
openFile(filePath);
readFile();
processData();
writeFile();
closeFile();
}
abstract void openFile(String filePath); // 抽象方法，由子类实现打开文件
abstract void readFile(); // 抽象方法，由子类实现读取文件内容
abstract void processData(); // 抽象方法，由子类实现数据处理逻辑
abstract void writeFile(); // 抽象方法，由子类实现写入文件
abstract void closeFile(); // 抽象方法，由子类实现关闭文件
}
// 具体实现类，处理TXT文件
class TXTFileProcessor extends FileProcessor {
@Override
void openFile(String filePath) {
System.out.println("Opening TXT file: " + filePath);
}
@Override
void readFile() {
System.out.println("Reading TXT content");
}
@Override
void processData() {
System.out.println("Processing TXT data");
}
@Override
void writeFile() {
System.out.println("Writing processed TXT data back to file");
}
@Override
void closeFile() {
System.out.println("Closing TXT file");
}
}
// 具体实现类，处理PDF文件
class PDFFileProcessor extends FileProcessor {
@Override
void openFile(String filePath) {
System.out.println("Opening PDF file: " + filePath);
}
@Override
void readFile() {
System.out.println("Reading PDF content");
}
@Override
void processData() {
System.out.println("Processing PDF data");
}
@Override
void writeFile() {
System.out.println("Writing processed PDF data back to file");
}
@Override
void closeFile() {
System.out.println("Closing PDF file");
}
}
public class FileProcessingDemo {
public static void main(String[] args) {
FileProcessor txtProcessor = new TXTFileProcessor();
FileProcessor pdfProcessor = new PDFFileProcessor();
txtProcessor.processFile("sample.txt"); // 处理TXT文件
pdfProcessor.processFile("document.pdf"); // 处理PDF文件
}
}
在这个例子中，FileProcessor类定义了处理文件的模板方法，包括打开文件、读取文件、处理数据、写入文件和关闭文件的一系列步骤。TXTFileProcessor和PDFFileProcessor类作为具体实现，分别覆盖了这些抽象方法以实现特定文件格式的处理逻辑。这种设计使得新增其他文件类型的支持变得非常简单，只需要创建一个新的子类并实现相应的抽象方法即可。
单例模式（Singleton Pattern）是一种创建型设计模式，它确保一个类在整个应用程序中仅有一个实例，并提供一个全局访问点来获取这个实例。这有助于控制共享资源的访问，比如数据库连接池、日志系统等。
优点
缺点
代码示例 (Java)
以下是一个线程安全的懒汉式单例模式实现：
public class Singleton {
private static volatile Singleton instance;
// 私有构造方法，防止外部直接创建实例
private Singleton() {}
// 获取单例实例的公共方法
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
在这个例子中，Singleton类的构造方法是私有的，防止外部直接实例化。getInstance方法提供了获取单例实例的途径，并使用双重检查锁定（double-checked locking）机制来确保线程安全和性能，即只有在实例为null且需要创建时才进行同步操作。这样既保证了单例的唯一性，又尽可能减少了同步带来的性能开销.