工厂模式（思惟导图）

 

图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;
    }
}

View Code

非工厂的对象实例化：

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