工厂模式的java代码实现

工厂模式是一种常用的创建型模式，它定义了一个用于创建对象的接口，让子类决定实例化哪一个类。工厂模式使得一个类的实例化延迟到其子类。

在 Java 中，工厂模式有三种实现方式：简单工厂模式、工厂方法模式和抽象工厂模式。下面分别介绍这三种实现方式的具体实现。

简单工厂模式

简单工厂模式又称为静态工厂方法模式，它通过一个工厂类创建不同类型的对象，属于创建型模式。下面是一个简单的示例代码：

// 抽象产品类
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 Factory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        } else {
            throw new RuntimeException("Invalid product type");
        }
    }
}

// 客户端代码
public class SimpleFactoryDemo {
    public static void main(String[] args) {
        Product productA = Factory.createProduct("A");
        Product productB = Factory.createProduct("B");
        productA.show();
        productB.show();
    }
}

在上面的代码中，Product 是一个抽象产品类，ConcreteProductA 和 ConcreteProductB 是具体的产品类，实现了 Product 接口。Factory 是工厂类，通过静态方法 createProduct 来创建不同类型的产品对象。客户端代码可以通过调用 Factory.createProduct 方法来获取具体的产品对象，并调用它们的 show 方法。

工厂方法模式

工厂方法模式是简单工厂模式的一种升级版，它定义了一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使得一个类的实例化延迟到其子类。下面是一个示例代码：

// 抽象产品类
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");
    }
}

// 抽象工厂类
interface Factory {
    Product createProduct();
}

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


// 具体工厂类B
public class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}
// 客户端
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.operation();

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

在上述示例中，我们通过具体工厂类 ConcreteFactoryA 和 ConcreteFactoryB 来创建具体产品对象 ConcreteProductA 和 ConcreteProductB。客户端代码只依赖于抽象工厂接口和抽象产品接口，而不依赖于具体的产品类和具体的工厂类。这样可以提高代码的灵活性和可维护性。

工厂方法模式相对于简单工厂模式的优势在于，它将工厂的职责拆分到了多个具体工厂类中，每个具体工厂类负责创建自己对应的产品对象。这样可以更加方便地扩展和修改产品对象的创建方式，并且也可以降低工厂类的复杂度。

抽象工厂模式

象工厂模式也是一种创建型设计模式，它提供了一个接口，用于创建一系列相关或相互依赖的对象，而无需指定具体的类。下面是一个简单的抽象工厂模式的 Java 实现示例：

public interface ProductA {
    void operationA();
}

public interface ProductB {
    void operationB();
}
public class ConcreteProductA1 implements ProductA {
    @Override
    public void operationA() {
        System.out.println("ConcreteProductA1 operationA");
    }
}

public class ConcreteProductA2 implements ProductA {
    @Override
    public void operationA() {
        System.out.println("ConcreteProductA2 operationA");
    }
}

public class ConcreteProductB1 implements ProductB {
    @Override
    public void operationB() {
        System.out.println("ConcreteProductB1 operationB");
    }
}

public class ConcreteProductB2 implements ProductB {
    @Override
    public void operationB() {
        System.out.println("ConcreteProductB2 operationB");
    }
}
public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}
public class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

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

public class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    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.operationA();
        productB1.operationB();

        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();
        productA2.operationA();
        productB2.operationB();
    }
}

在上述示例中，我们通过具体工厂类 ConcreteFactory1 和 ConcreteFactory2 来创建一系列相关的产品对象。客户端代码只依赖于抽象工厂接口和抽象产品接口，而不依赖于具体的产品类和具体的工厂类。这样可以提高代码的灵活性和可维护性。

抽象工厂模式相对于工厂方法模式的优势在于，它可以创建一系列相关或相互依赖的产品族，而不是单一的产品对象。这样可以更加方便地保证产品族之间的一致性和兼容性。但是抽象工厂模式的缺点在于，当需要增加新的产品族时，需要修改抽象工厂接口和所有具体工厂类的实现，这可能会导致较大的代码改动。