简单工厂、工厂方法、抽象工厂模式-这仨货的区别

在软件开发中，常常会用到工厂模式来创建对象，其中包括简单工厂、工厂方法和抽象工厂模式。这三种工厂模式在实际应用中有着不同的特点和用途。

简单工厂模式：
简单工厂模式是最简单的工厂模式，它通过一个工厂类来创建对象。客户端只需要知道工厂类的名称，而不需要知道具体的产品类。下面是一个简单工厂模式的示例代码：

java
// 定义产品接口
public interface Product {
    void show();
}

// 具体产品类A
public class ConcreteProductA implements Product {
    @Override
    public void show() {
        System.out.println(This is product A);
    }
}

// 具体产品类B
public class ConcreteProductB implements Product {
    @Override
    public void show() {
        System.out.println(This is product B);
    }
}

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

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

java
// 定义产品接口
public interface Product {
    void show();
}

// 具体产品类A
public class ConcreteProductA implements Product {
    @Override
    public void show() {
        System.out.println(This is product A);
    }
}

// 具体产品类B
public class ConcreteProductB implements Product {
    @Override
    public void show() {
        System.out.println(This is product B);
    }
}

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

// 具体工厂类A
public 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.show();
        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.show();
    }
}

java
// 定义产品接口
public interface Product {
    void show();
}

// 具体产品类A
public class ConcreteProductA implements Product {
    @Override
    public void show() {
        System.out.println(This is product A);
    }
}

// 具体产品类B
public class ConcreteProductB implements Product {
    @Override
    public void show() {
        System.out.println(This is product B);
    }
}

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

// 具体工厂类1
public class ConcreteFactory1 implements AbstractFactory {
    @Override
    public Product createProductA() {
        return new ConcreteProductA();
    }

    @Override
    public Product createProductB() {
        return new ConcreteProductB();
    }
}

// 具体工厂类2
public class ConcreteFactory2 implements AbstractFactory {
    @Override
    public Product createProductA() {
        return new ConcreteProductA();
    }

    @Override
    public Product createProductB() {
        return new ConcreteProductB();
    }
}

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

        AbstractFactory factory2 = new ConcreteFactory2();
        Product productA2 = factory2.createProductA();
        productA2.show();
        Product productB2 = factory2.createProductB();
        productB2.show();
    }
}