设计模式-工厂模式

工厂模式

用于创建复杂对象，不暴露对象创建过程得一种设计模式

案例

假设我们现在开一家包子铺，包子铺里面卖豆沙包和豆腐包

// 定义一个包子接口
public interface BaoZi {
    public void makeBaoZi();
}

public class DouFuBao implements BaoZi{
    @Override
    public void makeBaoZi() {
        System.out.println("豆腐包");
    }
}

public class DouShaBao implements BaoZi{
    @Override
    public void makeBaoZi() {
        System.out.println("豆沙包");
    }
}

包子店售卖包子

public class BaoziDian {
    /**
     * 销售包子
     * @param name
     */
    public BaoZi saleBaoZi(String name){
        BaoZi baoZi = null;
        if(name.equals("dousha")){
            baoZi = new DouShaBao();
        }else if(name.equals("doufu")){
            baoZi = new DouFuBao();
        }
        if(baoZi != null) baoZi.makeBaoZi();
        return baoZi;
    }
}

// 我们销售时 需要包子店自己做

过了一段时间，自己做包子实在时太累了，决定找一个加工厂，这个加工厂里面就能生产这两种包子，我们只需要负责销售，其他生产过程不需要参与

简单工厂模式

定义一个包子工厂类

public class BaoZiFactory {
    public BaoZi create(String name){
        BaoZi baoZi = null;
        if(name.equals("dousha")){
            baoZi = new DouShaBao();
        }else if(name.equals("doufu")){
            baoZi = new DouFuBao();
        }
        if(baoZi != null) baoZi.makeBaoZi();
        return baoZi;
    }
}

包子店只需要从工厂里面进货即可

public class BaoziDian {
    /**
     * 销售包子
     * @param name
     */
    public BaoZi saleBaoZi(String name){
        BaoZiFactory baoZiFactory = new BaoZiFactory();
        return baoZiFactory.create(name);
    }

    public static void main(String[] args) {
        BaoziDian baoziDian = new BaoziDian();
        baoziDian.saleBaoZi("dousha");
    }
}

// 又过了一段时间，包子厂改革（抽象成一个接口），A 地的豆沙好，那么在A 地创建一个分厂 只生产豆沙包，B 地 豆腐好 ，只在B地 生产豆腐包。

工厂方法模式

我们需要从 A 和 B工厂 分别拿货，没办法为了挑剔的食客。此时 如果我们需要新增加包子的类别，只需要再找一个 负责生产新品种的工厂就可以了

public interface IBaoZiFactory {
    public BaoZi create();
}

public class DouShaBaoZiFactory implements IBaoZiFactory{
    @Override
    public BaoZi create() {
        return new DouShaBao();
    }
}

public class DouFuBaoZiFactory implements IBaoZiFactory{
    @Override
    public BaoZi create() {
        return new DouFuBao();
    }
}

抽象工厂模式

public class ABaoZi implements BaoZi{

    @Override
    public void makeBaoZi() {
        System.out.println("A 包子");
    }
}

public class AShaoBing implements ShaoBing{
    @Override
    public void makeShaoBing() {
        System.out.println("A ShaoBing");
    }
}

public interface IZaoCanFactory {
    BaoZi createBaoZi();
    ShaoBing createShaoBing();
}

public class AZaoCanFactory implements IZaoCanFactory{
    @Override
    public BaoZi createBaoZi() {
        return new ABaoZi();
    }

    @Override
    public ShaoBing createShaoBing() {
        return new AShaoBing();
    }
}

public static void main(String[] args) {
        IZaoCanFactory iZaoCanFactory = new AZaoCanFactory();
        iZaoCanFactory.createBaoZi().makeBaoZi();
        iZaoCanFactory.createShaoBing().makeShaoBing();
    }