一、设计模式的分类及优缺点_单例设计模式_工厂模式

1、总体来说设计模式分为三大类：
　　Java 中一般认为有 23 种设计模式，我们不需要所有的都会，但是其中常用的几种设计模式应该去掌握。下面列出了所有的设计模式。需要掌握的设计模式已单独列出来了，当然能掌握的越多越好。
创建型模式（5种）：单例模式、工厂模式（包含：工厂方法模式和抽象工厂模式）、建造者模式、原型模式。
结构型模式（7种）：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式（11种）：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。常用的七种设计模式的含义及优劣如下：

1.1 创建型模式：
   1）单例模式：该类负责创建自己的对象，同时确保只有单个对象被创建。
      优点：
         a.在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例，
         b.避免对资源的多重占用（比如写文件操作）
      缺点：
         a.与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化；
      使用场景：
         a.全局唯一id、web页面计数器
   2）工厂模式：它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
      优点：
         a.一个调用者想创建一个对象，只要知道其名称就可以了
         b.扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以
         c.屏蔽产品的具体实现，调用者只关心产品的接口
      缺点：
         a.每次增加一个产品时，都需要增加一个具体类和修改对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。
   3）建造者模式：是使用多个简单的对象一步一步构建成一个复杂的对象
      优点：
         a.建造者独立，易扩展
         b.便于控制细节风险
      缺点：
         a.产品必须有共同点，范围有限制。
         b.如内部变化复杂，会有很多的建造类。
      典型的如kfc 的汉堡套餐：蔬菜汉堡套餐、鸡肉汉堡套餐
1.2 行为型模式：
   1）策略模式：
      一个类的行为或其算法可以在运行时更改。在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。策略对象改变 context 对象的执行算法。
      优点：
         a.算法可以自由切换
         b.避免使用多重条件判断
         c.扩展性良好
      缺点：
         a.策略类会增多。
         b.所有策略类都需要对外暴露。
      示例：不同的策略对象，调用策略中的同一个方法，得到的确实不同的策略结果
   2）观察者模式：
      一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。
      优点：
         a.观察者和被观察者是抽象耦合的
         b.建立一套触发机制
      缺点：
         a.如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间
         b.如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃
         c.观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。
      示例：Subject(主题)中，定义有观察者列表，并提供主题中的状态发生变更的时候，进行消息通知的方法

   3）模板模式：一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。
      优点：
         a.封装不变部分，扩展可变部分。
         b.提取公共代码，便于维护。
         c.行为由父类控制，子类实现。
      缺点：
         a.每一个不同的实现都需要一个子类来实现，导致类的个数增加，使得系统更加庞大。
         示例：需求描述 订单消息包括：待收货，待审核，待支付，代客下单待确认;账号管理消息包括：账密提取消息，添加组织架构，角色分配，审核流程，审核废弃流程待确认消息;这些都需要进行消息数量展示
         模板抽象类中定义：当前对象类型、该消息类型是否具有权限、是否被风控降级、查DB、获取表中消息的数量、获取表初始化数量
1.3 结构型模式：
   1）装饰器模式：允许向一个现有的对象添加新的功能，同时又不改变其结构。
      优点：
         装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能
      缺点：
         多层装饰比较复杂
      使用场景：动态增加一个类的功能，动态撤销；
      示例：创建一个 Shape 接口和实现了 Shape 接口的实体类。然后我们创建一个实现了 Shape 接口的抽象装饰类 ShapeDecorator，并把 Shape 对象作为它的实例变量。RedShapeDecorator 是实现了 ShapeDecorator 的实体类。DecoratorPatternDemo 类使用 RedShapeDecorator 来装饰 Shape 对象。

2、单例模式
2.1饿汉式单例

//饿汉式
public class Singleton1 {
    //直接创建对象
    public static Singleton1 instance=new Singleton1();
    //私有化构造方法
    private Singleton1(){}
    //返回对象实例
    public static Singleton1 getInstance(){
        return instance;
    }
}

2.2懒汉式单例

//懒汉式：
public class Singleton2 {
    // 声明变量
    private static volatile Singleton2 singleton = null;

    // 私有构造函数
    private Singleton2() {
    }

    // 提供对外方法
    public static Singleton2 getInstance() {
        if (singleton == null) {
            synchronized (Singleton2.class) {
                if (singleton == null) {
                    singleton = new Singleton2();
                }
            }
        }
        return singleton;
    }
    
    public static void main(String[] args){
        System.out.println(getInstance());
    }
    
}

3.工厂模式分为:工厂方法模式和抽象工厂模式
3.1)工厂方法模式分为三种：
    1、普通工厂模式：就是建立一个工厂类， 对实现了同一接口的一些类进行实例的创建。示列：SendFactory
    a）同一接口类：

public interface Sender {
    public void send();
}

    b1）同一接口的实现类MailSender：

public class MailSender implements Sender {

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

}

    b2）同一接口的实现类SmsSender：　

public class SmsSender implements Sender {

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

}

    c）普通工厂模式类SendFactory

//普通工厂模式
public class SendFactory {
    public Sender produce(String type){
        if("mail".equals(type)){
            return new MailSender();
        }else if ("sms".equals(type)) {
            return new SmsSender();
        }else {
            System.out.println("请输入正确的类型!");
            return null;
        }
    }
}

    d）测试类：

public class FacteryTest {
    public static void main(String[] args) {
        SendFactory sendFactory=new SendFactory();
        sendFactory.produce("mail").send();
        sendFactory.produce("sms").send();
        
    }
}

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

//多个工厂方法模式：
public class SendFactory2 {
    public Sender produceMail(){
        return new MailSender();
    }
    
    public Sender produceSms(){
        return new SmsSender();
    }
}

　 b）测试类：

public class FacteryTest {
    public static void main(String[] args) {    
        SendFactory2 factory = new SendFactory2();
        Sender sender2 = factory.produceMail();
        sender2.send();
    }
}

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

　a）静态工厂方法模式类SendFactory3

//静态工厂方法模式
public class SendFactory3 {
    public static Sender produceMail(){
        return new MailSender();
    }
    
    public static Sender produceSms(){
        return new SmsSender();
    }
}

　b）测试类：　

public class FacteryTest {
    public static void main(String[] args) {
        Sender sender3=SendFactory3.produceSms();
        sender3.send();
    }
}

3.2)抽象工厂模式
    工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。
　 a）接口Provider　

public interface Provider {
    public Sender produce();
}

　 b）接口Sender　

public interface Sender {
    public void send();
}

　 c）功能类MailSender，实现了Sender接口

public class MailSender implements Sender {
    public void send() {
        System.out.println("this is mail sender!");
    }
}

    d）功能类SmsSender，实现了Sender接口

public class SmsSender implements Sender {
    public void send() {
        System.out.println("this is sms sender!");
    }
}

    e）工厂类SendMailFactory，实现了Provider接口

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

    f）工厂类SendSmsFactory，实现了Provider接口

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

    g）测试类

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

 参看文章：https://www.runoob.com/design-pattern/design-pattern-tutorial.html 设计模式