设计模式专题（一）工厂模式

绝地灬酷狼 2023-02-21 12:25 86阅读 0赞

**目录**

工厂模式

简单工厂模式

工厂方法模式

抽象工厂模式

# 工厂模式 #

为了便于理解，这里做一个小案例：

1、首先制造一个牛奶类：

public interface Milk {
    
        /**
         * 获取一个标准产品
         * @return
         */
        public String getName();
    
    }

2、然后制造很多的具体牛奶类，实现这个接口：

蒙牛类：

public class Mengniu implements Milk {
    
        public String getName() {
            return "蒙牛";
        }
    }

特仑苏类：

public class Telunsu implements Milk {
    
        public String getName() {
            return "特仑苏";
        }
    }

伊利类：

public class Yili implements  Milk {
    
        public String getName() {
            return "伊利";
        }
    }

## 简单工厂模式 ##

**含义：**

*  简单工厂模式（Simple Factory Pattern）是指由一个工厂对象决定创建出哪一种产品类的实例。

**适用场景：**

*  工厂类负责创建的对象较少。
 *  客户端只需要传入工厂类的参数，对于如何创建对象的逻辑不需要关心。

**优点：**

*  只需传入一个正确的参数，就可以获取你所需要的对象无须知道其创建的细节。

**缺点 ：**

*  工厂类的职责相对过重，增加新的产品时需要修改工厂类的判断逻辑，违背开闭原则。
 *  不易于扩展过于复杂的产品结构。

1、创建一个简单工厂

public class SimpleFactory {
        public Milk getMilk(String name){
            if("特仑苏".equals(name)){
                return new Telunsu();
            }else if("伊利".equals(name)){
                return new Yili();
            }else if("蒙牛".equals(name)){
                return new Mengniu();
            }else {
                System.out.println("不能生产您所需的产品");
                return null;
            }
        }
    }

2、测试简单工厂模式

public static void main(String[] args) {
        
            //这个new的过程实际上一个比较复杂的过程
            //有人民币及不需要自己new了
            System.out.println(new Telunsu().getName());
    
            //小作坊式的生产模式
            //用户本身不再关心生产的过程，而只需要关心这个结果
            //假如：特仑苏、伊利、蒙牛
            //成分配比都是不一样的
            SimpleFactory factory = new SimpleFactory();
    
            //把用户的需求告诉工厂
            //创建产品的过程隐藏了，对于用户而且完全不清楚是怎么产生的
            System.out.println(factory.getMilk("特仑苏").getName());
        }

## 工厂方法模式 ##

**含义：**

*  工厂方法模式（Fatory Method Pattern）是指定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行。主要解决产品扩展的问题。

**适用场景：**

*  创建对象需要大量重复的代码。
 *  客户端（应用层）不依赖于产品类实例如何被创建、实现等细节。
 *  一个类通过其子类来指定创建哪个对象。

**优点：**

*  用户只需关心所需产品对应的工厂，无须关心创建细节。
 *  加入新产品符合开闭原则，提高了系统的可扩展性。

**缺点 ：**

*  类的个数容易过多，增加了代码结构的复杂度。
 *  增加了系统的抽象性和理解难度。

1、创建工厂

public interface Factory {
    
        //工厂必然具有生产产品技能，统一的产品出口
        Milk getMilk();
    
    }

2、创建工厂实现类

public class MengniuFactory implements  Factory {
        public Milk getMilk() {
            return new Mengniu();
        }
    }

public class TelunsuFactory implements Factory {
        public Milk getMilk() {
            return new Telunsu();
        }
    }

public class YiliFactory implements Factory {
        public Milk getMilk() {
            return new Yili();
        }
    }

3、测试工厂方法模式

public static void main(String[] args) {
            //System.out.println(new Factory().getMilk(););
            //货比三家
            //不知道谁好谁好谁坏
            //配置，可能会配置错
            Factory factory = new SanluFactory();
            System.out.println(factory.getMilk());
        }

## 抽象工厂模式 ##

**含义：**

*  抽象工厂模式（Abastract Factory Pattern）是指提供一个创建一系列相关或相互依赖对象的接口，无须指定他们具体的类。
 *  客户端（应用层）不依赖于产品类实例如何被创建、实现等细节，强调的是一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量重复的代码。需要提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。

**适用场景：**

*  客户端（应用层）不依赖于产品类实例如何被创建、实现等细节。
 *  强调一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量重复的代码。
 *  提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。

**优点：**

*  具体产品在应用层代码隔离，无须关心创建细节
 *  将一个系列的产品族统一到一起创建。

**缺点 ：**

*  规定了所有可能被创建的产品集合，产品族中扩展新的产品困难，需要修改抽象工厂的接口。
 *  增加了系统的抽象性和理解难度。

1、创建抽象工厂

public abstract class AbstractFactory {
    
        //公共的逻辑
        //方便于统一管理
    
        /**
         * 获得一个蒙牛品牌的牛奶
         * @return
         */
        public  abstract Milk getMengniu();
    
        /**
         * 获得一个伊利品牌的牛奶
         * @return
         */
        public abstract  Milk getYili();
    
        /**
         * 获得一个特仑苏品牌的牛奶
         * @return
         */
        public  abstract  Milk getTelunsu();
    
    }

2、创建抽象工厂实现类

public class MilkFactory extends  AbstractFactory {
    
        @Override
        public Milk getMengniu() {
            return new Mengniu();
        }
        
        @Override
        public Milk getYili() {
            return new Yili();
        }
        
        @Override
        public Milk getTelunsu() {
            return new Telunsu();
        }
    }

3、测试抽象工厂模式

public static void main(String[] args) {
    
            MilkFactory factory = new MilkFactory();
            //对于用户而言，更加简单了
            //用户只有选择的权利了，保证了程序的健壮性
            System.out.println(factory.getMengniu());
        }