【设计模式】创建者模式之工厂模式

工厂方法模式

定义一个用于创建对象的接口，让子类决定实例化哪个产品类对象。工厂方法使一个产品类的实例化延迟到其工厂的子类

结构

• 抽象工厂：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法来创建对象
• 具体工厂：实现抽象工厂里的抽象方法，完成具体产品的创建
• 抽象产品：定义了产品的规范，描述了产品的主要特性和功能
• 具体产品：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应

实现

通过咖啡店进行点单，创建咖啡的抽象工厂，有多少种咖啡就实现多少个咖啡工厂。利用多态性避免了咖啡店的修改（开闭原则）

优点：

• 用户只需要知道具体工厂的名称就能得到具体产品，无需知道产品的创建过程。
• 需要增加新的产品时，只需要添加相应的工厂，无需对原工厂进行修改。符合开闭原则

缺点

• 多个产品就需要创建多个具体工厂。增加了系统的复杂性

public abstract class Coffee {

    public abstract String getName();

    public void addsugar(){
        System.out.println("加糖");
    }

    public void addMilk(){
        System.out.println("加奶");
    }
}

public class MeishiCoffee extends Coffee {
    @Override
    public String getName() {

        System.out.println("美式");
        return "美式咖啡";
    }
}

public class NatieCoffee extends Coffee {
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}

/**
 * 抽象工厂
 */
public interface CoffeeFactory {

    Coffee createCoffee();
}

/**
 * 美式咖啡工厂对象，生成美式咖啡
 */
public class MeishiFactory implements CoffeeFactory{
    @Override
    public Coffee createCoffee() {
        return new MeishiCoffee();
    }
}

public class NatieFactory implements CoffeeFactory{
    @Override
    public Coffee createCoffee() {
        return new NatieCoffee();
    }
}

public class CoffeeStore {

    private CoffeeFactory factory;

    public void setFactory(CoffeeFactory factory) {
        this.factory = factory;
    }

    // 点咖啡功能
    public Coffee orderCoffee(){
        Coffee coffee = factory.createCoffee();
        coffee.addMilk();
        coffee.addsugar();
        return coffee;
    }
}

public class Client {
    public static void main(String[] args) {
        CoffeeStore store = new CoffeeStore();
        store.setFactory(new MeishiFactory());
        Coffee c = store.orderCoffee();
        System.out.println(c.getName());
    }
}

抽象工厂模式

多等级产品的生产，将同一个具体工厂所产生的位于不同等级的一组产品称为一个产品族

public abstract class Coffee {

    public abstract String getName();

    public void addsugar(){
        System.out.println("加糖");
    }

    public void addMilk(){
        System.out.println("加奶");
    }
}

/**
 * 甜品抽象类
 */
public abstract class Dessert {

    public abstract void show();
}


public class MeishiCoffee extends Coffee{
    @Override
    public String getName() {
        return "美式咖啡";
    }
}


public class NatieCoffee extends Coffee{
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}


public class Mocms extends Dessert{
    @Override
    public void show() {
        System.out.println("抹茶慕斯");
    }
}


/**
 * 提拉米苏类
 */
public class Tilamisu extends Dessert{
    @Override
    public void show() {
        System.out.println("提拉米苏");
    }
}


/**
 * 甜品抽象工厂
 */
public interface DessertFactory {

    // 生成咖啡的功能
    Coffee createCoffee();

    // 生成甜品的功能
    Dessert createDessert();

}


/**
 * 意大利风味工厂 生成拿铁 提拉米苏
 */
public class ItalyDessertFactory implements DessertFactory{
    @Override
    public Coffee createCoffee() {
        return new NatieCoffee();
    }

    @Override
    public Dessert createDessert() {
        return new Tilamisu();
    }
}


/**
 * 美式风味的甜品工厂，生成美式咖啡和抹茶慕斯
 */
public class MeishiDessertFactory implements DessertFactory{
    @Override
    public Coffee createCoffee() {
        return new MeishiCoffee();
    }

    @Override
    public Dessert createDessert() {
        return new Mocms();
    }
}


public class Client {
    public static void main(String[] args) {
        // 创建意大利风味甜品工厂
        ItalyDessertFactory italyDessertFactory = new ItalyDessertFactory();
//        MeishiDessertFactory meishiDessertFactory = new MeishiDessertFactory();
        Dessert dessert = italyDessertFactory.createDessert();
        Coffee coffee = italyDessertFactory.createCoffee();
        System.out.println(coffee.getName());
        dessert.show();
    }
}