工厂模式三兄弟：简单工厂、工厂方法、抽象工厂

public void checkout(String type, BigDecimal amount) {
    if ("alipay".equals(type)) {
        new AliPay().pay(amount);
    } else if ("wechat".equals(type)) {
        new WeChatPay().pay(amount);
    } else if ("paypal".equals(type)) {
        new PayPalPay().pay(amount);
    }
}

/** 简单工厂：一个方法决定造哪个具体类 */
public class SimpleFactoryDemo {

    interface Payment {                       // 抽象产品
        void pay(java.math.BigDecimal amount);
    }

    static class AliPay implements Payment {  // 具体产品 A
        public void pay(java.math.BigDecimal amount) {
            System.out.println("支付宝支付 " + amount);
        }
    }

    static class WeChatPay implements Payment { // 具体产品 B
        public void pay(java.math.BigDecimal amount) {
            System.out.println("微信支付 " + amount);
        }
    }

    /** 工厂：集中创建逻辑，调用方只认接口 */
    static class PaymentFactory {
        static Payment create(String type) {
            switch (type.toLowerCase()) {
                case "alipay": return new AliPay();
                case "wechat": return new WeChatPay();
                default: throw new IllegalArgumentException("不支持的支付方式: " + type);
            }
        }
    }

    public static void main(String[] args) {
        Payment p = PaymentFactory.create("alipay");
        p.pay(new java.math.BigDecimal("19.90"));
        PaymentFactory.create("wechat").pay(new java.math.BigDecimal("5.00"));
    }
}

/** 注册表式工厂：新增产品只注册，不改工厂 */
public class RegistryFactoryDemo {

    interface Payment { void pay(java.math.BigDecimal amount); }
    static class AliPay implements Payment {
        public void pay(java.math.BigDecimal a) { System.out.println("支付宝 " + a); }
    }
    static class WeChatPay implements Payment {
        public void pay(java.math.BigDecimal a) { System.out.println("微信 " + a); }
    }

    static class PaymentFactory {
        private static final java.util.Map<String, java.util.function.Supplier<Payment>>
                REGISTRY = new java.util.HashMap<>();

        static void register(String type, java.util.function.Supplier<Payment> supplier) {
            REGISTRY.put(type.toLowerCase(), supplier);
        }
        static Payment create(String type) {
            java.util.function.Supplier<Payment> s = REGISTRY.get(type.toLowerCase());
            if (s == null) throw new IllegalArgumentException("未注册的支付方式: " + type);
            return s.get();
        }
    }

    public static void main(String[] args) {
        PaymentFactory.register("alipay", AliPay::new);     // 注册
        PaymentFactory.register("wechat", WeChatPay::new);
        PaymentFactory.create("alipay").pay(new java.math.BigDecimal("9.90"));
    }
}

/** 工厂方法：抽象工厂定义"造什么"的接口，由子类决定具体产品 */
public class FactoryMethodDemo {

    interface Transport {                    // 抽象产品
        void deliver();
    }
    static class Truck implements Transport {
        public void deliver() { System.out.println("卡车陆运，走高速"); }
    }
    static class Ship implements Transport {
        public void deliver() { System.out.println("轮船海运，走港口"); }
    }

    /** 抽象工厂：包含"业务方法"和"工厂方法" */
    abstract static class Logistics {
        protected abstract Transport createTransport();   // 工厂方法

        public void planDelivery() {                      // 业务方法：只依赖抽象产品
            Transport t = createTransport();
            System.out.println("规划路线…");
            t.deliver();
        }
    }

    static class RoadLogistics extends Logistics {        // 具体工厂 A
        protected Transport createTransport() { return new Truck(); }
    }
    static class SeaLogistics extends Logistics {         // 具体工厂 B
        protected Transport createTransport() { return new Ship(); }
    }

    public static void main(String[] args) {
        new RoadLogistics().planDelivery();
        new SeaLogistics().planDelivery();
    }
}

/** 抽象工厂：一个工厂负责一个产品族（同风格的整套组件） */
public class AbstractFactoryDemo {

    interface Button { void paint(); }        // 产品等级结构 1
    interface Checkbox { void paint(); }      // 产品等级结构 2

    static class WinButton implements Button {
        public void paint() { System.out.println("渲染 Windows 风格按钮"); }
    }
    static class WinCheckbox implements Checkbox {
        public void paint() { System.out.println("渲染 Windows 风格复选框"); }
    }
    static class MacButton implements Button {
        public void paint() { System.out.println("渲染 macOS 风格按钮"); }
    }
    static class MacCheckbox implements Checkbox {
        public void paint() { System.out.println("渲染 macOS 风格复选框"); }
    }

    /** 抽象工厂：声明一族产品的创建方法 */
    interface GUIFactory {
        Button createButton();
        Checkbox createCheckbox();
    }
    static class WinFactory implements GUIFactory {
        public Button createButton() { return new WinButton(); }
        public Checkbox createCheckbox() { return new WinCheckbox(); }
    }
    static class MacFactory implements GUIFactory {
        public Button createButton() { return new MacButton(); }
        public Checkbox createCheckbox() { return new MacCheckbox(); }
    }

    /** 客户端只依赖抽象工厂 + 抽象产品，不知道具体风格 */
    static class Application {
        private final Button button;
        private final Checkbox checkbox;

        Application(GUIFactory factory) {
            this.button = factory.createButton();
            this.checkbox = factory.createCheckbox();
        }
        void render() { button.paint(); checkbox.paint(); }
    }

    public static void main(String[] args) {
        String os = System.getProperty("os.name").toLowerCase();
        GUIFactory factory = os.contains("mac") ? new MacFactory() : new WinFactory();
        new Application(factory).render();
    }
}