JAVA设计模式-工厂模式

一、工厂模式

1、普通工厂模式,就是建立一个工厂类，对实现统一接口的一些类的实例的创建。首先看下关系图。

                                   

举例说明：（我们举一个发送邮件和短信的例子）

首先：创建接口

/**
 * 发送接口
 * @author 张天柱
 * @version 1.1
 **/
public interface Sender1 {
	/**
	 * 发送方法
	 */
	public void send();
}

其次：创建实现类

/**
 * sms发送类
 * @author 张天柱
 * @version 1.1
 */
public class SmsSender implements Sender1{

	@Override
	public void send() {
		System.out.println("this is smsSender");
	}

}

/**
 * 邮件发送类
 * @author 张天柱
 * @version 1.1
 */
public class MailSender implements Sender1{

	@Override
	public void send() {
		System.out.println("this is MailSender");
	}

}

最后，创建工厂类：

/**
 * 工厂类
 * @author 张天柱
 *
 **/
public class SendFactory {
	
	/**
	 * 创建实例方法
	 * @param type
	 * @return
	 */
	public Sender1 produce(String type){
		if(type.equals("mail")){
			return new SmsSender();
		}else if(type.equals("sms")){
			return new SmsSender();
		}else{
			System.out.println("请输入正确的类型");
			return null;
		}
	}
}

最后，建测试类

/**
 * 工厂测试类
 * @author 张天柱
 * @version 1.1
 */
public class FactoryTest {
	
	public static void main(String[] args) {
		SendFactory factory = new SendFactory();
		Sender1 sender1 = factory.produce("sms");
		sender1.send();
	}
}

最后，输出  this is smsSender；

2、多个工厂方法模式,上面这种单个工厂模式有个弊端，如果传递的字符串出错，则不能正确地创建对象，多个工厂模式提供多个工厂方法，创建对象

对上面的代码稍作修改，变成：

/**
	 * 创建sms对象
	 * @return
	 */
	public Sender1 produceSms(){
		return new SmsSender();
	}
	
	/**
	 * 创建mail对象
	 * @return
	 */
	public Sender1 produceMail(){
		return new MailSender();
	}

测试类变成：

/**
 * 工厂测试类
 * @author 张天柱
 * @version 1.1
 */
public class FactoryTest {
	
	public static void main(String[] args) {
		SendFactory factory = new SendFactory();
		Sender1 sender1 = factory.produceMail();
		sender1.send();
	}
}

最后输出：this is MailSender；

3、静态工厂模式

   将上面工厂类中的方法改为静态方法；

/**
	 * 创建sms对象
	 * @return
	 */
	public static Sender1 produceSms(){
		return new SmsSender();
	}
	
	/**
	 * 创建mail对象
	 * @return
	 */
	public static Sender1 produceMail(){
		return new MailSender();
	}

测试方法改为

/**
 * 工厂测试类
 * @author 张天柱
 * @version 1.1
 */
public class FactoryTest {
	
	public static void main(String[] args) {
		Sender1 sender1 = SendFactory.produceMail();
		sender1.send();
	}
}

4、抽象工厂模式

静态工厂模式有一个弊端，就是创建类的实例，必须要修改工厂类，这违背了对修改关闭，对扩张开放原则。所以从设计角度讲，可以创建多个工厂类（抽象工厂模式），如果要增加新的对象，则增加工厂类即可。下面先看关系图：

请看例子

先定义一个接口

/**
 * 
 * @author 张天柱
 * @version 1.1
 **/
public interface Sender {
	public void send();
}

两个实现类

/**
 * 
 * @author 张天柱
 * @version 1.1
 */
public class MailSender implements Sender {

	@Override
	public void send() {
		System.out.println("this is mail");
	}

}

/**
 * 
 * @author 张天柱
 * @version 1.1
 */
public class SmsSender implements Sender{

	@Override
	public void send() {
		System.out.println("this is sms");
	}

}

再提供一个接口

/**
 * 
 * @author 张天柱
 * @version 1.1
 */
public interface Provider {
	public Sender produce();
}

两个工厂类

/**
 * 
 * @author 张天柱
 * @version 1.1
 */
public class MailSendFactory implements Provider{

	@Override
	public Sender produce() {
		return new MailSender();
	}

}

/**
 * 
 * @author 张天柱
 * @version 1.1
 */
public class SmsSendFactory implements Provider{

	@Override
	public Sender produce() {
		return new SmsSender();
	}

}

工厂测试类

/**
 * 工厂测试类
 * @author 张天柱
 * @version 1.1
 */
public class FactoryTest {
	
	public static void main(String[] args) {
		Provider provider = new SmsSendFactory();
		Sender sender = provider.produce();
		sender.send();
	}
}

其实这个模式的好处就是，

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

        谢谢一个名叫“zz563143188”的大牛，你让我懂得了很多