工厂模式，策略工厂模式，简单工厂模式，抽象工厂模式，有啥区别，分别适用于什么场景

1. 简单工厂模式：
   简单工厂模式是一种创建型设计模式，它通过一个工厂类来决定创建哪种产品类的实例。客户端只需要传入一个参数，工厂类就会根据这个参数来创建相应的对象。简单工厂模式适用于只有一个工厂类，根据传入参数的不同来创建不同的产品对象的场景。

2. 工厂模式：
   工厂模式是一种创建型设计模式，它定义了一个创建对象的接口，但是让子类决定实例化哪个类。工厂模式允许一个类在运行时创建另一个类的对象。工厂模式适用于创建对象的过程比较复杂，可能会有多个具体工厂类来创建不同的产品对象的场景。

3. 策略工厂模式：
   策略工厂模式是一种行为设计模式，它定义了一系列算法，并将每个算法封装到一个类中，使它们可以相互替换。客户端可以根据需要在运行时选择不同的算法。策略工厂模式适用于需要在运行时动态选择算法的场景。

4. 抽象工厂模式：
   抽象工厂模式是一种创建型设计模式，它提供一个接口，用于创建相关或依赖对象的家族，而不需要指定具体类。抽象工厂模式适用于需要创建一组相关对象的场景，例如不同系列的产品对象。

工厂模式是一个更广泛的概念，包括简单工厂模式、工厂方法模式和抽象工厂模式。简单工厂模式适用于简单的对象创建场景，策略工厂模式适用于动态选择算法的场景，抽象工厂模式适用于创建一组相关对象的场景。选择适合场景的设计模式可以提高代码的可维护性和扩展性。

举个例子

简单工厂模式示例：

package main

import "fmt"

type Product interface {
    GetInfo() string
}

type ConcreteProductA struct{}

func (p ConcreteProductA) GetInfo() string {
    return "Product A"
}

type ConcreteProductB struct{}

func (p ConcreteProductB) GetInfo() string {
    return "Product B"
}

func CreateProduct(productType string) Product {
    switch productType {
    case "A":
        return ConcreteProductA{}
    case "B":
        return ConcreteProductB{}
    default:
        return nil
    }
}

func main() {
    productA := CreateProduct("A")
    fmt.Println(productA.GetInfo()) // Output: Product A

    productB := CreateProduct("B")
    fmt.Println(productB.GetInfo()) // Output: Product B
}

工厂模式示例：

package main

import "fmt"

type Product interface {
    GetInfo() string
}

type ConcreteProductA struct{}

func (p ConcreteProductA) GetInfo() string {
    return "Product A"
}

type ConcreteProductB struct{}

func (p ConcreteProductB) GetInfo() string {
    return "Product B"
}

type Factory interface {
    CreateProduct() Product
}

type ConcreteFactoryA struct{}

func (f ConcreteFactoryA) CreateProduct() Product {
    return ConcreteProductA{}
}

type ConcreteFactoryB struct{}

func (f ConcreteFactoryB) CreateProduct() Product {
    return ConcreteProductB{}
}

func main() {
    factoryA := ConcreteFactoryA{}
    productA := factoryA.CreateProduct()
    fmt.Println(productA.GetInfo()) // Output: Product A

    factoryB := ConcreteFactoryB{}
    productB := factoryB.CreateProduct()
    fmt.Println(productB.GetInfo()) // Output: Product B
}

策略工厂模式

package main

import "fmt"

type Strategy interface {
    DoOperation()
}

type ConcreteStrategyA struct{}

func (s ConcreteStrategyA) DoOperation() {
    fmt.Println("Strategy A")
}

type ConcreteStrategyB struct{}

func (s ConcreteStrategyB) DoOperation() {
    fmt.Println("Strategy B")
}

type Context struct {
    strategy Strategy
}

func NewContext(strategy Strategy) *Context {
    return &Context{strategy}
}

func (c *Context) ExecuteStrategy() {
    c.strategy.DoOperation()
}

func main() {
    strategyA := ConcreteStrategyA{}
    contextA := NewContext(strategyA)
    contextA.ExecuteStrategy() // Output: Strategy A

    strategyB := ConcreteStrategyB{}
    contextB := NewContext(strategyB)
    contextB.ExecuteStrategy() // Output: Strategy B
}

抽象工厂模式

// 抽象产品接口
interface Button {
    void render();
}

interface Checkbox {
    void render();
}

// 具体产品类
class WindowsButton implements Button {
    @Override
    public void render() {
        System.out.println("Rendering a Windows button");
    }
}

class MacOSButton implements Button {
    @Override
    public void render() {
        System.out.println("Rendering a MacOS button");
    }
}

class WindowsCheckbox implements Checkbox {
    @Override
    public void render() {
        System.out.println("Rendering a Windows checkbox");
    }
}

class MacOSCheckbox implements Checkbox {
    @Override
    public void render() {
        System.out.println("Rendering a MacOS checkbox");
    }
}

// 抽象工厂接口
interface GUIFactory {
    Button createButton();
    Checkbox createCheckbox();
}

// 具体工厂类
class WindowsFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new WindowsButton();
    }

    @Override
    public Checkbox createCheckbox() {
        return new WindowsCheckbox();
    }
}

class MacOSFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new MacOSButton();
    }

    @Override
    public Checkbox createCheckbox() {
        return new MacOSCheckbox();
    }
}

// 客户端代码
public class Client {
    private Button button;
    private Checkbox checkbox;

    public Client(GUIFactory factory) {
        button = factory.createButton();
        checkbox = factory.createCheckbox();
    }

    public void render() {
        button.render();
        checkbox.render();
    }

    public static void main(String[] args) {
        GUIFactory windowsFactory = new WindowsFactory();
        Client windowsClient = new Client(windowsFactory);
        windowsClient.render();

        GUIFactory macOSFactory = new MacOSFactory();
        Client macOSClient = new Client(macOSFactory);
        macOSClient.render();
    }
}