设计模式（二）——工厂模式

简单工厂模式：

create()方法通常是静态的，也叫静态工厂，定义：通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

/**
 * 产品抽象类
 *
 * @date 2018/8/14
 */

public abstract  class INoodles {
    public abstract void desc();
}
//====================================
/**
 *具体产品类
 * @date 2018/8/14
 */

public class LanzhouNoodles extends INoodles {
    @Override
    public void desc() {
        Log.e("mrpeng", "desc: 兰州拉面，产自兰州" );
    }
}
//==================================
/**
 * Demo class
 * 具体产品类
 * @date 2018/8/14
 */

public class PaomianNoodles extends INoodles {
    @Override
    public void desc() {
        Log.e("mrpeng", "desc: 泡面没营养" );
    }
}
//===================================================
/**
 *  简单工厂类
 * @date 2018/8/14
 */

public class SimpleNoodlesFactory {

    public static final int TYPE_LZ = 1;//兰州拉面
    public static final int TYPE_PM = 2;//泡面

    public static INoodles createNoodles(int type) {
        switch (type) {
            case TYPE_LZ:
                return new LanzhouNoodles();
            case TYPE_PM:
                return new PaomianNoodles();
            default:
                return null;
        }
    }
}
//test方法
public void test() {
        INoodles noodles = SimpleNoodlesFactory.createNoodles(SimpleNoodlesFactory.TYPE_LZ);
        noodles.desc();
    }

特点： 工厂类是一个具体的类，非抽象接口，有create方法，利用if或swich穿件产品并返回。create方法通常是静态方法，因此也称之为静态工厂
缺点： 扩展性差，如果要增加产品类，还要修改工厂类方法。不同产品需要额外不同参数的时候不支持。

工厂方法模式：

定义：定义一个创建对象的接口（工厂接口），让其实现类（工厂实现类）决定要实例化的类是哪一个（产品类）。并由该实现类，创建对应类的实例。工厂方法模式把类实例化的过程推迟到子类。
作用：
1. 可以一定程度解耦，消费者和产品实现类隔离开，只依赖产品接口（抽象产品），产品实现类如何改动与消费者完全无关。
2. 可以一定程度增加扩展性，若增加一个产品实现，只需要实现产品接口，修改工厂创建产品的方法，消费者无感知，（若消费之不关心产品是什么）
3. 可以一定程度增加代码的封装性，可读性。清楚地代码接口对消费者来说很少的代码量就可以完成很多工作。
4. 抽象工厂才是实际意义的工厂模式，工厂方法只是抽象工厂的一个比较常见的情况。
场景：
1. 消费者不关心它所要创建对象的类（产品类）的时候
2. 消费者知道它所要创建对象的类（产品类），但不关心如何创建的时候。
要素：
1. 提供产品类的接口。产品类都要实现这个接口（也可以是抽象类，即抽象产品）
2. 提供工厂类的接口。工厂类均要实现这个接口（抽象工厂）
3. 由工厂实现类创建产品类的实例，工厂实现类应有一个方法，用来实例化产品类。

/**
 *  工厂方法模式_工厂接口
 */

public interface IMyMessageFactory {
     IMyMessage createMessage(String messageType);
}
//===================================================
/**
 * 工厂方法模式_产品接口
 */

public interface IMyMessage {
    Map<String, Object> getMessageParams();
    void setMessageParam(Map<String,Object> messageParam);
    void sendMessage() throws Exception;//发送通知消息
}
//======================================================
/**
 * 工厂方法模式_虚拟产品类
 *
 * @date 2018/8/20
 */

public abstract class MyAbstractMessage implements IMyMessage {

    private Map<String, Object> messageParams;//这里可以理解为生产产品所需要的原材料库。最好是个自定义的对象，这里为了不引起误解使用Map。

    @Override
    public Map<String, Object> getMessageParams() {
        return messageParams;
    }

    @Override
    public void setMessageParam(Map<String, Object> messageParam) {
        this.messageParams = messageParam;
    }
}
//============================================================
public class MessageOaTo extends MyAbstractMessage {

    @Override
    public void sendMessage() throws Exception {
        // TODO Auto-generated method stub
        if (null == getMessageParams() || null == getMessageParams().get("username")
                || "".equals(getMessageParams().get("username"))) {
            throw new Exception("发送OA待办,需要传入OAUSERNAME参数");// 为了简单起见异常也不自定义了
        }// 另外邮件内容，以及其他各种协议参数等等都要处理

        Log.e("mrpeng", "我是OA待办，发送通知给" + getMessageParams().get("username"));
    }
}

//=========================================================
/**
 * 工厂方法模式_email产品
 *
 * @date 2018/8/20
 */
public class MesaageEmail extends MyAbstractMessage {

    @Override
    public void sendMessage() throws Exception {
        // TODO Auto-generated method stub
        if (null == getMessageParams() || null == getMessageParams().get("email")
                || "".equals(getMessageParams().get("email"))) {
            throw new Exception("发送短信,需要传入EMAIL参数");// 为了简单起见异常也不自定义了
        }// 另外邮件内容，以及其他各种协议参数等等都要处理

        Log.e("mrpeng", "我是邮件，发送通知给" + getMessageParams().get("email"));
    }
}

//======================================================

/**
 * 工厂方法模式_工厂实现
 * @date 2018/8/17
 */

public class MyMessageFactory implements IMyMessageFactory {

    @Override
    public IMyMessage createMessage(String messageType) {
        IMyMessage message = null;
        HashMap<String, Object> messageParams = new HashMap<>();
        if ("oa".equals(messageType)) {
            message = new MessageOaTo();
            messageParams.put("username", "testuser");
        }else if ("email".equals(messageType)){
            message=new MesaageEmail();
            messageParams.put("email","test@text.com");
        }
        message.setMessageParam(messageParams);
        return message;
    }
}
//============================================================

//工厂方法模式_消费者
                IMyMessageFactory messageFactory = new MyMessageFactory();
                IMyMessage message;
                try {
                    message = messageFactory.createMessage("oa");
                    message.sendMessage();
                    message = messageFactory.createMessage("email");
                    message.sendMessage();
                } catch (Exception e) {
                    e.printStackTrace();
                }

抽象工厂模式：

定义：提供一个接口，用于创建相关的或依赖对象的家族，而不需要明确指定具体类。