LAGOU21 常用的设计原则和设计模式

21.1 常用的设计原则（记住）
21.1.1 软件开发的流程
需求分析文档、概要设计文档、详细设计文档、编码和测试、安装和调试、维护和升级
21.1.2 常用的设计原则
开闭原则（Open Close Principle）：对扩展开放对修改关闭，为了使程序的扩展性好，易于维护和升级。
里氏代换原则（Liskov Substitution Principle）：任何基类可以出现的地方，子类一定可以出现，多使用多态的方式。
依赖倒转原则（Dependence Inversion Principle）：尽量多依赖于抽象类或接口而不是具体实现类，对子类具有强制性和规范性。
接口隔离原则（Interface Segregation Principle）：尽量多使用小接口而不是大接口，避免接口的污染，降低类之间的耦合度。
迪米特法则（最少知道原则）（Demeter Principle）：一个实体应当尽量少与其他实体之间发生相互作用，使系统功能模块相对独立。高内聚、低耦合
合成复用原则（Composite Reuse Principle）：尽量多使用合成/聚合的方式，而不是继承的方式。
下面的代码显示了合成复用原则：

package task21;
public class B{
	private A a;
	public B(A a){
		this.a=a;
	}
	public void test(){
		//调用A类中的show方法，请问如何实现？
		a.show();
	}
}

21.2 常用的设计模式
21.2.1 基本概念
设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
设计模式就是一种用于固定场合的固定套路。
21.2.2 基本分类
创建型模式-单例设计模式、工厂方法模式、抽象工厂模式等
结构型模式-装饰器模式、代理模式等
行为型模式-模板设计模式等
21.3 设计模式详解（重点）
21.3.1 单例设计模式
单例设计模式主要分为：饿汉式和懒汉式，懒汉式需要对多线程进行同步处理。
饿汉式代码如下：

package task21;

public class Singleton {
    //2.声明本类类型的引用指向本类类型的对象并使用private static关键字修饰
    private static Singleton sin=null;

    //1.私有化构造方法，使用private关键字修饰
    private Singleton(){}

    //3.提供公有的get方法负责将上述对象返回出去，使用public static关键字修饰
    public static /*synchronized*/ Singleton getInstance() {
        /*synchronized (Singleton.class) {
            if (null == sin) {
                sin = new Singleton();
            }
            return sin;
        }*/
        if (null==sin) {
            synchronized (Singleton.class) {
                if (null == sin) {
                    sin = new Singleton();
                }
            }
        }
        return sin;
    }
}

21.3.2 普通工厂模式
（1）基本概念
普通工厂方法模式就是建立一个工厂类，对实现了同一接口的不同实现类进行实例的创建。
（2）类图结构

(3) 主要缺点
在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，并且可能出现空指针异常。
下面是一个普通工厂模式的实现：
1.Sender接口

package task21;

public interface Sender {
    //自定义抽象方法来描述发送的行为
    void send();
}

2.MailSender类

package task21;

public class MailSender implements Sender{

    @Override
    public void send() {
        System.out.println("正在发送邮件....");
    }
}

3.SmsSender类

package task21;

public class SmsSender implements Sender{
    @Override
    public void send() {
        System.out.println("正在发送短信....");
    }
}

4.SendFactory类

package task21;

public class SendFactory {
    //自定义成员方法实现对象的创建
    public Sender produce(String type){
        if ("mail".equals(type))
        {
            return new MailSender();
        }
        if ("sms".equals(type))
        {
            return new SmsSender();
        }
        return null;
    }
}

5.测试用类

package task21;

public class SendFactoryTest {
    public static void main(String[] args) {
        //1.声明工厂类类型的引用指向工厂类类型的对象
        SendFactory sf=new SendFactory();
        //2.调用生产方法来实现对象的创建
        Sender sender=sf.produce("mail");
        //3.使用对象调用方法模拟正在发生的行为
        sender.send();
    }
}

输出结果为：正在发送邮件…
下面代码是一个对比，包含了对普通工厂模式优缺点的讨论：

package task21;

