一、工厂模式
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”的大牛,你让我懂得了很多