Factory mode of design mode (creative type, producing brand products with up to standard quality)

Simple Factory Pattern (not one of the 23 classic design patterns)

Scenario: We know that there are many brands of beer, such as Tsingtao, Snow, Budweiser, and then there will be many beer production plants. If a beer production plant can produce Tsingtao, Snow, and Budweiser beer at the same time, then this is a simple factory model. Is not it simple?
Code:
First, beer must exist, and then beer is divided into Tsingtao beer, Snow beer, and Budweiser beer.
1. First describe the beer:

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

2. Describe Tsingtao Brewery:

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

3. Description of Snow Beer:

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

4. Describe Budweiser:

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

5. Describe a factory that produces beer:

/**
 * 有个工厂，可以同时生产青岛、雪花、百威啤酒
 */
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. Consumer Zhang San needs to buy beer:

/**
 * 张三需要买啤酒
 */
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.一个工厂同时生产好几个品牌的啤酒，质量是不能保证
    }
}

Factory Method Pattern

Scenario: We know that there are many brands of beer, such as Tsingtao, Snow, Budweiser, and then there will be many beer production plants, Tsingtao Brewery specializes in Tsingtao Beer, Snow Brewery specializes in Snow Beer, and Budweiser Brewery specializes in Budweiser beer , this is the factory method pattern, simple or not?
Code:
First, there must be a brewery, and then the brewery is divided into Tsingtao Brewery, Snow Brewery, and Budweiser Brewery.
1. First describe the brewery:

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

2. Describe Tsingtao Brewery:

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

3. Describe the Snow Brewery:

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

4. Describe the Budweiser Brewery:

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

5. Consumer Zhang San needs to buy beer:

/**
 * 张三需要买啤酒
 */
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.啤酒生产厂更符合国家标准，一个厂只生产一种品牌的啤酒
    }
}

Abstract Factory Pattern

Scenario: We know that there are many brands of beer, such as Tsingtao, Snowflake, Budweiser, and then there will be many beer production plants. For consumers, the beer production plants are far away from us (very abstract), and it is impossible for us to buy 2 bottles. We go to the production factory specially for beer. We usually go to the convenience store to buy the beer we want. This is the abstract factory model. Is it the closest to our life?
Code:
Since the production plant is far away from us, we only need to know that there is such a production plant, and then the convenience store will go to the factory to stock up.
1. First describe an abstract brewery, which can represent any brand of brewery:

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

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

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

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

2. Describe a convenience store:

/**
 * 这个啤酒厂类似便利店，专门从各大啤酒生产厂进货
 */
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. Consumer Zhang San needs to buy beer:

/**
 * 张三需要买啤酒
 */
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.下次张三再去便利店买啤酒的时候，可能又多出了几款啤酒品牌（可扩展性）
    }
}

Summary: The simple factory pattern has the least application. Usually, the factory method pattern is used in combination with the abstract factory pattern. The abstract factory pattern is the most widely used in spring and conforms to the principle of opening and closing: open for extension and close for modification.