30-设计原则和设计模式

常用的设计原则----------------------------------------

软件开发的流程：需求分析文档、概要设计文档、详细设计文档、编码和测试、安装和调试、维护和升级

常用的设计原则----------------------------------------

开闭原则（Open Close Principle）：对扩展开放对修改关闭，为了使程序的扩展性好，易于维护和升级

package com.lagou.task21;

public abstract class Person {
    private String name;
    //private int age;
    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public abstract void show();
}

package com.lagou.task21;

public class SubPerson extends Person {
    private int age;

    @Override
    public void show() {

    }
}

里氏代换原则（Liskov Substitution Principle）：任何基类可以出现的地方，子类一定可以出现，多使用多态的方式

package com.lagou.task09;

/**
 *
 */
public class ShapeTest {
    //自定义成员方法实现将参数指定矩形对象特征打印出来的行为
    //也就是绘制图形的行为
    //Rect r = new Rect(1,2,3,4);
    //public static void draw(Rect r){
    //    r.show(); // 1 2 3 4
    //}
    //自定义成员方法实现将参数指定圆形对象特征打印出来的行为
    //public static void draw(Circle c){ //重载
    //    c.show(); // 1 2 3
    //}
    //自定义成员方法实现既能打印矩形对象又能打印圆形对象的特征
    //对象由参数传入，子类is a 父类
    //Shape r = new Rect(1,2,3,4);
    //Shape r = new Circle(1,2,3);
    //多态的使用场合之一，通过参数传递形成了多态
    public static void draw(Shape s){ //重载
        // 父类类型的引用指向子类类型的对象，这就是多态
        //编译阶段调用父类的版本，运行阶段调用子类重写后的版本
        s.show(); // 1 2 3 4
    }
    public static void main(String[] args) {
        //Rect r = new Rect(1,2,3,4);
        ShapeTest.draw(new Rect(1,2,3,4));
        ShapeTest.draw(new Circle(1,2,3));


    }
}

依赖倒转原则（Dependence Inversion Principle）：尽量多依赖于抽象类或接口而不是具体实现类，对子类具有强制性和规范性接口

即尽量有抽象类和接口

隔离原则（Interface Segregation Principle）：尽量多使用小接口而不是大接口，避免接口的污染，降低类之间耦合度

package com.lagou.task21;

public interface Animal {

    void run(); // 用于描述奔跑行为的抽象方法
    void fly(); // 用于描述飞行行为的抽象方法
}

package com.lagou.task21;

public interface RunAnimal {

    void run(); // 用于描述奔跑行为的抽象方法
}

package com.lagou.task21;

public interface FlyAnimal {

    void fly(); // 用于描述飞行行为的抽象方法
}

package com.lagou.task21;

public class Dog implements RunAnimal {
    @Override
    public void run() {

    }
}

迪米特法则（最少知道原则）（Demeter Principle）：一个实体应当尽量少与其他实体之间发生相互作用

使系统功能模块相对独立。高内聚，低耦合，与隔离原则类似，不有其他类的操作，而尽量独立

且尽量不可以有操作其他类的操作

合成复用原则（Composite Reuse Principle）：尽量多使用合成/聚合的方式，而不是继承的方式

package com.lagou.task21;

public class A {

    public void show() {
        System.out.println("这是A类中的show方法！");
    }
}

package com.lagou.task21;

public class B/* extends A*/ {
    private A a;  // 合成复用原则

    public B(A a) {
        this.a = a;
    }

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

常用的设计模式----------------------------------------

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结

设计模式就是一种用于固定场合的固定套路

基本分类----------------------------------------

创建型模式 - 单例设计模式、工厂方法模式、抽象工厂模式、…

结构型模式 - 装饰器模式、代理模式、…

行为型模式 - 模板设计模式、…

设计模式详解----------------------------------------

单例设计模式：单例设计模式主要分为：饿汉式 和 懒汉式，懒汉式需要对多线程进行同步处理

package com.lagou.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;
    }
}

普通工厂模式：普通工厂方法模式就是建立一个工厂类，对实现了同一接口的不同实现类进行实例的创建

类图结构

主要缺点：在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，并且可能出现空指针异常

