java工厂设计模式

Java中的工厂设计模式是一种创建型设计模式，它提供了一种将对象的创建逻辑抽象出来的方法，使得客户端代码不需要直接实例化具体的类，而是通过一个共同的接口来创建对象。这样可以降低代码之间的耦合性，提高代码的可维护性和可扩展性。

在工厂设计模式中，通常有三种主要的类型：简单工厂模式、工厂方法模式和抽象工厂模式。下面分别介绍这三种类型的工厂模式：

1. 简单工厂模式（Simple Factory Pattern）： 简单工厂模式也称为静态工厂模式，它通过一个工厂类来封装对象的创建逻辑，客户端通过传递不同的参数给工厂类来获取不同类型的对象。简单工厂模式适用于创建单一类型的对象。

示例代码：

// 产品接口
interface Product {
    void produce();
}

// 具体产品类A
class ConcreteProductA implements Product {
    public void produce() {
        System.out.println("Producing Product A");
    }
}

// 具体产品类B
class ConcreteProductB implements Product {
    public void produce() {
        System.out.println("Producing Product B");
    }
}

// 简单工厂类
class SimpleFactory {
    public Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ConcreteProductA();
        } else if ("B".equals(type)) {
            return new ConcreteProductB();
        }
        throw new IllegalArgumentException("Invalid product type");
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        SimpleFactory factory = new SimpleFactory();
        Product productA = factory.createProduct("A");
        Product productB = factory.createProduct("B");
        productA.produce();
        productB.produce();
    }
}

1. 工厂方法模式（Factory Method Pattern）： 工厂方法模式通过定义一个接口来创建对象，每个具体的产品类都实现这个接口，并提供了自己的工厂方法来创建对象。客户端通过调用具体产品类的工厂方法来获取对象，从而将对象的创建延迟到具体的产品类中。

示例代码：

// 产品接口
interface Product {
    void produce();
}

// 具体产品类A
class ConcreteProductA implements Product {
    public void produce() {
        System.out.println("Producing Product A");
    }
}

// 具体产品类B
class ConcreteProductB implements Product {
    public void produce() {
        System.out.println("Producing Product B");
    }
}

// 工厂接口
interface Factory {
    Product createProduct();
}

// 具体工厂类A
class ConcreteFactoryA implements Factory {
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

// 具体工厂类B
class ConcreteFactoryB implements Factory {
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.produce();

        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.produce();
    }
}

1. 抽象工厂模式（Abstract Factory Pattern）： 抽象工厂模式通过提供一个接口来创建一组相关或相互依赖的对象，每个具体的工厂类都实现这个接口，并负责创建一组相关的产品。客户端通过调用具体工厂类的方法来获取相应的产品组，从而将产品的创建和客户端的使用分离。

示例代码：

// 产品接口A
interface ProductA {
    void produce();
}

// 具体产品类A1
class ConcreteProductA1 implements ProductA {
    public void produce() {
        System.out.println("Producing Product A1");
    }
}

// 具体产品类A2
class ConcreteProductA2 implements ProductA {
    public void produce() {
        System.out.println("Producing Product A2");
    }
}

// 产品接口B
interface ProductB {
    void produce();
}

// 具体产品类B1
class ConcreteProductB1 implements ProductB {
    public void produce() {
        System.out.println("Producing Product B1");
    }
}

// 具体产品类B2
class ConcreteProductB2 implements ProductB {
    public void produce() {
        System.out.println("Producing Product B2");
    }
}

// 抽象工厂接口
interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

// 具体工厂类1
class ConcreteFactory1 implements AbstractFactory {
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

// 具体工厂类2
class ConcreteFactory2 implements AbstractFactory {
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        ProductB productB1 = factory1.createProductB();
        productA1.produce();
        productB1.produce();

        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();
        productA2.produce();
        productB2.produce();
    }
}
以上是三种常见的工厂设计模式的示例代码。工厂设计模式在实际开发中经常被使用，特别是在需要创建复杂对象或者遵循开闭原则的场景下，它可以帮助我们更好地组织和管理对象的创建过程。