小小工厂模式 轻松拿捏

Java 工厂模式的初级使用

公众号 装睡鹿先生

在 Java 的编程世界里，工厂模式就像是一座神奇的 "魔法工坊"，能高效、有序地帮我们 "制造" 各种对象，避免代码陷入混乱的 "泥沼"。今天，咱就以轻松幽默的方式，走进这工厂模式的初级应用天地，瞧瞧它是咋施展 "魔法" 的。

一、简单工厂模式：基础 "魔法工坊" 初体验

想象你经营着一家超火的玩具店，店里有各式各样的玩具，像毛绒小熊、塑料恐龙、积木城堡等。要是没有工厂模式，每次有顾客下单，你得在杂乱的仓库（代码里的主类）里翻箱倒柜找对应的玩具，再包装售卖，代码可能就长这样：

public class ToyShop {
    public static void sellToy(String toyType) {
        if ("毛绒小熊".equals(toyType)) {
            // 手动创建毛绒小熊对象的代码，比如设置材质、颜色等属性
            TeddyBear teddyBear = new TeddyBear("棕色", "柔软绒毛");
            System.out.println("售卖毛绒小熊：" + teddyBear);
        } else if ("塑料恐龙".equals(toyType)) {
            PlasticDinosaur dinosaur = new PlasticDinosaur("绿色", "硬塑料");
            System.out.println("售卖塑料恐龙：" + dinosaur);
        } else if ("积木城堡".equals(toyType)) {
            BuildingBlockCastle castle = new BuildingBlockCastle("彩色", "木质积木");
            System.out.println("售卖积木城堡：" + castle);
        } else {
            System.out.println("暂无此款玩具库存！");
        }
    }

    public static void main(String[] args) {
        sellToy("毛绒小熊");
    }
}

瞅瞅，这代码里一堆 if - else 判断，每次进新玩具，得在这 "大杂烩" 里加好多新逻辑，乱得像缠在一起的毛线团。

这时候，简单工厂模式就闪亮登场啦！它像个专业 "玩具制造工坊"，把创建玩具的活儿都揽过去，让咱的玩具店（主类）清爽起来。

1. 创建产品接口与具体产品类
   先定个 "玩具" 接口，就好比画张蓝图，规定所有玩具都得有 "展示" 功能：

interface Toy {
    void show();
}

然后，毛绒小熊、塑料恐龙、积木城堡这些具体玩具类按蓝图 "施工"，实现接口：

class TeddyBear implements Toy {
    private String color;
    private String material;

    public TeddyBear(String color, String material) {
        this.color = color;
        this.material = material;
    }

    @Override
    public void show() {
        System.out.println("我是一只" + color + "的毛绒小熊，材质是" + material);
    }
}

class PlasticDinosaur implements Toy {
    private String color;
    private String material;

    public PlasticDinosaur(String color, String material) {
        this.color = color;
        this.material = material;
    }

    @Override
    public void show() {
        System.out.println("我是一只" + color + "的塑料恐龙，材质是" + material);
    }
}

class BuildingBlockCastle implements Toy {
    private String color;
    private String material;

    public BuildingBlockCastle(String color, String material) {
        this.color = color;
        this.material = material;
    }

    @Override
    public void show() {
        System.out.println("我是一座" + color + "的积木城堡，材质是" + material);
    }
}

2. 搭建简单工厂类
   这个工厂类就像工坊里的 "老师傅"，根据订单（传入参数）造玩具：

class ToyFactory {
    public static Toy createToy(String toyType) {
        if ("毛绒小熊".equals(toyType)) {
            return new TeddyBear("棕色", "柔软绒毛");
        } else if ("塑料恐龙".equals(toyType)) {
            return new PlasticDinosaur("绿色", "硬塑料");
        } else if ("积木城堡".equals(toyType)) {
            return new BuildingBlockCastle("彩色", "木质积木");
        } else {
            return null;
        }
    }
}

3. 优化玩具店售卖逻辑
   现在玩具店代码简洁多了，专心 "卖货" 就行：

public class ToyShop {
    public static void sellToy(String toyType) {
        Toy toy = ToyFactory.createToy(toyType);
        if (toy!= null) {
            toy.show();
        } else {
            System.out.println("暂无此款玩具库存！");
        }
    }

    public static void main(String[] args) {
        sellToy("毛绒小熊");
    }
}

以后进新玩具，在工厂类里加个 if - else 判断分支就行，玩具店主类稳如泰山，不被干扰，代码维护轻松不少。

二、工厂方法模式：进阶 "魔法工坊" 的分工协作

