工厂模式

时间：2020-05-24 19:27:33 阅读：59 评论：0 收藏：0 [点我收藏+]

一、工厂模式：

　　工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，以达到提高灵活性。工厂模式分为三种：

　　1、简单工厂模式：创建几个产品抽象类，然后创建一个简单工厂类，最后调用。

　　栗子：

　　步骤一：创建产品抽象类。（我喜欢看电视，所以我要先创建一个具体的电视节目抽象类。）　

// 描述小说的书单
public abstract class AllNovel {
   public abstract void mynovel();
}

// 具体产品类:魔道祖师
public class MdNovel extends AllNovel {
    @Override
    public void mynovel() {
        System.out.println("蓝忘机&魏无羡");
    }
}

// 具体产品类:天官赐福
public class TgNovel extends AllNovel {
    @Override
    public void mynovel() {
        System.out.println("谢怜&花城");
    }
}

// 具体产品类:破云
public class PyNovel extends AllNovel {
    @Override
    public void mynovel() {
        System.out.println("严峫&江停");
    }
}

// 具体产品类:伪装学渣
public class VzNovel extends AllNovel {
    @Override
    public void mynovel() {
        System.out.println("贺朝&谢俞");
    }
}

　　步骤二：创建简单工厂类。（来到‘晋江文学城’，书单如下：）

public class SimpleNovelFactory {
    public static final int TYPE_MD = 1;//魔道祖师
    public static final int TYPE_TG = 2;//天官赐福
    public static final int TYPE_PY = 3;//破云
    public static final int TYPE_WZ = 4;//伪装学渣

    public static AllNovel createNovel(int type) {
        switch (type) {
            case TYPE_MD:
                return new MdNovel();
            case TYPE_TG:
                return new TgNovel();
            case TYPE_PY:
                return new PyNovel();
            case TYPE_PY:    
            default:
                return new VzNovel();
        }
    }
}

　　步骤三：调用。（我想看那部小说，就选择哪部。）

AllNovel an =SimpleNovelFactory.createNovel(SimpleNovelFactory.TYPE_WZ);
an.mynovel();

注意：它是一个具体的类，非接口抽象类。有一个重要的create()方法，利用if或者 switch创建产品并返回。

　　 create()方法通常是静态的，所以也称之为静态工厂。

缺点：

1、扩展性差（我想增加一本小说，除了新增一个小说产品类，还需要修改工厂类方法）

2、不同的产品需要不同额外参数的时候不支持。

　　2、工厂方法模式：提供一个用于创建对象的接口(工厂接口)，让其实现类(工厂实现类)决定实例化哪一个类(产品类)，并且由该实现类创建对应类的实例。

　　栗子：

　　步骤一：提供一个用于创建对象的工厂借口。

package com.demoFound.factoryMethod.factory;  
import com.demoFound.factoryMethod.message.IMyMessage;  
  
// 工厂方法模式_工厂接口 
public interface IMyMessageFactory {  
  
    public IMyMessage createMessage(String messageType);  
}

　　步骤二：工厂实现类。

package com.demoFound.factoryMethod.factory;  
  
import java.util.HashMap;  
import java.util.Map;  
  
import com.demoFound.factoryMethod.message.IMyMessage;  
import com.demoFound.factoryMethod.message.MyMessageEmail;  
import com.demoFound.factoryMethod.message.MyMessageOaTodo;  
import com.demoFound.factoryMethod.message.MyMessageSms;  

// 工厂方法模式_工厂实现 
public class MyMessageFactory implements IMyMessageFactory {  
  
    @Override  
    public IMyMessage createMessage(String messageType) {  
        // 这里的方式是：消费者知道自己想要什么产品；若生产何种产品完全由工厂决定，则这里不应该传入控制生产的参数。  
        IMyMessage myMessage;  
        Map<String, Object> messageParam = new HashMap<String, Object>();  
        // 根据某些条件去选择究竟创建哪一个具体的实现对象，条件可以传入的，也可以从其它途径获取。  
          
        if ("SMS".equals(messageType)) {  // sms
            myMessage = new MyMessageSms();  
            messageParam.put("PHONENUM", "123456789");  
        }   
                   
        if ("OA".equals(messageType)) {   // OA待办
            myMessage = new MyMessageOaTodo();  
            messageParam.put("OAUSERNAME", "testUser");  
        }  
         
        if ("EMAIL".equals(messageType)) {  // email 
            myMessage = new MyMessageEmail();  
            messageParam.put("EMAIL", "test@test.com");  
        } 
        else  // 默认生产email这个产品  
        {  
            myMessage = new MyMessageEmail();  
            messageParam.put("EMAIL", "test@test.com");  
        }  
        
        myMessage.setMessageParam(messageParam);  
        return myMessage;  
    }  
}

　　步骤三：创建具体产品类。

　　　　创建产品接口：　　　　

