抽象工厂模式【构建模式】

抽象工厂类

Provide an interface for creating families of related or dependent objects without
specifying their concreate class.
提供一个接口来创建一系列相关的或独立的对象，而不需要指定他们的具体类。

public class AbstractFactory {

    /**
     * 抽象工厂模式：
     * Provide an interface for creating families of related or dependent objects without
     * specifying their concreate class.
     * 提供一个接口来创建一系列相关的或独立的对象，而不需要指定他们的具体类。
     */
    @Test
    public void all() {
        Composite composite = Composite.create(ElfKingdomFactory.get());
        assertEquals("ElfKing ElfCastle ElfArmy", composite.show());

        composite = Composite.create(OrcKingdomFactory.get());
        assertEquals("OrcKing OrcCastle OrcArmy", composite.show());
    }
}

interface Army {
    String desc();
}

interface Castle {
    String desc();
}

interface King {
    String desc();
}

interface KingdomFactory {
    Army createArmy();

    Castle createCastle();

    King createKing();
}

class ElfArmy implements Army {
    @Override
    public String desc() {
        return "ElfArmy";
    }
}

class ElfCastle implements Castle {
    @Override
    public String desc() {
        return "ElfCastle";
    }
}

class ElfKing implements King {
    @Override
    public String desc() {
        return "ElfKing";
    }
}

class ElfKingdomFactory implements KingdomFactory {
    private static final KingdomFactory FACTORY = new ElfKingdomFactory();

    private ElfKingdomFactory() {
    }

    public static final KingdomFactory get() {
        return FACTORY;
    }

    @Override
    public Army createArmy() {
        return new ElfArmy();
    }

    @Override
    public Castle createCastle() {
        return new ElfCastle();
    }

    @Override
    public King createKing() {
        return new ElfKing();
    }
}

@Builder
@Getter
class Composite {
    private final King king;
    private final Castle castle;
    private final Army army;

    public static final Composite create(KingdomFactory factory) {
        return Composite.builder()
                .king(factory.createKing())
                .castle(factory.createCastle())
                .army(factory.createArmy())
                .build();
    }

    public String show() {
        return String.join(" ", king.desc(), castle.desc(), army.desc());
    }
}

// 新增一个产品族
class OrcArmy implements Army {
    @Override
    public String desc() {
        return "OrcArmy";
    }
}

class OrcCastle implements Castle {
    @Override
    public String desc() {
        return "OrcCastle";
    }
}

class OrcKing implements King {
    @Override
    public String desc() {
        return "OrcKing";
    }
}

class OrcKingdomFactory implements KingdomFactory {
    private static OrcKingdomFactory FACTORY = new OrcKingdomFactory();

    private OrcKingdomFactory() {
    }

    public static final OrcKingdomFactory get() {
        return FACTORY;
    }

    @Override
    public Army createArmy() {
        return new OrcArmy();
    }

    @Override
    public Castle createCastle() {
        return new OrcCastle();
    }

    @Override
    public King createKing() {
        return new OrcKing();
    }
}