工厂方法模式

Posted on | Edited on | In | Views:

工厂方法模式

在简单工厂模式中有个坏处就是,类的创建需要依赖工厂,也就是说如果要扩展类的功能需要对工厂类进行修改,这违背了开闭原则,所以从设计考虑,有一定问题.所以有了工厂方法模式,创建一个工厂接口和多个工厂实现类,这样一旦需要增加新的功能,直接增加工厂类就可以了,不需要修改以前的代码,只需要在添加一个工厂类.符合开闭原则.

举例:

类接口:

1
2
3
public interface Sender {
    public void send();
}

实现类:

1
2
3
4
5
6
7
8
9
10
11
12
13
public class MailSender implements Sender {

    @Override
    public void send() {
        System.out.println("mailsender");
    }
}
public class SmsSender implements Sender {
    @Override
    public void send() {
        System.out.println("SmsSender");
    }
}

工厂接口:

1
2
3
public interface Provider {
    public Sender getSender();
}

工厂实现类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class MailSendFactory implements Provider {
    @Override
    public Sender getSender() {
        return new MailSender();
    }
}
public class SmsSendFactory implements Provider {
    @Override
    public Sender getSender() {
        return new SmsSender();
    }
}
~~~ 

## 测试
~~~java
public static void main(String[] args) {
        Provider provider = new MailSendFactory();
        Sender sender = provider.getSender();
    }
    //这样做的好处就是完全解耦合,当需要不同的产品是只需要改变一下工厂类即可,其余的都可以不需要改.

这个样子就可以在扩展的时候不需要修改之前的程序就可以添加扩展功能了.这样做的好处就是扩展性好,在添加新功能的时候只需要实现一个类,实现Sender接口,然后在做一个实现工厂,实现Provider接口,就可以了.
借鉴与https://www.cnblogs.com/geek6/p/3951677.html

抽象工厂模式

抽象工厂模式与工厂模式的区别不好区分.
抽象工厂模式是提供一个创建一系列相关或相互依赖对象的接口,而无需制定他们具体的类.
抽象工厂模式的好处就是易于交换产品系列,由于具体工厂类在一个应用中一般只需要出现一次(就像Provider = new MailSendFactory()). 这就使得改变一个应用的具体工厂编的非常容易,只需要改变具体工厂即可使用不用的产品配置.
抽象工厂模式与工厂方法模式的不同:　　　
工厂方法模式:

  • 一个抽象产品类可以派生出多个具体产品类
  • 一个抽象工厂类可以派生出多个具体工厂类
  • 每个具体工厂类也只能派生出一个具体产品类
    抽象工厂模式:　　　
  • 多个抽象产品类，每个抽象产品类可以派生出多个具体产品类
  • 一个抽象工厂类．可以派生出多个具体工厂类
  • 每个具体工厂类可以创建多个具体的产品类的实例.


举个例子:

多个抽象产品类

1
2
3
4
5
6
public interface Recived {
    public void recived();
}
public interface Sender {
    public void send();
}

工厂抽象类

1
2
3
4
public interface Provider {
    public Sender getSender();
}
// Reviced 与这个一样,就不写了.

工厂实现类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
public class MailSendFactory implements Provider {
    @Override
    public Sender getSender() {
        return new MailSender();
    }
}
public class SmsSendFactory implements Provider {
    @Override
    public Sender getSender() {
        return new SmsSender();
    }
}
~~~ 


## 多个实现类
~~~java
public class MailSender implements Sender {

    @Override
    public void send() {
        System.out.println("mailsender");
    }
}

public class MailRecived implements Recived {
    @Override
    public void recived() {
        System.out.println("mailRecived");
    }
}
public class SmsRecived implements Recived {
    @Override
    public void recived() {
        System.out.println("smsRecived");
    }
}
public class SmsSender implements Sender {
    @Override
    public void send() {
        System.out.println("SmsSender");
    }
}

##　测试

1
2
3
4
5
public static void main(String[] args) {
        Provider provider = new MailSendFactory();
        Recived recived = provider.getRecived();
        Sender sender = provider.getSender();
}

在这里如果想要使用mailSend邮件协议只需要改变上面那个工厂就可以在下面整体替换邮件系统.这样子给程序的扩展性与改变性提供了更好的方法.