工厂模式（思维导图）

 

图1 工厂模式【点击查看大图】

　　在面向对象编程中, 最通常的方法是一个new操作符产生一个对象实例,new操作符就是用来构造对象实例的。但是在一些情况下, new操作符直接生成对象会带来一些问题。举例来说, 许多类型对象的创造需要一系列的步骤: 你可能需要计算或取得对象的初始设置; 选择生成哪个子对象实例; 或在生成你需要的对象之前必须先生成一些辅助功能的对象。 在这些情况,新对象的建立就是一个 “过程”，不仅是一个操作，像一部大机器中的一个齿轮传动。

1，非工厂模式

　　自产自用，需要什么东西自己动手做的田园经济。

辅助函数：

package com.cnblogs.mufasa.Demo2;

public interface IMessage {
    final static String VALUE="接口中的常量数据";
    public void send();
    public void send(String message);
}

public interface IService {
    public void service();
}

public class NetMessage implements IMessage {
    private String message;
    public NetMessage(){
        this.message="无参构造";
    }
    public NetMessage(String message){
        this.message=message;
    }


    public void send() {
        System.out.println(this.message+"。。。输出");
    }
    public void send(String str) {
        System.out.println(str+this.getVALUE());
    }

    public String getVALUE(){
        return this.VALUE;
    }
    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

非工厂的对象实例化：

package com.cnblogs.mufasa.Demo2;

public class Demo1 {
    public static void main(String[] args) throws Exception {
        IMessage msg=new NetMessage("成功");//如果直接实例化一定会有
        msg.send();
        msg.send("hello");
    }
}
/*输出
【网络消息发送】www.cnblogs.com
 */

 

2，简单工厂模式（Simple Factory） 

　　市场经济的初级阶段，这个工厂只能生产特定不变的东西。【静态工厂】

package com.cnblogs.mufasa.Demo2;

/**
 * 静态工厂类：添加新的子类需要追加修改，标记
 */
public class Factory {
    private Factory(){}//没有产生实例化对象的意义，所以构造方法私有化
    public static IMessage getInstance(String className){
        if("netmessage".equalsIgnoreCase(className)){
            return new NetMessage();
        }
        return null;
    }
}

简单工厂实例化：

package com.cnblogs.mufasa.Demo2;

public class Demo2 {
    public static void main(String[] args) throws Exception {
        IMessage msg=Factory.getInstance("NetMessage");//标准的工厂设计模式
        msg.send();
    }
}
/*输出
【网络消息发送】www.cnblogs.com
 */

 

3，工厂方法模式（Factory Method） 

package com.cnblogs.mufasa.demo1;

import com.cnblogs.mufasa.demo1.IMessage;

public interface IFactory {
    IMessage getInstance();
}

class FactoryNetMessage implements IFactory{
    @Override
    public NetMessage getInstance() {
        return new NetMessage();
    }
}

 

package com.cnblogs.mufasa.demo1;

public class Demo1 {
    public static void main(String[] args) {
        FactoryNetMessage factoryNetMessage=new FactoryNetMessage();
        NetMessage netMessage=factoryNetMessage.getInstance();
        netMessage.send("工厂方法-");

    }
}

 

4，抽象工厂模式（Abstract Factory） 

 　　将功能进行细分

package com.cnblogs.mufasa.Demo3;

public interface IFactory {
    public IMessage getMessage();
    public IService getService();
}

class Factory1 implements IFactory{
    @Override
    public IMessage getMessage() {
        return new NetMessage();
    }

    @Override
    public IService getService() {
        return new HouseService();
    }
}

class Factory2 implements IFactory{
    @Override
    public IMessage getMessage() {
        return new NetMessage();
    }

    @Override
    public IService getService() {
        return new HouseService();
    }
}

 

5，反射实现的动态工厂模式

package com.cnblogs.mufasa.demo2;

//反射实现的动态工厂类
public class Factory2 {
    private Factory2(){}
    public static IMessage getInstance(String className) throws Exception {
        IMessage instance=null;
        try{//动态工厂类
            instance=(IMessage) Class.forName(className).getDeclaredConstructor().newInstance();
        }catch (Exception e){
            e.printStackTrace();
        }
        return instance;
    }
}

 

6，反射&泛型实现的动态工厂模式

package com.cnblogs.mufasa.demo2;

public class Factory3 {
    private Factory3(){}

    /**
     * 获取接口实例化对象
     * @param className 接口的子类
     * @param tClass    描述的是一个接口的类型
     * @param <T>       接口的类型【泛型】
     * @return          如果子类存在则返回指定接口的实例化对象
     * @throws Exception
     */
    public static <T> T getInstance(String className,Class<T> tClass) throws Exception {
        T instance=null;
        try{//动态工厂类
            instance=(T) Class.forName(className).getDeclaredConstructor().newInstance();
        }catch (Exception e){
            e.printStackTrace();
        }
        return instance;
    }
}

 

原文链接：https://blog.csdn.net/jason0539/article/details/23020989

原文链接：https://blog.csdn.net/jason0539/article/details/44976775