【设计模式】

软件设计的6大基本原则SOLID

1、Single单一性原则

一个类只负责一类方法的封装，一个方法只负责单一的功能的封装。

该原则是高内聚，低耦合的基础。高内聚指功能相同的方法内聚在同一个类中，共同完成一个功能的代码块聚合在一个方法中；低耦合指一个类之间的方法尽量少的相互调用，修改一个方法不会或者很少的影响另外一个方法。

2、Open&Close 开闭原则

对扩展开放，对修改关闭。由于旧代码已经经过测试和实践检验，不能对旧代码进行修改，而是只能在旧代码基础上进行扩展，添加新的代码，而非修改旧的代码。

3、里氏替换原则LSP

父类出现的地方，都可以用子类进行替换。比如MVC模式中，Controller层通过统一的接口调用具体实现类的方法，而非通过具体的实现类。这里所有的父类接口都可以用具体的子类进行替换。

4、Interface接口隔离原则

不同功能之间尽量使用接口隔离，对外不暴露不会使用的接口。

5、依赖倒置原则

高层不依赖于底层模块，而是依赖于其抽象；针对抽象编程，而非针对具体。具体表现之一是：父类按照接口调用子类，而非通过具体类。

6、迪米特法则------最少知道法则

一个类的实体应该尽量少的与另一个类发生联系。

设计模式的分类

构建型：用于构建复杂的对象，比如建造者模式，工厂模式

结构型：关注类和对象的组合，比如适配器模式，外观模式

行为型：关注对象之间的通信，比如观察者模式，迭代器模式

单例模式

在系统中，部分关键资源只能有一份，比如单一日志文件的文件对象，mysql自增主键的主键值分发器，redis连接器等，这时应该使用单例模式

单例模式有两种实现：

1、懒汉模式：第一次使用时创建

2、饿汉模式：类加载时创建

下方是代码：

/**
 * 单例模式 ------> 懒汉实现
 */

public class SingletonLazy {
    private static volatile SingletonLazy instance;
    private SingletonLazy(){

    }

    /**
     * 线程不安全的方法
     * 存在线程安全问题
     * @return
     */
    public static SingletonLazy getInstance1(){
        if (instance == null)
            instance = new SingletonLazy();
        return instance;
    }

    /**
     * 方法加锁，没有线程安全问题
     * 但是synchronized对方法加锁加锁会导致较大的性能开销
     * 使用DCL双重锁定检查
     */
    public static SingletonLazy getInstance2(){
        if (instance == null){
            synchronized(SingletonLazy.class) {
                if (instance == null)
                   instance = new SingletonLazy();
            }
        }
        return instance;
    }





}

/**
 * 饿汉模式：在类加载时就创建单例对象
 * 优点：不涉及线程同步问题，实现简单
 * 缺点：拖慢加载速度，浪费内存（在不用该对象时创建了该对象）
 */
public class SingletonHungry {
    private static SingletonHungry instance = new SingletonHungry();
    private SingletonHungry(){}
    private SingletonHungry getInstance(){
        return instance;
    }
}

工厂模式

工厂模式将对象的创建和对象的使用分离开，使得对象的创建和使用分别更加容易修改而不会影响对方。

1、简单工厂模式

有一个工厂，通过静态方法传入参数，返回不同的商品；这些商品是同一类，继承同一个接口。

package factory;
//公共接口

public interface Pay {
    /**
     * 统一下单接口
     */
    void unifiedorder();
}

商品1：阿里pay

package factory;

public class AliPay implements Pay {

    @Override
    public void unifiedorder() {
        System.out.println("支付宝统一下单");
    }
}

商品2：微信pay

package factory;

public class WechatPay implements Pay {
    @Override
    public void unifiedorder() {
        System.out.println("微信支付统一下单接口");
    }
}

工厂：

public class SimplePayFactory {
    public static Pay createPay(String payType){
        if (payType == null) return null;
        if (payType.equalsIgnoreCase("WECHAT PAY"))
            return new WechatPay();
        else if (payType.equalsIgnoreCase("ALI PAY"))
            return new AliPay();
        //需要扩展时，需要修改代码，添加更多if
        return null;
    }

}

简单工厂模式的缺点：在添加产品时需要修改工厂的代码；工厂的负担过重，商品生产全部集中在工厂中。

2、工厂方法模式

在简单工厂的基础上，将工厂也抽象出来，出现了多个工厂建造不同类的产品，这些工厂也继承同一个接口。带来的好处是：在添加工厂时，不需要修改原有的代码；

商品同上

工厂的接口及其实现：

package factory.method;

import factory.Pay;

public interface PayFactory {
    Pay getPay();
}

package factory.method;

import factory.AliPay;
import factory.Pay;

public class AliPayFactory implements PayFactory{

    @Override
    public Pay getPay() {
        return new AliPay();
    }
}

package factory.method;

import factory.AliPay;
import factory.Pay;

public class AliPayFactory implements PayFactory{

    @Override
    public Pay getPay() {
        return new AliPay();
    }
}

调用：

package factory.method;

import factory.Pay;
import factory.simple.SimplePayFactory;

public class Main {
    static public void main(String[] arg){
        PayFactory payFactory = new AliPayFactory();
        Pay pay = payFactory.getPay();
        pay.unifiedorder();
    }
}

抽象方法模式的缺点：当增加商品时，仍然需要修改代码。

3、抽象工厂方法模式

添加一个统一的建造工厂的工厂，利用简单工厂模式生产不同的工厂；这些工厂也同样继承了同样的接口，能够用同样的接口生产商品；每一个工厂可以生产多种商品，这些商品实现同一种接口

建造工厂的工厂：

package factory.abstractf;

public class FactoryProducer {
    static OrderFactory getFactory(String type){
        if (type.equalsIgnoreCase("wechat"))
            return new WechatOrderFactory();
        else if (type.equalsIgnoreCase("ali"))
            return new AliOrderFactory();
        return null;
    }
}

工厂的接口（工厂生产2中产品，Pay和Refund）

package factory.abstractf;

import factory.Pay;
import factory.Refund;

public interface OrderFactory {
    Pay getPay();
    Refund getRefund();
}

工厂的实现

package factory.abstractf;

import factory.Pay;
import factory.Refund;

public class AliOrderFactory implements OrderFactory{
    @Override
    public Pay getPay() {
        return null;
    }

    @Override
    public Refund getRefund() {
        return null;
    }
}

package factory.abstractf;

import factory.Pay;
import factory.Refund;

public class WechatOrderFactory implements OrderFactory {
    @Override
    public Pay getPay() {
        return null;
    }

    @Override
    public Refund getRefund() {
        return null;
    }
}

商品的接口

package factory;

public interface Pay {
    /**
     * 统一下单接口
     */
    void unifiedorder();
}

package factory;

public interface Refund {
    void unifiedrefund();
}

商品的实现有：AliPay、AliRefund、WechatPay、WechatRefund

*********************************************************************************

未完待续

*********************************************************************************

本文地址：https://blog.csdn.net/WilliamCode/article/details/110533132