package com.lagou.task21;

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

package com.lagou.task21;

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

package com.lagou.task21;

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

package com.lagou.task21;

public class SendFactory {
    // 自定义成员方法实现对象的创建
    public Sender produce(String type) {
        //System.out.println("随便加一句打印进行测试");
        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 com.lagou.task21;

public class SendFactoryTest {

    public static void main(String[] args) {

        // 缺点：代码复杂，可读性略差
        // 优点：扩展性和可维护性更强！  尤其是在创建大量对象的前提下
        //如：需要再创建对象的前面的打印一句话，那么这里可以直接在方法里写一句话
        //就可以应对大量的创建对象操作，否则的话，会写很多的打印的代码
        // 1.声明工厂类类型的引用指向工厂类类型的对象
        //SendFactory sf = new SendFactory();
        // 2.调用生产方法来实现对象的创建
        //Sender sender = sf.produce("mail");
        //Sender sender = sf.produce("maill");
        //Sender sender = sf.produceMail();
        Sender sender = SendFactory.produceMail();
        // 3.使用对象调用方法模拟发生的行为
        sender.send();

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

        System.out.println("-------------------------------------");
        Provider provider = new MailSendFactory();
        Sender sender2 = provider.produce();
        sender2.send();

        System.out.println("-------------------------------------");
        Provider provider1 = new PacketSendFactory();
        Sender sender3 = provider1.produce();
        sender3.send();
    }
}

多个工厂方法模式

类图结构

实际意义：工厂方法模式适合：凡是出现了大量的产品需要创建且具有共同的接口时，可以通过工厂方法模式进行创建

主要缺点：工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序生产新的产品，

必须对工厂类的代码进行修改，这就违背了开闭原则

抽象工厂模式----------------------------------------

类图结构

package com.lagou.task21;

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

package com.lagou.task21;

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

package com.lagou.task21;

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

package com.lagou.task21;

public class PacketSender implements Sender {
    @Override
    public void send() {
        System.out.println("正在发送包裹...");
    }
}

package com.lagou.task21;

public class PacketSendFactory implements Provider {
    @Override
    public Sender produce() {
        return new PacketSender();
    }
}

装饰器模式----------------------------------------

装饰器模式就是给一个对象动态的增加一些新功能，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例

类图结构

实际意义：可以实现一个类功能的扩展。可以动态的增加功能，而且还能动态撤销（继承不行）

缺点：产生过多相似的对象，不易排错

package com.lagou.task21;

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

package com.lagou.task21;

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

package com.lagou.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 com.lagou.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();

        System.out.println("---------------------------------------------------");
        Sourceable sourceable2 = new Proxy();
        sourceable2.method();
    }
}

package com.lagou.task21;

public class Proxy implements Sourceable {
    private Source source;

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

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

代理模式----------------------------------------

代理模式就是找一个代理类替原对象进行一些操作

比如我们在租房子的时候找中介，再如我们打官司需要请律师，中介和律师在这里就是我们的代理

类图结构

实际意义

如果在使用的时候需要对原有的方法进行改进，可以采用一个代理类调用原有方法

并且对产生的结果进行控制，这种方式就是代理模式。使用代理模式，可以将功能划分的更加清晰，有助于后期维护

代理模式和装饰器模式的比较----------------------------------------------

装饰器模式通常的做法是将原始对象作为一个参数传给装饰者的构造器

而代理模式通常在一个代理类中创建一个被代理类的对象

装饰器模式关注于在一个对象上动态的添加方法，然而代理模式关注于控制对对象的访问

模板方法模式----------------------------------------

模板方法模式主要指一个抽象类中封装了一个固定流程

流程中的具体步骤可以由不同子类进行不同的实现，通过抽象类让固定的流程产生不同的结果

类图结构

实际意义

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

package com.lagou.task21;

public abstract class AbstractCalculator {

    // 自定义成员方法实现将参数指定的表达式按照参数指定的规则进行切割并返回计算结果  1+1  +
    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);
}

package com.lagou.task21;

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

package com.lagou.task21;

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

package com.lagou.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
    }
}

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

package com.lagou.task21;

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

package com.lagou.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
    }
}