设计模式的六大原则

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

使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化；设计模式是[软件工程]的基石脉络。

一，分类

创建型模式：5钟，对象实例化的模式，创建型模式用于解耦对象的实例化过程。
      _{工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。}
结构性模式：7种，把类或对象结合在一起形成一个更大的结构。
      _{适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。}
行为型模式：11种，类和对象如何交互，及划分责任和算法。
      _{策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式
        状态模式、访问者模式、中介者模式、解释器模式。}

设计模式的六大原则

总原则：开闭原则

开闭原则就是说对外扩展开放，对修改关闭。当程序需要扩展的时候，不去修改原有的代码，而是要扩展原有代码，实现一个热插拔的效果。为了达到这样的效果，需要实现抽象类和接口等。

1，单一责任原则

不要存在多于一个导致类变更的原因，也就是说每个类应该实现单一的职责，如若不然，就应该把类拆分。

2，里氏替换原则

里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范
里氏替换中，子类对父类的方法经量不要重写和重载，因为弗雷定义好了结构，通过规定的接口与外界交互，子类不应该随便的破坏它。

3，依赖倒转原则

这个是开闭原则的基础，具体内容：面向接口编程，依赖于抽象而不依赖于具体。写代码时用到具体类时，不与具体类交互，而与具体类的上层接口交互

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

这个原则的意思是：每个接口中不存在子类用不到却必须实现的方法，如果不然，就要将接口拆分。使用多个隔离的接口，比使用单个接口（多个接口方法集合到一个的接口）要好。

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

就是说：一个类对自己依赖的类知道的越少越好。也就是说无论被依赖的类多么复杂，都应该将逻辑封装在方法的内部，通过public方法提供给外部。这样当被依赖的类变化时，才能最小的影响该类。也就是说要求陌生的类不要作为局部变量出现在类中，

6，合成复用原则：

意思就是经量首先使用合成/聚合的方式，而不是使用继承。

基础知识：

1，接口和抽象类

接口：interface 接口仅是方法定义和常量值定义的接口，方法没有函数体。
抽象类：abstract 可定义普通类包含的所有内容，还可以定义抽象方法。
接口抽象类本身不能实列化，必须在相应的子类中实现抽象方法，才能获得应用。

java反射

https://www.jianshu.com/p/f1baa3000bdb

模式详解

重要的一些模式

1，单例模式

保证一个类仅有一个对象，并提供一个访问它的全局访问点。当系统需要某个类只能有一个实例时，就可以采用单例模式。
特点：单例类只有一个实例；单例类必须自己创建自己唯一的实例；单例类必须给其他所有对象
单例模式的实现方式

1，直接实例化。

public class singleton{
  private singleton(){ };
private static final singleton single = new singleton();
public static singleton getInstance(){
    return single;
      }
}

2，延迟话实现

 public static class Singleton2{
        private Singleton2(){}
        private static Singleton2 single = null;
        public static Singleton2 getInstance(){
            if(single == null){
                single = new Singleton2();
            }
            return  single;
        }
    }

延迟创建是线程不安全的，在多线程中可能会创建多个实例，所以需要改进。
1，完全同步方法
在原有的代码基础上的成员函数前面加上synchronized

public static  synchronized Singleton2 getInstance()

2，部分同步方法

public static class Singleton2{
        private Singleton2(){}
        private static Singleton2 single = null;
        public static   Singleton2 getInstance(){
            synchronized(Singleton2.class){
            if(single == null) {
                single = new Singleton2();
                }
            }
            return  single;
        }
    }

3，静态内部类

import java.lang.reflect.*;
import java.util.Scanner;

public class test {
 public static class Singleton3{
        private static class My{
            private static final Singleton3 single = new Singleton3();
        }
        private  Singleton3(){
            System.out.println("this is a new instance!");
        }
        public static final Singleton3 getInstance(){
            return My.single;
        }
    }
    public static void main(String []args)throws Exception {
        Scanner s = new Scanner(System.in);
        s.next();
        Singleton3 obj = Singleton3.getInstance();
        Singleton3 obj2 = Singleton3.getInstance();
    }

}

方法三与1，2相比最大的不同就是在于类中没有使用synchromized关键字，因而提高了java虚拟机的维护效率。它是通过静态内部类My来实现单例对象的。而且对象My.single是线程安全的。

工厂模式