public class SendFactoryTest {
    public static void main(String[] args) {
        //缺点：代码复杂，可读性略差
        //优点：扩展性和可维护性更强！尤其是在创建大量对象的前提下
        //1.声明工厂类类型的引用指向工厂类类型的对象
        SendFactory sf=new SendFactory();
        //2.调用生产方法来实现对象的创建
        Sender sender=sf.produce("mail");
        //3.使用对象调用方法模拟正在发生的行为
        sender.send();

        System.out.println("--------------------------------");
        //优点：代码简单，可读性强 在创建单个对象时有优势
        //缺点：扩展性和可维护性略差
        Sender sender1=new MailSender();
        sender1.send();
    }
}

21.3.3 多个工厂方法模式
(1) 类图结构

(2) 主要缺点
在多个工厂方法模式中，为了能够正确创建对象，先需要创建工厂类的对象才能调用工厂类中的生产方法。
多个工厂模式修改了两个地方：
第一个地方-SendFactory类：

package task21;

public class SendFactory {
    //自定义成员方法实现对象的创建
    public Sender produce(String type){
        if ("mail".equals(type))
        {
            return new MailSender();
        }
        if ("sms".equals(type))
        {
            return new SmsSender();
        }
        return null;
    }

    public Sender produceMail(){
        return new MailSender();
    }
    public Sender produceSms(){
        return new SmsSender();
    }
}

第二个地方-测试用类：

package task21;

public class SendFactoryTest {
    public static void main(String[] args) {
        //缺点：代码复杂，可读性略差
        //优点：扩展性和可维护性更强！尤其是在创建大量对象的前提下
        //1.声明工厂类类型的引用指向工厂类类型的对象
        SendFactory sf=new SendFactory();
        //2.调用生产方法来实现对象的创建
        //Sender sender=sf.produce("mail");
        Sender sender=sf.produceMail();
        //3.使用对象调用方法模拟正在发生的行为
        sender.send();

        System.out.println("--------------------------------");
        //优点：代码简单，可读性强 在创建单个对象时有优势
        //缺点：扩展性和可维护性略差
        Sender sender1=new MailSender();
        sender1.send();

    }
}

21.3.4 静态工厂方法模式
(1) 类图结构

(2) 实际意义
工厂方法模式适合：凡是出现了大量的产品需要创建且具有共同的接口时，可以通过工厂方法模式进行创建。
(3) 主要缺点
工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序生产新的产品，就必须对工厂类的代码进行修改，这就违背了开闭原则。
静态工厂修改了两个类：
第一个地方-SendFactory类：

package task21;

public class SendFactory {
    //自定义成员方法实现对象的创建
    public Sender produce(String type){
        if ("mail".equals(type))
        {
            return new MailSender();
        }
        if ("sms".equals(type))
        {
            return new SmsSender();
        }
        return null;
    }

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

第二个地方-测试用类：

package task21;

public class SendFactoryTest {
    public static void main(String[] args) {
        //缺点：代码复杂，可读性略差
        //优点：扩展性和可维护性更强！尤其是在创建大量对象的前提下
        //2.调用生产方法来实现对象的创建
        Sender sender=SendFactory.produceMail();
        //3.使用对象调用方法模拟正在发生的行为
        sender.send();

        System.out.println("--------------------------------");
        //优点：代码简单，可读性强 在创建单个对象时有优势
        //缺点：扩展性和可维护性略差
        Sender sender1=new MailSender();
        sender1.send();

    }
}

21.3.5 抽象工厂模式
(1) 类图结构

Provider接口：

package task21;

public interface Provider {
    //自定义抽象方法描述产品的生产行为
    Sender produce();
}

MailSendFactory类：

package task21;

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

SmsSendFactory类：

package task21;

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

Sender接口：

package task21;

public interface Sender {
    //自定义抽象方法来描述发送的行为
    void send();
}

MailSender类：

package task21;

public class MailSender implements Sender{

    @Override
    public void send() {
        System.out.println("正在发送邮件....");
    }
}

SmsSender类：

package task21;

public class SmsSender implements Sender{
    @Override
    public void send() {
        System.out.println("正在发送短信....");
    }
}

测试用类：

package task21;

public class SendFactoryTest {
    public static void main(String[] args) {
        Provider provider=new MailSendFactory();
        Sender sender2=provider.produce();
        sender2.send();
    }
}

21.3.6 装饰器模式
(1) 基本概念
装饰器模式就是给一个对象动态的增加一些新功能，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。
(2) 类图结构

(3) 实际意义
可以实现一个类功能的扩展
可以动态的增加功能，而且还能动态撤销（继承不行）
缺点：产生过多相似的对象，不易排错
Soureceable接口：

package task21;

public interface Sourceable {
    //自定义抽象方法
    void method();
}

Source类：

package task21;

public class Source implements Sourceable{
    @Override
    public void method() {
        System.out.println("素颜美可以如此之美！");
    }
}

Decorator类：

package task21;

public class Decorator implements Sourceable{
    private Sourceable source;