import java.util.Map;  

// 工厂方法模式_产品接口
public interface IMyMessage {  
  
    public Map<String, Object> getMessageParam();  
  
    public void setMessageParam(Map<String, Object> messageParam);  
  
    public void sendMesage() throws Exception;// 发送通知/消息  
  
}

　　虚拟产品类：

// 工厂方法模式_虚拟产品类 
package com.demoFound.factoryMethod.message;  
  
import java.util.Map;  
 
public abstract class MyAbstractMessage implements IMyMessage {  
  
    private Map<String, Object> messageParam;  
  
    @Override  
    public Map<String, Object> getMessageParam() {  
        return messageParam;  
    }  
  
    @Override  
    public void setMessageParam(Map<String, Object> messageParam) {  
        this.messageParam = messageParam;  
    }  
}

　　具体产品类：

//工厂方法模式_email产品
package com.demoFound.factoryMethod.message;  
 
public class MyMessageEmail extends MyAbstractMessage {  
  
    @Override  
    public void sendMesage() throws Exception {   
        if (null == getMessageParam() || null == getMessageParam().get("EMAIL")  
                || "".equals(getMessageParam().get("EMAIL"))) {  
            throw new Exception("发送短信,需要传入EMAIL参数");
        }  
  
        System.out.println("我是邮件，发送通知给" + getMessageParam().get("EMAIL"));  
    }  
  
}

// 工厂方法模式_oa待办产品
package com.demoFound.factoryMethod.message;  
  
public class MyMessageOaTodo extends MyAbstractMessage {  
  
    @Override  
    public void sendMesage() throws Exception {   
        if (null == getMessageParam()  
                || null == getMessageParam().get("OAUSERNAME")  
                || "".equals(getMessageParam().get("OAUSERNAME"))) {  
            throw new Exception("发送OA待办,需要传入OAUSERNAME参数");
        } 
  
        System.out  
                .println("我是OA待办，发送通知给" + getMessageParam().get("OAUSERNAME"));  
    }  
}

// 工厂方法模式_sms产品
package com.demoFound.factoryMethod.message;  
   
public class MyMessageSms extends MyAbstractMessage {  
  
    @Override  
    public void sendMesage() throws Exception {  
  
        if (null == getMessageParam()  
                || null == getMessageParam().get("PHONENUM")  
                || "".equals(getMessageParam().get("PHONENUM"))) {  
            throw new Exception("发送短信,需要传入PHONENUM参数");
        }
        System.out.println("我是短信，发送通知给" + getMessageParam().get("PHONENUM"));  
    }    
}

　　主函数：

// 工厂方法模式_消费者类
package com.demoFound.factoryMethod;  
  
import com.demoFound.factoryMethod.factory.IMyMessageFactory;  
import com.demoFound.factoryMethod.factory.MyMessageFactory;  
import com.demoFound.factoryMethod.message.IMyMessage;  
   
public class MyFactoryMethodMain {  
  
    public static void main(String[] args) {  
        IMyMessageFactory myMessageFactory = new MyMessageFactory();  
        IMyMessage myMessage;  
        // 对于这个消费者来说，不用知道如何生产message这个产品，耦合度降低  
        try {  
            // 先来一个短信通知  
            myMessage = myMessageFactory.createMessage("SMS");  
            myMessage.sendMesage();  
  
            // 来一个oa待办  
            myMessage = myMessageFactory.createMessage("OA");  
            myMessage.sendMesage();  
  
            // 来一个邮件通知  
            myMessage = myMessageFactory.createMessage("EMAIL");  
            myMessage.sendMesage();  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
}

　　3、抽象工厂模式：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。

　　栗子：

interface IProduct1 {  //产品1接口
    public void show();  
}  
interface IProduct2 {  //产品2 接口
    public void show();  
}  
  
class Product1 implements IProduct1 {  
    public void show() {  
        System.out.println("这是1型产品");  
    }  
}  
class Product2 implements IProduct2 {  
    public void show() {  
        System.out.println("这是2型产品");  
    }  
}  
  
interface IFactory {  
    public IProduct1 createProduct1();  
    public IProduct2 createProduct2();  
}  
class Factory implements IFactory{  
    public IProduct1 createProduct1() {  
        return new Product1();  
    }  
    public IProduct2 createProduct2() {  
        return new Product2();  
    }  
}  

// 主函数
public class Client {  
    public static void main(String[] args){  
        IFactory factory = new Factory();  
        factory.createProduct1().show();  
        factory.createProduct2().show();  
    }  
}

缺点：产品族的扩展将是一件十分费力的事情，假如产品族中需要增加一个新的产品，则几乎所有的工厂类都需要进行修改。所以使用抽象工厂模式时，对产品等级结构的划分是非常重要的。

工厂模式

原文：https://www.cnblogs.com/Tibbers/p/12952011.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)