23种设计模式 - java 实现_被遗忘的设计模式-CSDN博客

1）创建型

1.工厂方法

意图：

定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。

适用性：

当一个类不知道它所必须创建的对象的类的时候。

当一个类希望由它的子类来指定它所创建的对象的时候。

当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。

11、普通工厂模式，就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建

实现：

Sender接口

public interface Sender {
    public void sendMessage();
}

Sender接口的实现：MailSender

public class MailSender implements Sender {

    @Override
    public void sendMessage() {
        System.out.println("Send Mail!");
    }
}

Sender接口的实现：SmsSender

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

Sender接口的实现：NullSender（空对象模式）

public class NullSender implements Sender {
    @Override
    public void sendMessage(){
        System.out.println("You enter a wrong Sender Type!");
    }
}

SenderFactory

public class SenderFactory {
    public Sender produce(String senderType){
        if ("MailSender".equals(senderType)){
            return new MailSender();
        }else if ("SmsSender".equals(senderType)){
            return new SmsSender();
        }else {
            return new NullSender();
        }
    }

    public static void main(String[] args){
        SenderFactory senderFactory = new SenderFactory();
        Sender sender = senderFactory.produce("SmsSender");
        sender.sendMessage();
    }
}

（备注：在工厂方法模式中，加入了空对象模式，由于不属于常用的23种设计模式，详情可以参考《被遗忘的设计模式——空对象模式（Null Object Pattern）》一文，避免

空指针异常）

22、多个工厂方法模式，是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。

工厂类

public class MultiSenderFactory {
    public Sender produceSmsSender(){
        return new SmsSender();
    }
    public Sender produceMailSender(){
        return new MailSender();
    }
}

测试类：

public class TestFactory {
    public static void main(String[] args){
        MultiSenderFactory multiSenderFactory = new MultiSenderFactory();
        multiSenderFactory.produceMailSender().sendMessage();
    }
}

33、静态工厂方法模式，将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

工厂类：

public class MultiStaticSenderFactory {
    public static Sender produceSmsSender(){
        return new SmsSender();
    }
    public static Sender produceMailSender(){
        return new MailSender();
    }
}

测试类：

public class TestFactory {
    public static void main(String[] args){
        MultiStaticSenderFactory.produceSmsSender().sendMessage();
    }
}

2.抽象工厂

意图：

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
适用性：

一个系统要独立于它的产品的创建、组合和表示时。

一个系统要由多个产品系列中的一个来配置时。

当你要强调一系列相关的产品对象的设计以便进行联合使用时。

当你提供一个产品类库，而只想显示它们的接口而不是实现时。

工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。因为抽象工厂不太好理解，我们先看看图，然后就和代码，就比较容易理解。

Sender接口，SmsSender类和MailSender类同上

Provider接口：

public interface Provider {
    public Sender produce();
}

Provider实现for MailSender：

public class SendMailFactory implements Provider {
    @Override
    public Sender produce() {
        return new MailSender();
    }
}

Provider实现for SmsSender：

public class SendSmsFactory implements Provider {
    @Override
    public Sender produce() {
        return new SmsSender();
    }
}

测试类：

public class TestFactory {
    public static void main(String[] args){
        Provider provider = new SendMailFactory();
        Sender sender = provider.produce();
        sender.sendMessage();
    }
}

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