一、软件开发流程

需求分析文档、概要设计文档、详细设计文档、编码和测试、安装和调试、维护和升级

二、常用的设计原则
参考链接：https://www.cnblogs.com/dolphin0520/p/3919839.html

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

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

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

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

（5）迪米特法则（最少知道原则）（Demeter Principle）
一个实体应当尽量少与其他实体之间发生相互作用，使系统功能模块相对独立。
高内聚，低耦合。

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

三、常用的设计模式

（1）基本概念
设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验
的总结。
设计模式就是一种用于固定场合的固定套路。

（2）基本分类
创建型模式 - 单例设计模式、工厂方法模式、抽象工厂模式、…
结构型模式 - 装饰器模式、代理模式、…
行为型模式 - 模板设计模式、…

（3）设计模式详解（重点）

（1）单例模式
单例设计模式主要分为：饿汉式和懒汉式，懒汉式需要对多线程进行同步处理。
懒汉式线程同步 ```java package task21;

单例模式— 懒汉式线程同步
*/

public class Singleton { private static Singleton singleton=null;

public Singleton() {
}
public  static  /*synchronized */Singleton getInstance() {
    synchronized (Singleton.class) {
        if (singleton == null) {
           singleton = new Singleton();
        }
        return singleton;
    }
}

}


- 懒汉式线程同步优化
( 因为getInstance()方法的调用一般在第一次调用时进行判断，所以为了代码的执行效率，先在加锁前进行判断，如果为null，则进入锁机制，第一个线程创建完后，第二个线程再进入，而第二个线程进入后，singleton已经不再为null，直接返回singleton,由此提高的了代码的执行效率)
```java
package task21;
/*
* 单例模式-- 懒汉式   线程同步
* */
public class Singleton {
    private static Singleton singleton;
    public Singleton() {
    }
    public static  /*synchronized */Singleton getInstance() {
       /* synchronized (Singleton.class) {
            if (singleton == null) {
                 singleton = new Singleton();
            }
            return singleton;
        }*/
        if (null == singleton) { //只有第一次调用的时候才进行加锁
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

（2）普通工厂模式

2.1基本概念

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

2.2 代码实现

（根据类图编写代码）

package task21;
public interface Sender {
    void send();
}

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

package task21;
public class smsSender  implements  Sender{
    @Override
    public void send() {
        System.out.println("正在发送信息...");
    }
}

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;
    }
}

测试

package task21;
public class SenderFactoryTest {
    public static void main(String[] args) {
        //引用SendFactory的对象
        SendFactory sendFactory=new SendFactory();
        //创建mailSender对象
        Sender sender = sendFactory.produce("mail");
        //代用对象的方法
        sender.send();
    }
}

2.3 工厂模式的意义

比如要在new对象之前打印一句话，工厂模式只需要在prioduce（）方法中增加一条输出语句，而不需要手写太多的输出语句。

2.4 主要缺点

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

（3）多个工厂方法模式

解决普通工厂模式出现空指针的情况

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 SenderFactoryTest {
    public static void main(String[] args) {
        //引用SendFactory的对象
        SendFactory sendFactory=new SendFactory();
        //创建mailSender对象
        Sender sender = sendFactory.produce("mail");
        //代用对象的方法
        sender.send();
        System.out.println("-----------------------------------");
        Sender sender1 = sendFactory.produceMail();
        sender1.send();
    }
}

3.1 主要缺点

在多个工厂方法模式中，为了能够正确创建对象，先需要创建工厂类的对象才能调用工厂类中的生
产方法。

（4）静态工厂方法模式

package task21;
public class SendFactory {
    public static Sender produceMail(){
        return  new mailSender();
    }
    public static Sender produceSms(){
        return  new smsSender();
    }
}

生产方法都为静态方法，直接通过类名.调用

package task21;
public class SenderFactoryTest {
    public static void main(String[] args) {
        //引用SendFactory的对象
        SendFactory sendFactory=new SendFactory();
        //创建mailSender对象
        Sender sender = sendFactory.produce("mail");
        //代用对象的方法
        sender.send();
        System.out.println("-----------------------------------");
        Sender sender1 = sendFactory.produceMail();
        sender1.send();
        System.out.println("-----------------静态工厂模式");
        Sender sender2=SendFactory.produceMail();
        sender2.send();
    }
}

4.1 实际意义

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

4.2 实际意义

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

(5) 抽象工厂模式

使用该模式，不会违背开闭原则。

5.1代码的实现

package task21;
public interface Provider {
     Sender produce();
}

package task21;
public class MailFactory implements Provider{
    @Override
    public Sender produce() {
        return new mailSender();
    }
}

package task21;
public class SmsFactory  implements  Provider{
    @Override
    public Sender produce() {
        return new smsSender();
    }
}

package task21;
public class SenderFactoryTest {
    public static void main(String[] args) {
        //引用SendFactory的对象
        SendFactory sendFactory=new SendFactory();
        //创建mailSender对象
        Sender sender = sendFactory.produce("mail");
        //代用对象的方法
        sender.send();
        System.out.println("-----------------------------------");
        Sender sender1 = sendFactory.produceMail();
        sender1.send();
        System.out.println("-----------------静态工厂模式");
        Sender sender2=SendFactory.produceMail();
        sender2.send();
        System.out.println("------------------抽象工厂模式");
        Provider provider=new MailFactory();
        Sender sender3=provider.produce();
        sender3.send();
    }
}

5.2 扩展的优势

如需要增加一个packaget发送，只需要添加一个packageSender类和一个packagetFactory工厂类即可。

（6）装饰器模式

6.1基本概念

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

6.2 类图和代码

package task21;
public interface Sourceable {
    void method();
}

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

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 s2=new Decorator(sourceable);
        s2.method();
    }
}