简单工厂模式虽好，但工厂类越来越大时，也会 "不堪重负"。这就轮到工厂方法模式出场，它像把工厂拆成多个 "小工坊"，各干各的活儿。

还拿玩具店举例，现在玩具多了，按材质分了几个 "工坊"，有 "毛绒工坊""塑料工坊""木质工坊"，每个工坊专注造对应材质玩具。

1. 改造工厂类为抽象工厂与具体工厂子类
   先把工厂变成抽象的，定个规矩（抽象方法），让子类按规矩造玩具：

abstract class ToyFactory {
    public abstract Toy createToy();
}

class TeddyBearFactory implements ToyFactory {
    @Override
    public Toy createToy() {
        return new TeddyBear("棕色", "柔软绒毛");
    }
}

class PlasticDinosaurFactory implements ToyFactory {
    @Override
    public Toy createToy() {
        return new PlasticDinosaur("绿色", "硬塑料");
    }
}

class BuildingBlockCastleFactory implements ToyFactory {
    @Override
    public Toy createToy() {
        return new BuildingBlockCastle("彩色", "木质积木");
    }
}

2. 玩具店灵活 "进货" 与 "售卖"
   玩具店根据需求找不同工坊 "进货"，售卖流程更灵活：

public class ToyShop {
    public static void sellToy(ToyFactory factory) {
        Toy toy = factory.createToy();
        if (toy!= null) {
            toy.show();
        } else {
            System.out.println("暂无此款玩具库存！");
        }
    }

    public static void main(String[] args) {
        sellToy(new TeddyBearFactory());
    }
}

这样，新增玩具类型，对应加个具体工厂子类就行，代码扩展性蹭蹭涨，像给玩具店安上了 "扩张魔法"。

三、抽象工厂模式：高级 "魔法联盟工坊" 的协同作战

抽象工厂模式更厉害，像组建了个 "魔法联盟工坊"，能批量产出相关联的 "玩具套装"。

假设咱现在有 "动物主题套装" 和 "城堡主题套装"，每套里有不同玩具，得配套生产。

1. 细化产品族与抽象工厂接口
   先把玩具按主题分成不同 "家族"，像 "动物玩具家族" 有接口，"城堡玩具家族" 也有接口：

interface AnimalToy {
    void play();
}

interface CastleToy {
    void build();
}

再定个超抽象的工厂接口，规定要能造不同家族玩具：

abstract class AbstractToyFactory {
    public abstract AnimalToy createAnimalToy();
    public abstract CastleToy createCastleToy();
}

2. 打造具体工厂与产品实现类
   针对主题，建具体工厂，里面实现造对应家族玩具方法：

class AnimalThemeToyFactory implements AbstractToyFactory {
    @Override
    public AnimalToy createAnimalToy() {
        return new TeddyBear("棕色", "柔软绒毛");
    }

    @Override
    public CastleToy createCastleToy() {
        return new BuildingBlockCastle("彩色", "木质积木");
    }
}

class CastleThemeToyFactory implements AbstractToyFactory {
    @Override
    public AnimalToy createAnimalToy() {
        return new PlasticDinosaur("绿色", "硬塑料");
    }

    @Override
    public CastleToy createCastleToy() {
        return new BuildingBlockCastle("彩色", "木质积木");
    }
}

产品类按接口实现具体玩法或搭建逻辑：

class TeddyBear implements AnimalToy {
    //...省略构造函数等，同前
    @Override
    public void play() {
        System.out.println("抱着毛绒小熊玩耍啦！");
    }
}

class BuildingBlockCastle implements CastleToy {
    //...省略构造函数等，同前
    @Override
    public void build() {
        System.out.println("搭建积木城堡咯！");
    }
}

class PlasticDinosaur implements AnimalToy {
    //...省略构造函数等，同前
    @Override
    public void play() {
        System.out.println("摆弄塑料恐龙咯！");
    }
}

3. 玩具店 "豪华售卖" 场景
   玩具店拿到工厂，产出完整主题套装售卖，高大上得很：

public class ToyShop {
    public static void sellToySet(AbstractToyFactory factory) {
        AnimalToy animalToy = factory.createAnimalToy();
        CastleToy castleToy = factory.createCastleToy();
        animalToy.play();
        castleToy.build();
    }

    public static void main(String[] args) {
        sellToySet(new AnimalThemeToyFactory());
    }
}

抽象工厂模式让代码像个精密 "魔法联盟"，按主题批量生产、配套售卖，管理有序，应对复杂业务轻松自如，在 Java 编程这片 "魔法大陆" 上，开启高效、灵活的对象创建 "奇幻之旅"。