设计模式之工厂模式（创建型，生产质量达标的品牌产品）

简单工厂模式（不属于23种经典设计模式之一）

场景：我们知道啤酒有很多品牌，例如青岛、雪花、百威，然后会有很多啤酒生产厂，如果一个啤酒生产厂里可以同时生产青岛、雪花、百威啤酒，那么这就是简单工厂模式了，是不是很简单？
代码：
首先得有啤酒这一个东西存在，然后啤酒又分为青岛啤酒、雪花啤酒、百威啤酒。
1.先描述出啤酒这一个东西：

/**
 * 啤酒应该为一个统称，因为它有很多品牌的啤酒
 */
public interface Beer {
    public String getName();
}

2.描述青岛啤酒：

/**
 * 青岛啤酒为啤酒的一个品牌
 */
public class QinDaoBeer implements Beer {
    @Override
    public String getName() {
        return "青岛啤酒";
    }
}

3.描述雪花啤酒：

/**
 * 雪花啤酒为啤酒的一个品牌
 */
public class XueHuaBeer implements Beer {
    @Override
    public String getName() {
        return "雪花啤酒";
    }
}

4.描述百威啤酒：

public class BaiWeiBeer implements Beer {
    @Override
    public String getName() {
        return "百威啤酒";
    }
}

5.描述一个生产啤酒的工厂：

/**
 * 有个工厂，可以同时生产青岛、雪花、百威啤酒
 */
public class SimpleFactory {
    /**
     * 工厂里生产啤酒的方法
     * @param name
     * @return
     */
    public Beer getBeer(String name){
        if(name.equals("青岛啤酒")){
            return new QinDaoBeer();
        }else if(name.equals("雪花啤酒")){
            return new XueHuaBeer();
        }else if(name.equals("百威啤酒")){
            return new BaiWeiBeer();
        }else{
            System.out.println("工厂里没有生产这款啤酒");
            return null;
        }
    }
}

6.消费者张三需要去购买啤酒：

/**
 * 张三需要买啤酒
 */
public class SimpleFactoryUser {
    public static void main(String[] args) {
        //1.张三先去这个啤酒生产厂
        SimpleFactory simpleFactory=new SimpleFactory();
        //2.张三说：我要买青岛啤酒
        System.out.println(simpleFactory.getBeer("青岛啤酒"));
        //3.张三又说：我要买雪花啤酒
        System.out.println(simpleFactory.getBeer("雪花啤酒"));
        //4.张三还说：我要买黑啤
        System.out.println(simpleFactory.getBeer("黑啤"));

        //执行结果：
        //com.taofut.sjms2.factory.QinDaoBeer@1b6d3586
        //com.taofut.sjms2.factory.XueHuaBeer@4554617c
        //工厂里没有生产这款啤酒
        //null

        //特点：1.啤酒不用自己去生产，消费者只需要拿钱去啤酒生产厂买
        //     2.用户自己说要购买某个品牌的啤酒，可能该啤酒工厂里是没有的
        //     3.一个工厂同时生产好几个品牌的啤酒，质量是不能保证
    }
}

工厂方法模式

场景：我们知道啤酒有很多品牌，例如青岛、雪花、百威，然后会有很多啤酒生产厂，青岛啤酒厂专门生产青岛啤酒，雪花啤酒厂专门生产雪花啤酒，百威啤酒厂专门生产百威啤酒，这就是工厂方法模式，简单否？
代码：
首先得有啤酒厂这一个东西存在，然后啤酒工厂又分为青岛啤酒厂、雪花啤酒厂、百威啤酒厂。
1.先描述出啤酒厂这一个东西：

/**
 * 啤酒工厂是一类统称，它可以有青岛啤酒厂、雪花啤酒厂、百威啤酒厂
 */
public interface BeerFactory {
    Beer getBeer();
}

2.描述出青岛啤酒厂：

/**
 * 专门生产青岛啤酒的工厂
 */
public class QinDaoBeerFactory implements BeerFactory{
    /**
     * 生产青岛啤酒的方法
     * @return
     */
    @Override
    public Beer getBeer() {
        return new QinDaoBeer();
    }
}

3.描述出雪花啤酒厂：

/**
 * 专门生产雪花啤酒的工厂
 */
public class XueHuaBeerFactory implements BeerFactory{
    /**
     * 生产雪花啤酒的方法
     * @return
     */
    @Override
    public Beer getBeer() {
        return new XueHuaBeer();
    }
}

4.描述出百威啤酒厂：

/**
 * 专门生产百威啤酒的工厂
 */
