常见的几种设计模式

单例模式（双重检查锁版）

保证一个类仅有一个实例，并提供一个访问它的全局访问点

public class LazyMan2 {
    
    //声明变量
    private static volatile LazyMan2 singleton = null;
    
    //私有化构造函数
    private LazyMan2(){
        
    }
    
    //提供对外方法
    public static LazyMan2 getInstance(){
        if(singleton == null){
            //细节，这里对类进行锁定
            synchronized (singleton.getClass()){
                if (singleton == null){
                    singleton = new LazyMan2();
                }
            }
        }
        return singleton;
    }
}

静态工厂方法模式

使用一个工厂类来专门生产对象，用户只是关心产品，不用关心创建过程

public interface Sender {
   void send();
}

public class SmsSender implements Sender {

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

public class MailSender implements Sender {

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


public class SendFactory {

    //跟多个工厂方法模式相比，就是把两个方法都改成静态的，无需实例化就可以调用
    public static Sender produceMail(){
        return new MailSender();
    }

    public static Sender produceSms(){
        return new SmsSender();
    }

}

问题，如果我想要扩展程序，添加一个发送图片的功能是不是就得修改原有的代码 ？

抽象工厂模式

在普通工厂方法模式的基础上，对所有的工厂进行了一个抽象，创建不同的对象可以使用不同的工厂，在扩展的时候只需要增加一个工厂类和创建该对象的类就行，不需要修改原来的代码

以Spring中常见的工厂模式举例 ：
有三个类：

代码如下：

public abstract class Provider {

    static Provider defaultProvider = new SendMailFactory();

    abstract Sender produce();

    public static Sender produce(String type){
        if("mail".equals(type)){
            return new SendMailFactory().produce();
        }else if ("sms".equals(type)){
            return new SendSmsFactory().produce();
        }else {
            System.out.println("返回默认的产品");
            return defaultProvider.produce();
        }
    }
}

public class SendMailFactory extends Provider {

    @Override
    Sender produce() {
        return new MailSender();
    }
}
public class SendSmsFactory extends Provider {

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

使用抽象类Provider的静态方法就可以生产需要生产的对象.