java设计模式---工厂模式

Java设计模式之工厂模式

java常用的工厂模式概论：

工厂模式分两种：1.工厂方法模式 2. 抽象工厂模式

1.工厂方法模式又分为三种：普通工厂模式，多个工厂方法模式，静态工厂方法模式。

1.1 普通方法模式
就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。首先看下关系图：

接下来我们再结合代码看一下具体怎么实现的
首先定义一个接口

public interface SendMsg {
    public void sendMsg();
}

其次，创建实现类：

public class Phone implements SendMsg{
    @Override
    public void sendMsg() {
        System.out.println("send msg by phone");
    }
}

public class Computer implements SendMsg{
    @Override
    public void sendMsg() {
        System.out.println("send msg by computer");
    }
}

然后创建一个工厂类，根据参入的参数调用不用的方法

public class SendMsgFactory {
    private  static Logger logger = Logger.getLogger(SendMsgFactory.class);

    public SendMsg send(String type){
        if(StringUtils.equals("phone",type)){
            return new Phone();
        }else if(StringUtils.equals("computer",type)){
            return new Computer();
        }else{
            logger.info("传入的类型不对");
            return null;
        }
    }
}

然后我们创建一个测试类：

public class FactoryTest {

    public static void main(String[] args) {
        SendMsgFactory factory = new SendMsgFactory();
        SendMsg send = factory.send("computer");
        send.sendMsg();
    }
}

运行结果：send msg by computer

1.2 多个工厂方法模式
是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。关系图如下：

和普通工厂不同的是多个工厂方法模式的工厂类变了

public class SendMsgFactory {

    public SendMsg sendByPhone(){
        return new Phone();
    }

    public SendMsg sendByComputer(){
        return new Computer();
    }
}

这样测试类就不用传相应的type

public class FactoryTest {

    public static void main(String[] args) {
        SendMsgFactory factory = new SendMsgFactory();
        SendMsg send = factory.sendByPhone();
        send.sendMsg();
    }
}

运行结果：send msg by phone

1.3 静态工厂方法模式
将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

public class SendMsgFactory {

    public static SendMsg sendByPhone(){
        return new Phone();
    }

    public static SendMsg sendByComputer(){
        return new Computer();
    }
}

测试类修改为不用new工厂类实例

public class FactoryTest {

    public static void main(String[] args) {
        SendMsg send = SendMsgFactory.sendByComputer();
        send.sendMsg();
    }
}

2.抽象工厂模式
工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。关系图如下：

代码如下：
定义业务接口：

public interface SendMsg {
    public void sendMsg();
}

定义业务实现类：

public class Phone implements SendMsg{
    @Override
    public void sendMsg() {
        System.out.println("send msg by phone");
    }
}

public class Computer implements SendMsg{
    @Override
    public void sendMsg() {
        System.out.println("send msg by computer");
    }
}

定义工厂类接口：

public interface Factory {
    public SendMsg sendBy();
}

定义工厂接口实现类：

public class FactoryPhone implements Factory{

    @Override
    public SendMsg sendBy() {
        return new Phone();
    }
}

public class FactoryComputer implements Factory{
    @Override
    public SendMsg sendBy() {
        return new Computer();
    }
}

这样一来，我们测试类直接使用向上造型：

public class FactoryTest {

    public static void main(String[] args) {
        Factory factory = new FactoryComputer();
        SendMsg sendMsg = factory.sendBy();
        sendMsg.sendMsg();
    }
}

其实这个模式的好处就是，如果你现在想增加一个功能：发及时信息，则只需做一个实现类，实现SendMsg接口，同时做一个工厂类，实现Factory接口，就OK了，无需去改动现成的代码。这样做，拓展性较好！

===============
第一篇博客，很激动。希望对那些刚步入Java行业的小伙伴有些帮助author：头