工厂模式

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

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

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

// 工厂接口
public abstract class Factory {
    public abstract Product factoryMethod();
}

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

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

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.factoryMethod();
        productA.use(); // 输出: 使用具体产品 A

        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.factoryMethod();
        productB.use(); // 输出: 使用具体产品 B
    }
}

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

public interface Checkbox {
    void render();
}

// 具体产品类 - Windows
public class WindowsButton implements Button {
    public void render() {
        System.out.println("渲染 Windows 按钮");
    }
}

public class WindowsCheckbox implements Checkbox {
    public void render() {
        System.out.println("渲染 Windows 复选框");
    }
}

// 具体产品类 - MacOS
public class MacOSButton implements Button {
    public void render() {
        System.out.println("渲染 MacOS 按钮");
    }
}

public class MacOSCheckbox implements Checkbox {
    public void render() {
        System.out.println("渲染 MacOS 复选框");
    }
}

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

// 具体工厂类 - Windows
public class WindowsFactory implements GUIFactory {
    public Button createButton() {
        return new WindowsButton();
    }
    
    public Checkbox createCheckbox() {
        return new WindowsCheckbox();
    }
}

// 具体工厂类 - MacOS
public class MacOSFactory implements GUIFactory {
    public Button createButton() {
        return new MacOSButton();
    }
    
    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 factory;
        String osName = System.getProperty("os.name").toLowerCase();
        if(osName.contains("win")) {
            factory = new WindowsFactory();
        } else {
            factory = new MacOSFactory();
        }
        Client client = new Client(factory);
        client.render();
    }
}

import java.lang.reflect.Constructor;

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

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

public class ConcreteProductB implements Product {
    public void use() {
        System.out.println("使用具体产品 B");
    }
}

// 工厂类
public class ProductFactory {
    public static Product createProduct(String className) {
        try {
            Class<?> cls = Class.forName(className);
            Constructor<?> constructor = cls.getDeclaredConstructor();
            return (Product) constructor.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Product productA = ProductFactory.createProduct("ConcreteProductA");
        if(productA != null) {
            productA.use(); // 输出: 使用具体产品 A
        }
        
        Product productB = ProductFactory.createProduct("ConcreteProductB");
        if(productB != null) {
            productB.use(); // 输出: 使用具体产品 B
        }
    }
}