    public Decorator(Sourceable source){
        this.source=source;
    }

    @Override
    public void method() {
        source.method(); //保证原有功能不变
        System.out.println("化妆之后你会更美！");
    }
}

测试用类：

package task21;

public class SourceableTest {
    public static void main(String[] args) {

        Sourceable sourceable=new Source();
        sourceable.method();

        System.out.println("--------------------------");
        //接下来使用装饰类实现功能
        Sourceable sourceable1=new Decorator(sourceable);
        sourceable1.method();
    }
}

输出结果为：

素颜美可以如此之美！
--------------------------
素颜美可以如此之美！
化妆之后你会更美！

21.3.7 代理模式
(1) 基本概念
代理模式就是找一个代理类代替原对象进行一些操作
比如我们在租房子的时候找中介，再如我们打官司的时候请律师，中介和律师在这里就是我们的代理
(2) 类图结构

(3) 实际意义
如果在使用的时候需要对原有的方法进行改进，可以采用一个代理类调用原有方法，并且对产生的结果进行控制，这种方式就是代理模式。
使用代理模式，可以将功能划分的更加清晰，有助于后期维护
(4) 代理模式和装饰器模式的比较
装饰器模式通常的做法是将原始对象作为一个参数传给装饰者的构造器，而代理模式通常在一个代理类中创建一个被代理类的对象。
装饰器模式关注于在一个对象上动态的添加方法，然而代理模式关注于控制对对象的访问。
Sourceable接口：

package task21;

public interface Sourceable {
    //自定义抽象方法
    void method();
}

Source类：

package task21;

public class Source implements Sourceable{
    @Override
    public void method() {
        System.out.println("素颜美可以如此之美！");
    }
}

Proxy类：

package task21;

public class Proxy implements Sourceable{

    private Source source;

    public Proxy(){
        source=new Source();
    }

    @Override
    public void method() {
        source.method();
        System.out.println("我和装饰器模式其实是不一样的！");
    }
}

测试用类：
package task21;

package task21;

public class SourceableTest {
    public static void main(String[] args) {
        System.out.println("--------------------------");
        Sourceable sourceable2=new Proxy();
        sourceable2.method();
    }
}

输出结果为：

--------------------------
素颜美可以如此之美！
我和装饰器模式其实是不一样的！

21.3.8 模板方法模式
(1) 基本概念
模板方法模式主要指一个抽象类中封装了一个固定流程，流程中的具体步骤可以由不同子类进行不同的实现，通过抽象类让固定的流程产生不同的结果。
(2) 类图结构

(3) 实际意义
将多个子类共有且逻辑基本相同的内容提取出来实现代码复用；
不同的子类实现不同的效果形成多态，有助于后期维护；
AbstractCalculator类：

package task21;

public abstract class AbstractCalculator {
    //自定义成员方法实现将参数指定的表达式按照参数指定的规则进行切割并返回计算结果
    public int splitExpression(String exp,String op){
        String[] sArr=exp.split(op);
        return calculate(Integer.parseInt(sArr[0]),Integer.parseInt(sArr[1]));
    }
    //自定义抽象方法实现运算
    public abstract int calculate(int ia,int ib);
}

Plus类：

package task21;

public class Plus extends AbstractCalculator {

    @Override
    public int calculate(int ia, int ib) {
        return ia+ib;
    }
}

Minus类：

package task21;

public class Minus extends AbstractCalculator{
    @Override
    public int calculate(int ia, int ib) {
        return ia-ib;
    }
}

测试用类：

package task21;

public class AbstractCalculatorTest {
    public static void main(String[] args) {
        AbstractCalculator abstractCalculator=new Plus();
        int res=abstractCalculator.splitExpression("1+1","\\+");
        System.out.println("最终的运算结果是："+res);
    }
}

运行结果是：最终的运算结果是：2