public class BaiWeiBeerFactory implements BeerFactory{
    /**
     * 生产百威啤酒的方法
     * @return
     */
    @Override
    public Beer getBeer() {
        return new BaiWeiBeer();
    }
}

5..消费者张三需要去购买啤酒：

/**
 * 张三需要买啤酒
 */
public class BeerFactoryUser {
    public static void main(String[] args) {
        //1.张三想去买青岛啤酒，于是他去了青岛啤酒生产厂
        QinDaoBeerFactory qinDaoBeerFactory=new QinDaoBeerFactory();
        //他买了青岛啤酒
        System.out.println(qinDaoBeerFactory.getBeer());
        //2.张三想去买雪花啤酒，于是他去了雪花啤酒生产厂
        XueHuaBeerFactory xueHuaBeerFactory=new XueHuaBeerFactory();
        //他买了雪花啤酒
        System.out.println(xueHuaBeerFactory.getBeer());
        //3.张三想去买百威啤酒，于是他去了百威啤酒生产厂
        BaiWeiBeerFactory baiWeiBeerFactory=new BaiWeiBeerFactory();
        //他买了百威啤酒
        System.out.println(baiWeiBeerFactory.getBeer());

        //执行结果：
        //com.taofut.sjms2.factory.QinDaoBeer@1b6d3586
        //com.taofut.sjms2.factory.XueHuaBeer@4554617c
        //com.taofut.sjms2.factory.BaiWeiBeer@74a14482

        //特点：1.张三买啤酒的时候会货比三家，思考到底去哪一个厂买啤酒
        //     2.啤酒生产厂更符合国家标准，一个厂只生产一种品牌的啤酒
    }
}

抽象工厂模式

场景：我们知道啤酒有很多品牌，例如青岛、雪花、百威，然后会有很多啤酒生产厂，对于消费者来说，啤酒生产厂离我们很遥远（很抽象），我们不可能为了买2瓶啤酒而特地跑去生产厂，我们通常都是去便利店里选购自己想要的啤酒，这就是抽象工厂模式，是不是最为贴近我们的生活？
代码：
既然生产厂离我们很遥远，那我们只需要知道有这么一个生产厂存在就行，然后便利店会去工厂里进货。
1.先描述出一个抽象的啤酒厂，它可以表示任意品牌的啤酒厂：

/**
 * 抽象工厂作为工厂的一类统称（虚拟想象的工厂，可以获得各种啤酒）
 */
public abstract class AbstractBeerFactory {

    /**
     * 工厂想生产一个青岛品牌的啤酒
     * @return
     */
    public abstract Beer getQinDaoBeer();

    /**
     * 工厂想生产一个雪花品牌的啤酒
     * @return
     */
    public abstract Beer getXueHuaBeer();

    /**
     * 工厂想生产一个百威品牌的啤酒
     * @return
     */
    public abstract Beer getBaiWeiBeer();
}

2.描述出一个便利店：

/**
 * 这个啤酒厂类似便利店，专门从各大啤酒生产厂进货
 */
public class BeerFactory extends AbstractBeerFactory {
    /**
     * 便利店里的青岛啤酒
     * @return
     */
    @Override
    public Beer getQinDaoBeer() {
        return new QinDaoBeer();
    }

    /**
     * 便利店里的雪花啤酒
     * @return
     */
    @Override
    public Beer getXueHuaBeer() {
        return new XueHuaBeer();
    }

    /**
     * 便利店里的百威啤酒
     * @return
     */
    @Override
    public Beer getBaiWeiBeer() {
        return new BaiWeiBeer();
    }
}

3.消费者张三需要去购买啤酒：

/**
 * 张三需要买啤酒
 */
public class AbstractBeerFactoryUser {
    public static void main(String[] args) {
        //1.张三直接去便利店购买啤酒
        BeerFactory beerFactory=new BeerFactory();
        //2.张三看到便利店里有好几款啤酒，然后他得选自己喜欢的啤酒购买
        //最终张三选择购买青岛啤酒
        System.out.println(beerFactory.getQinDaoBeer());

        //执行结果：
        //com.taofut.sjms2.factory.QinDaoBeer@1b6d3586

        //特点：1.啤酒生产厂在哪里不需要再关心了、张三不需要再去工厂购买啤酒，而是直接去便利店里买（不需要关心产品生产地以及如何生产）
        //     2.下次张三再去便利店买啤酒的时候，可能又多出了几款啤酒品牌（可扩展性）
    }
}

总结：简单工厂模式的应用最少，通常都是工厂方法模式跟抽象工厂模式结合使用，抽象工厂模式在spring中应用最为广泛，符合开闭原则：扩展开放、修改关闭。