工厂设计模式的实现与应用场景分析

工厂设计模式的实现与应用场景分析

大家好，我是免费搭建查券返利机器人省钱赚佣金就用微赚淘客系统3.0的小编，也是冬天不穿秋裤，天冷也要风度的程序猿！

工厂设计模式（Factory Pattern）是一种创建型设计模式，它定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂模式让类的实例化推迟到子类，从而使代码更具扩展性和灵活性。本文将介绍工厂设计模式的基本实现方法、应用场景，并通过Java代码示例详细说明。

工厂设计模式的基本实现

工厂设计模式主要分为三种类型：简单工厂模式、工厂方法模式和抽象工厂模式。我们将逐一进行介绍和分析。

1. 简单工厂模式

简单工厂模式通过一个工厂类，根据传入的参数，决定创建哪一种产品的实例。这个模式不是真正的设计模式，而是一种编程习惯。

示例代码：

package cn.juwatech.factory;

interface Product {
    void create();
}

class ProductA implements Product {
    @Override
    public void create() {
        System.out.println("ProductA created");
    }
}

class ProductB implements Product {
    @Override
    public void create() {
        System.out.println("ProductB created");
    }
}

class SimpleFactory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ProductA();
        } else if (type.equals("B")) {
            return new ProductB();
        }
        return null;
    }
}

public class FactoryTest {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.create();
        
        Product productB = SimpleFactory.createProduct("B");
        productB.create();
    }
}

2. 工厂方法模式

工厂方法模式通过定义一个创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

示例代码：

package cn.juwatech.factory;

interface Product {
    void create();
}

class ProductA implements Product {
    @Override
    public void create() {
        System.out.println("ProductA created");
    }
}

class ProductB implements Product {
    @Override
    public void create() {
        System.out.println("ProductB created");
    }
}

interface Factory {
    Product createProduct();
}

class FactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

class FactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

public class FactoryMethodTest {
    public static void main(String[] args) {
        Factory factoryA = new FactoryA();
        Product productA = factoryA.createProduct();
        productA.create();
        
        Factory factoryB = new FactoryB();
        Product productB = factoryB.createProduct();
        productB.create();
    }
}

3. 抽象工厂模式

抽象工厂模式通过一个接口创建一系列相关或相互依赖的对象，而无需指定它们的具体类。它提供一个创建一系列相关或依赖对象的接口，而无需指定它们具体的类。

示例代码：

package cn.juwatech.factory;

interface ProductA {
    void createA();
}

class ProductA1 implements ProductA {
    @Override
    public void createA() {
        System.out.println("ProductA1 created");
    }
}

class ProductA2 implements ProductA {
    @Override
    public void createA() {
        System.out.println("ProductA2 created");
    }
}

interface ProductB {
    void createB();
}

class ProductB1 implements ProductB {
    @Override
    public void createB() {
        System.out.println("ProductB1 created");
    }
}

class ProductB2 implements ProductB {
    @Override
    public void createB() {
        System.out.println("ProductB2 created");
    }
}

interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

class Factory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA1();
    }
    
    @Override
    public ProductB createProductB() {
        return new ProductB1();
    }
}

class Factory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA2();
    }
    
    @Override
    public ProductB createProductB() {
        return new ProductB2();
    }
}

public class AbstractFactoryTest {
    public static void main(String[] args) {
        AbstractFactory factory1 = new Factory1();
        ProductA productA1 = factory1.createProductA();
        productA1.createA();
        ProductB productB1 = factory1.createProductB();
        productB1.createB();
        
        AbstractFactory factory2 = new Factory2();
        ProductA productA2 = factory2.createProductA();
        productA2.createA();
        ProductB productB2 = factory2.createProductB();
        productB2.createB();
    }
}