(使用装饰模式就可以进行“动态修饰”)

6.3实际意义

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

（7）代理模式

7.1基本概念

代理模式就是找一个代理类替原对象进行一些操作。
比如我们在租房子的时候找中介，再如我们打官司需要请律师，中介和律师在这里就是我们的代
理。

7.2类图

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;
public class SourceableTest {
    public static void main(String[] args) {
        Sourceable sourceable=new Source();
        sourceable.method();
        System.out.println("---------------------装饰模式");
        Sourceable s2=new Decorator(sourceable);
        s2.method();
        System.out.println("-----------代理模式");
        Sourceable s3=new Proxy();
        s3.method();
    }
}

7.4 实际意义

如果在使用的时候需要对原有的方法进行改进，可以采用一个代理类调用原有方法，并且对产生的
结果进行控制，这种方式就是代理模式。
使用代理模式，可以将功能划分的更加清晰，有助于后期维护。

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

装饰器模式通常的做法是将原始对象作为一个参数传给装饰者的构造器，而代理模式通常在一个代
理类中创建一个被代理类的对象。
装饰器模式关注于在一个对象上动态的添加方法，然而代理模式关注于控制对对象的访问。

（8）模板方法模式

8.1基本概念

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

8.2类图结构

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 Minus extends AbstractCalculator {
    @Override
    public int calculate(int ia, int ib) {
        return ia - 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 AbstractCalculatorTest {
    public static void main(String[] args) {
        AbstractCalculator abstractCalculator = new Plus();
        int res = abstractCalculator.splitExpression("1+1", "\\+");
        System.out.println("最终的运算结果是：" + res); // 2
    }
}

8.3实际意义

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

20、常用的设计原则和设计模式

一、软件开发流程

二、常用的设计原则

（1）开闭原则（Open Close Principle）

（2）里氏代换原则（Liskov Substitution Principle）

（3）依赖倒转原则（Dependence Inversion Principle）

（4）接口隔离原则（Interface Segregation Principle）

（5）迪米特法则（最少知道原则）（Demeter Principle）

（6）合成复用原则（Composite Reuse Principle）

三、常用的设计模式

（1）基本概念

（2）基本分类

（3）设计模式详解（重点）

（1）单例模式