设计模式——工厂方法模式

工厂方法模式：生产那种产品不再是由参数决定，定义一个创建对象的工厂接口，让实现工厂接口的具体类决定实例化哪一个产品类，将实际创建工作推迟到子类当中。

① 一个产品接口

② 一个工厂接口

③ 实现了产品接口的具体产品类

④ 实现了工厂接口的具体工厂类

⑤ 消费者类，用于测试

 

   

例子一

角色：一个产品接口

package com.test.factoryMethod2;

public interface Shape {
    public abstract void draw();
}

角色：一个工厂接口

package com.test.factoryMethod2;

public interface ShapeFactory {
    public abstract Shape getShape();
}

角色：具体的产品类 Circle

package com.test.factoryMethod2;

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println(" I am the Circle");
    }
}

角色：具体的产品类 Rectangle

package com.test.factoryMethod2;

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("I am the Rectangle");
    }
}

角色：具体的产品类 Square

package com.test.factoryMethod2;

public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("I am the Square");
    }
}

角色：与产品类Circle对应具体的工厂类

package com.test.factoryMethod2;

public class CircleFactory implements ShapeFactory {
    @Override
    public Shape getShape() {
        return new Circle();
    }
}

角色：与产品类Rectangle 对应具体的工厂类

package com.test.factoryMethod2;

public class RectangleFactory implements ShapeFactory {
    @Override
    public Shape getShape() {
        return new Rectangle();
    }
}

角色：与产品类Square对应具体的工厂类

package com.test.factoryMethod2;

public class SquareFactory implements ShapeFactory {
    @Override
    public Shape getShape() {
        return new Square();
    }
}

测试

package com.test.factoryMethod2;

public class FactoryMethodDemo {
    public static void main(String[] args){
        ShapeFactory circleFactory = new CircleFactory();
        circleFactory.getShape().draw();

        ShapeFactory rectangleFactory = new RectangleFactory();
        rectangleFactory.getShape().draw();

        ShapeFactory squareFactory = new SquareFactory();
        squareFactory.getShape().draw();
    }
}

测试结果：

例子二  在产品接口和具体产品类之间增加了一个抽象类

角色：产品接口

package com.test.factoryMethod;

import java.util.Map;

public interface MyMessage {
    /*
    * 产品接口
    */
    public abstract Map<String, Object> getMessageParam();
    public abstract void setMessageParam(Map<String, Object> messageParam);
    public abstract void sendMessage() throws Exception;
}

角色：抽象产品类 实现了一些共有方法

package com.test.factoryMethod;

import java.util.Map;

public abstract class MyAbstractMessage implements MyMessage {
    /*
    * 抽象产品类
    */
    private Map<String, Object> messageParam;
    @Override
    public Map<String, Object> getMessageParam(){
        return messageParam;
    }
    @Override
    public void setMessageParam(Map<String, Object> messageParam){
        this.messageParam = messageParam;
    }
}

角色：具体产品类 EmialMessage

package com.test.factoryMethod;

public class EmailMessage extends MyAbstractMessage {
    @Override
    public void sendMessage() throws Exception {
        if (null == getMessageParam() || null == getMessageParam().get("EMAIL") || "".equals(getMessageParam().get("EMAIL"))){
            throw new Exception("发送短信，需要传入EMAIL参数");
        }
        System.out.println("我是邮件，发送通知给" + getMessageParam().get("EMAIL"));
    }
}

角色：具体产品类 OAMessage

package com.test.factoryMethod;

public class OAMessage extends MyAbstractMessage {
    @Override
    public void sendMessage() throws Exception {
        if (null == getMessageParam() || null == getMessageParam().get("OA_userName") || "".equals(getMessageParam().get("OA_userName"))){
            throw new Exception("发送OA待办，需要传入 OA_userName 参数");
        }
        System.out.println("我是OA待办，发送通知给" + getMessageParam().get("OA_userName"));
    }
}

角色：具体产品类 SMSMessage

package com.test.factoryMethod;

public class SMSMessage extends MyAbstractMessage {
    @Override
    public void sendMessage() throws Exception {
        if (null == getMessageParam() || null == getMessageParam().get("phone_number") || "".equals(getMessageParam().get("phone_number"))){
            throw new Exception("发送短信，需要传入phone_number参数");
        }
        System.out.println("我是短信，发送通知给" + getMessageParam().get("phone_number"));
    }
}

角色：工厂接口

package com.test.factoryMethod;

public interface FactoryMethod {
    /*
    * 工厂接口
    */
    public abstract MyMessage createMessage(String messageType);
}

角色：具体工厂类

package com.test.factoryMethod;

import java.util.HashMap;
import java.util.Map;

public class FactoryMethod1 implements FactoryMethod {
    @Override
    public MyMessage createMessage(String messageType) {
        MyMessage myMessage;
        Map<String, Object> messageParam = new HashMap<>();
        if ("SMS".equals(messageType)){
            myMessage = new SMSMessage();
            messageParam.put("phone_number", "123456789");
        } else if ("OA".equals(messageType)){
            myMessage = new OAMessage();
            messageParam.put("OA_userName", "testUser");
        } else if ("EMAIL".equals(messageType)){
            myMessage = new EmailMessage();
            messageParam.put("EMAIL", "test@test.com");
        } else {
            myMessage = new EmailMessage();
            messageParam.put("EMAIL", "test@test.com");
        }
        myMessage.setMessageParam(messageParam);
        return myMessage;
    }
}

测试

package com.test.factoryMethod;

public class FactoryMethodTest {
    public static void main(String[] args){
        FactoryMethod messageFactory = new FactoryMethod1();
        MyMessage myMessage;
        try{
            myMessage = messageFactory.createMessage("SMS");
            myMessage.sendMessage();

            myMessage = messageFactory.createMessage("OA");
            myMessage.sendMessage();

            myMessage = messageFactory.createMessage("EMAIL");
            myMessage.sendMessage();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

测试结果

package com.test.factoryMethod2;

public interface Shape {
    public abstract void draw(