当用户需要一个子类实例，并不希望与该类的子类形成耦合或者不知道该类有那些子类可用时，可采用工厂模式。当用户需要系统提供多个对象，且希望与创建对象解耦时，可采用抽象工厂模式。
工厂一般分为：简单工厂，工厂，抽象工厂三种情况，属于创建型设计模式。

简单工厂（静态工厂）

简单工厂模式功能类编制步骤如下所示：
1，定义抽象产品接口
2，定制具体产品子类
3，定制工厂类
简单工厂的特点：它是一个具体的类，非接口或者抽象类，其中有一个重要的create（）方法，利用if-else或者switch开关创建所需产品，并返回。
使用简单工厂的时候，通常不用创建简单工厂的类实例，因此可以把简单工厂类实现变成一个工具类，直接使用静态方法就好了。

工厂

工厂模式功能类编制步骤如下所示：
1，定义抽象产品接口
2，定制具体产品子类
3，定义抽象工厂类（或接口）
4，定制具体工厂子类
工厂模式和简单工厂模式的区别
工厂模式把简单工厂中具体的工厂类划分为两成：抽象工厂类+具体工厂子类层
当需要增加一种超高级汽车时候，简单工厂模式需要增加产品子类，并且需要修改工厂类里面的create（）方法。而工厂模式因为工厂类和产品类。

抽象工厂

抽象工厂中，抽象工厂类里面有两个重要的create（）方法。
应用实列：编写读文件功能

生成器模式

生成器模式是指将一个复杂对象的构建与他的表示分离，使用同样的构建过程可以创建不同的表示适用该模式的情景如下：对象结构复杂，利用构造方法创建无法满足用户需求；对象的创建过程必须独立创建该对象的类。
过程：
1，定义一个产品类，
2，定义n个生成器build类，当需求发生改变时，只需要增加或者删除相应的生成器类即可。
3，定义一个统一调度类（指挥官类）。
应用：更新表的时候

原型模式：

是指用原型实列制定创建对象的种类，并且通过复制这些原型创建新的对象
原型模式复制功能分为潜赋值和深复制两种

责任链模式

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连接成一条链，并沿着这条链来传递该请求。直到有一个对象处理它为止
责任链涉及的角色如下所示：
1，抽象处理者角色
2，具体请求者角色
3，客户角色。
。。。
配置文件+反射
反射的作用，一般形成的责任链是刚性的，当需求发生变化，我们就要链中需要增加或者减少节点，使用配置文件+反射技术，可以不用修改程序来满足需求分析的变化。
回调技术

命令模式

将一个请求封装成一个对象，从而使用户可用不同的请求对客户进行参数化；对请求排对或记录请求日志，以及支持可插销的操作
字如其名，命令模式就是命令发送者 通过发送不同都明令，使命令接受者完成任务。简单的老师发送给学生命令，让学生完成

package test.thread;

/**
 * 抽象命令接口
 */
interface ICommand{
    public void sweep();

}

/**
 * 命令接收者
 */
class student{
    public void sweep(){
        System.out.println("student sweeping");
    }

}

/**
 * 命令发送者
 */

class Teacher implements ICommand{
    private student receiver = null;
    public Teacher(student receiver){
        this.receiver = receiver;
    }
    public void sweep() {
        this.receiver.sweep();
    }

}

/**
 * 命令模式当中最重要的 Invoke 命令请求者类
 */
class Invoke{
    ICommand command;
    public Invoke(ICommand command){
        this.command =command;
    }

    public void executeM(){
        command.sweep();//启动方法
    }
}
public class mingling {
    /**
     * 将一个请求封装成一个对象，从而使用户可用不同的请求对客户进行参数化；对请求排对或记录请求日志，以及支持可插销的操作
     * 字如其名，命令模式就是命令发送者 通过发送不同都明令，使命令接受者完成任务。简单的老师发送给学生命令，让学生完成
     */

}

main函数里面的执行方法
student s = new student();
        Teacher t = new Teacher(s);
        Invoke invoke = new Invoke(t);
        invoke.executeM();
    }
执行解过是执行了里面的sweep方法。

未完待续

创建型模式

结构型模式

行为型模式

参考文章
https://www.jianshu.com/p/f1baa3000bdb
https://www.cnblogs.com/pony1223/p/7608955.html
https://www.cnblogs.com/pony1223/p/7608955.html