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了，无需去改动现成的代码。这样做，拓展性较好!