设计模式（实现的功能，相当于使用场景+原理级别实现的记录）

设计模式的总结：设计模式是使用类之间的继承，接口，类的聚合，组合关系，实现良好的扩展结构

创建模式

单例模式：创建单实例的方法

工厂模式，复杂对象的创建交由工厂实现，用户不用关心创建的过程

其中，简单工厂模式，工厂根据传入的值不同，创建不同的对象

工厂模式：将工厂作为一个抽象的类，只有共性功能，个性化的工厂功能实现，交由子类的工厂实现

抽象工厂模式：工厂和创建的对象都是抽象方法，由子类去实现

建造者模式：对象的创建由derctor指引，实际的创建交由建造者，建造者聚合到derctor，创建的过程可以修改

原型模式：使用clone技术或者反序列化的方法，实现对象的克隆，也就是创建后的对象不会因为原来的对象修改而修改

行为模式：适配器模式：间原由的类扩展为客户端希望的类装饰者模式：对类原因的功能实现功能的增强享元模式：分为共性的方法和个性的方法，个性的方法需要实现，聚合到工厂类，工厂类中由容器，对于已经创建的相同对象，只在容器中获取（线程私池）代理模式：对原有的类进行功能扩张

行为模式：模板模式；模板方法是抽象方法，有了模板实现方法，子类只要实现个性化的方法

观察者模式（被动触发观察者）在观察者有状态变化时，触发观察者的方法

策略模式（主动触发策略）直接使用聚合策略的方法

设计模式的原则： 1、单一职责原则（不同的功能模块由不同的类实现或者方法）（目的：减低类的复杂读，提高可读性，可维护性，降低变更出现问题的风险，通常情况下，需要）如果不是很复杂的程序，需要遵守单一原则 2、接口隔离原则（每个类的依赖的（使用的）接口，里面的方法必须都是需要使用的，也就是接口里面的所有方法都是有用的）底层代码接口，抽象类，变量，尽量使用接口（可以实现功能的扩展）

3、依赖倒转原则（面向接口编程，细节依赖抽象，而不是抽象依赖细节，低层级依赖高层级）依赖的三种方式接口实现构造器实现 set方法实现 4、李氏替换原则尽量减少对父类的重写，这样会减低程序的复用性，尤其是在多态频繁使用的场景

解决方法，将子类和父类继承更高级的父类，使用依赖，聚合组合的方式替代

5、开闭原则（对扩展开发，对修改关闭）新的功能尽量增加新的代码而不是修改原来的代码，比如增加新的功能，创建新的类，传入固定的类，而不是改变固定的类

6、迪米特法则对自己依赖的类，知道的越少越好，方法尽可能地封装到自己的类中，其他地类只需简单地调用尽量不要出现直接地变量涉及到其他地类

7、合成复用原则（尽量使用合成聚合地方式，而不直接使用继承）也就是使用set方法，构造器方法或者new，来替代继承该类

unl 类间的关系：依赖（a类用到了b，则a依赖b）泛化（继承）实现（接口实现）关联（是否有定义成员变量）聚合（类中只声明其他类）可分割组合（类中创建了其他类）不可分割

设计模式的分类

设计模式的目的是提高软件系统的可维护性，扩展性，减低系统的代码复杂度

单例模式，工厂模式，抽象工厂模式，建造者模式，原型模式，修饰者模式，适配器模式，桥接模式，享元模式

单例模式

饿汉式（静态变量）

构造器私有化（防止new）类的内部创建对象向外暴露静态方法getinstance 优点：在类加载的时候创建，避免多线程问题，实现简单缺点：类不一定只是在getinstance的时候才加载，可能浪费内存资源

方法说明，构造方法私有化是为了避免使用new方法创建多个对象，同时类的内部可以调用来创建对象；对外暴露的方法使用静态方法，保证可以访问该类的方法，

懒加载使用双重检查法

静态内部类实现单例模式

静态内部类在类加载的时候，是不会加载的，只有再条用方法的时候，实例对象才会执行

单例模式使用的场景：频繁使用的对象

工厂模式

简单工厂模式（对象的创建由工厂根据传入的标志类型而创建不同类型的工厂）工厂根据传入的类型返回需要的对象，这个对象是频繁会被修改的，其调用者是频繁被多个地方使用的，这样，使用的客户类和工厂是低耦合的，修改工厂的类，不需要大量去修改客户端的类

工厂模式；相对于简单工厂模式，将工厂作为一个抽象的类，只有共性功能，具体的工厂功能实现，交由子类的工厂实现，并将工厂组合到客户端类crder类中，相对于简单工厂模式，工厂模式为的工厂更有扩展性，调用具体的工厂实现功能，（客户端类抽象类，与工组合关于）

抽象工厂，工厂类是一个接口，有子类去实现，抽象接口，order类聚合抽象工厂（客户端类和工厂的接口聚合的关系）

使用场景： 1、当不知道使用的对象确切类型时 2、希望为框架提供扩展方法时

优点：

将具体产品和创建者解耦

符合单一职责原则

符合开闭原则

public class designermodal{
    public static void main(String[] args) {
        Application2 application2 =  new createproductA();
        Product product = application2.GetObject();
        //这里的Product为多态，虽然执行的 product.method1();，但是会根据不同的实现类，执行不同的方法

        product.method1();
    }
}

interface Product {
    public void method1();
}

abstract class Application2{
   abstract Product creatproduct();

   Product GetObject(){
       Product   product =  creatproduct();
       return product;
   }

}

class createproductA1 extends Application2{

    @Override
    Product creatproduct() {
        return new productA();
    }
}


class createproductA extends Application2{

    @Override
    Product creatproduct() {
        return new productB();
    }
}

class productA implements  Product{
    public void method1(){
        System.out.println("method1");
    }
}

class productB implements  Product{
    public void method1(){
        System.out.println("method2");
    }
}

抽象工厂模式（工厂和工厂的方法都是接口，由新的需求，只需要实现这些方法）优点： 1、可以确定，从工厂得到的方法，彼此是兼容的

2、可以避免客户端代码和产品的代码紧密耦合

3、符合单一职责原则

4、符合开闭原则

public class abstractfactory {
    public static void main(String[] args) {
        databaseutil idatabaseutil = new oracleDatabaseUtil();
        Iconnection connection = idatabaseutil.getConnection();
        connection.connect();
        Icommand icommand = idatabaseutil.getIcommand();
        icommand.command();
    }
}

interface Iconnection{
    void connect();
}

interface Icommand{
    void command();
}
//抽象工厂模式，工厂方法接口（方法和类都是接口组成的）
interface databaseutil{
    Iconnection  getConnection();
    Icommand   getIcommand();
}



    class MySqlConnection implements Iconnection{

        @Override
        public void connect() {
            System.out.println("mysql connected.");
        }
    }



class MySqlCommond implements Icommand{


    @Override
    public void command() {
        System.out.println("mysql command.");
    }
}

class mysqlDatabaseUtil implements  databaseutil{

    @Override
    public Iconnection getConnection() {
        return new MySqlConnection();
    }

    @Override
    public Icommand getIcommand() {
        return new MySqlCommond();
    }
}

class oracleconmand implements Icommand{
    @Override
    public void command() {
        System.out.println("oracleconnect.");
    }
}

class   oracleconnect implements Iconnection{

    @Override
    public void connect() {
        System.out.println("oracleconmand");
    }
}

class oracleDatabaseUtil implements  databaseutil{

    @Override
    public Iconnection getConnection() {
        return new oracleconnect();
    }

    @Override
    public Icommand getIcommand() {
        return new oracleconmand();
    }
}

建造者模式:（specialconcreateprobuider聚合到director，director获取参数，内部调用specialconcreateprobuider的创建方法创建对象）

优缺点：用户不需要知道创建的复杂过程

使用场景：不用知道建造过程，就可以构建不同的东西。在构建地图的过程中，也就是用户委托Director这个类去构建对象

对象的创建比较复杂， specialconcreateprobuider（负责创建需要的对象）个性化创建需要的构造者 director（负责传入参数）可以共用，知道对象的创建

优点：建造者独立，容易扩展

工厂方法和建造者方法的区别：它们目的都是创建一个复杂的对象工厂模式注重的是整体对象的创建方法，而建造者模式注重的是对象的创建过程，创建对象的过程方法可以在创建时自由调用。

package main.java;

public class productModel {
    public static void main(String[] args) {
        productbuilder specialconcreateprobuider = new specialconcreateprobuider();
        Director director = new Director(specialconcreateprobuider);
        product product = director.makeProductor("aa", "bb", "cc", "dd", "ee", "ee");
        System.out.println(product);

    }
}
class Director{
    private productbuilder builder;

    public Director(productbuilder builder) {
        this.builder = builder;
    }

    public product
    makeProductor(String productname, String productcompany, String part1, String part2, String part3, String part4){
        builder.builderProductcompany(productname);
        builder.builderProductname(productcompany);
        builder.builderProductpart1(part1);
        builder.builderProductpart2(part2);
        builder.builderProductpart3(part3);
        builder.builderProductpart4(part4);
        product build = builder.build();
        return build;
    }
}

interface productbuilder{
    void builderProductname(String Productname);
    void builderProductcompany(String Productcompany);
    void builderProductpart1(String part1);
    void builderProductpart2(String part2);
    void builderProductpart3(String part3);
    void builderProductpart4(String part4);
     product build();
}

class defualtconcreateprobuider implements productbuilder{
    private String Productname;
    private String Productcompany;
    private String part1;
    private String part2;
    private String part3;
    private String part4;
    @Override
    public void builderProductname( String Productname ) {
        this.Productname =Productname;
    }

    @Override
    public void builderProductcompany( String Productcompany) {
        this.Productcompany =Productcompany;
    }

    @Override
    public void builderProductpart1(String part1) {
        this.part1 = part1;
    }

    @Override
    public void builderProductpart2(String part2) {
        this.part2 = part2;
    }

    @Override
    public void builderProductpart3(String part3) {
        this.part3 = part3;
    }

    @Override
    public void builderProductpart4(String part4) {
        this.part4 = part4;
    }

    @Override
    public product build() {
        return new product(this.Productname,this.Productcompany,this.part1,this.part2 ,this.part3, this.part4);
    }


}

class specialconcreateprobuider implements productbuilder{
    private String Productname;
    private String Productcompany;
    private String part1;
    private String part2;
    private String part3;
    private String part4;
    @Override
    public void builderProductname( String Productname ) {
        this.Productname =Productname;
    }

    @Override
    public void builderProductcompany( String Productcompany) {
        this.Productcompany =Productcompany;
    }

    @Override
    public void builderProductpart1(String part1) {
        this.part1 = part1;
    }

    @Override
    public void builderProductpart2(String part2) {
        this.part2 = part2;
    }

    @Override
    public void builderProductpart3(String part3) {
        this.part3 = part3;
    }

    @Override
    public void builderProductpart4(String part4) {
        this.part4 = part4;
    }

    @Override
    public product build() {
        return new product(this.Productname,this.Productcompany,this.part1,this.part2 ,this.part3, this.part4);
    }


}

class product{
    private String Productname;
    private String Productcompany;
    private String part1;
    private String part2;
    private String part3;
    private String part4;

    public product() {

    }

    public product(String productname, String productcompany, String part1, String part2, String part3, String part4) {
        Productname = productname;
        Productcompany = productcompany;
        this.part1 = part1;
        this.part2 = part2;
        this.part3 = part3;
        this.part4 = part4;
    }
}

建造者模式2 product2类的 Builder()静态类植入值，静态方法.bulid();执行创建

应用场景：

需要生成的对象有复杂的内部结构需要生成的对象内部属性本身相互依赖与不可变对象配合使用

package main.java;
public class productModel2 {
    public static void main(String[] args) {
        product2 bulid = new product2.Builder().Productname("aa").part1("bb").bulid();
        System.out.println(bulid);
    }
}

class product2 {
    private final String Productname;
    private final String Productcompany;
    private final String part1;
    private final String part2;
    private final String part3;
    private final String part4;

    static class Builder{
        private String Productname;
        private String Productcompany;
        private String part1;
        private String part2;
        private String part3;
        private String part4;

        public Builder Productname(String productname) {
            this.Productname = Productname;
            return this;
        }
        public Builder part1(String part1) {
            this.part1 = part1;
            return this;
        }
        public Builder part2(String part2) {
            this.part2 = part2;
            return this;
        }
        public Builder part3(String part3) {
            this.part3 = part3;
            return this;
        }
        public Builder part4(String part4) {
            this.part4 = part4;
            return this;
        }
        product2 bulid(){

            return  new product2(this.Productname,this.Productcompany,this.part1,this.part2,this.part3,this.part4);
        }
    }

    public product2(String productname, String productcompany, String part1, String part2, String part3, String part4) {
        Productname = productname;
        Productcompany = productcompany;
        this.part1 = part1;
        this.part2 = part2;
        this.part3 = part3;
        this.part4 = part4;
    }

    @Override
    public String toString() {
        return "product2{" +
                "Productname='" + Productname + '\'' +
                ", Productcompany='" + Productcompany + '\'' +
                ", part1='" + part1 + '\'' +
                ", part2='" + part2 + '\'' +
                ", part3='" + part3 + '\'' +
                ", part4='" + part4 + '\'' +
                '}';
    }
}

原型模式（目的的将原型的对象复制一份，但是复制的对象和原来的对象是独立的，也就是引用的对象不同，在修改复制的对象时，原本的对象不会改变）

原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象（如果是mutable或者是基本数据类型，String类，只需要浅拷贝即可；如果是对象里有可变的对象，则该对象需要进行深拷贝）浅拷贝:只是将指针引用的深拷贝：复制一个对象

实现的方式由clone方法和序列化方法

clone是利用java的clone，将对象复制一份

序列化是将对象输出再输入，指针赋给当前的值实现深度拷贝

序列化方法

clone方法

 product3 clone = (product3) super.clone();
        BaseInfo clone1 = (BaseInfo) this.baseInfo.clone();
        clone.setBaseInfo(clone1);


package main.java;

public class yxms {
    public static void main(String[] args) throws CloneNotSupportedException {
        BaseInfo gg = new BaseInfo("gg");
        product3 product3 = new product3("a", "b", "c", "d", "e", "f",gg);
        product3 clone = product3.clone();
        clone.getBaseInfo().setCompanyname("aaaaaa");
        clone.setPart1("bbbbbbbbbbbbbbbb");
        System.out.println(product3);
        System.out.println(clone);
    }
}

class BaseInfo implements Cloneable{
    private String companyname;

    public BaseInfo(String companyname) {
        this.companyname = companyname;
    }

    public String getCompanyname() {
        return companyname;
    }

    public void setCompanyname(String companyname) {
        this.companyname = companyname;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return super.hashCode()+"BaseInfo{" +
                "companyname='" + companyname + '\'' +
                '}';
    }
}

class product3 implements  Cloneable{
    private String Productname;
    private String Productcompany;
    private String part1;
    private String part2;
    private String part3;
    private String part4;
    private BaseInfo baseInfo;

    public BaseInfo getBaseInfo() {
        return baseInfo;
    }

    public void setBaseInfo(BaseInfo baseInfo) {
        this.baseInfo = baseInfo;
    }

    public String getProductname() {
        return Productname;
    }

    public String getProductcompany() {
        return Productcompany;
    }

    public String getPart1() {
        return part1;
    }

    public String getPart2() {
        return part2;
    }

    public String getPart3() {
        return part3;
    }

    public String getPart4() {
        return part4;
    }

    public product3() {

    }

    public void setProductname(String productname) {
        Productname = productname;
    }

    public void setProductcompany(String productcompany) {
        Productcompany = productcompany;
    }

    public void setPart1(String part1) {
        this.part1 = part1;
    }

    public void setPart2(String part2) {
        this.part2 = part2;
    }

    public void setPart3(String part3) {
        this.part3 = part3;
    }

    public void setPart4(String part4) {
        this.part4 = part4;
    }

    @Override
    protected product3 clone() throws CloneNotSupportedException {
        product3 clone = (product3) super.clone();
        BaseInfo clone1 = (BaseInfo) this.baseInfo.clone();
        clone.setBaseInfo(clone1);
        return clone;
    }

    public product3(String productname, String productcompany, String part1, String part2, String part3, String part4,BaseInfo baseInfo) {
        Productname = productname;
        Productcompany = productcompany;
        this.part1 = part1;
        this.part2 = part2;
        this.part3 = part3;
        this.part4 = part4;
        this.baseInfo = baseInfo;
    }

    @Override
    public String toString() {
        return super.hashCode()+"product3{" +
                "Productname='" + Productname + '\'' +
                ", Productcompany='" + Productcompany + '\'' +
                ", part1='" + part1 + '\'' +
                ", part2='" + part2 + '\'' +
                ", part3='" + part3 + '\'' +
                ", part4='" + part4 + '\'' +
                ", baseInfo=" + baseInfo +
                '}';
    }
}

享元模式：实际中的String，池技术都用到，将多个功能的共同点整合到同一份代码实例（如果没有，就创建，如果由，就使用原来的）所有享元里面会有一个容器进行存储。图说明：

flyweight：抽象的类，产品的抽象类，同时定义了抽象的公共方法*(内部状态)和个性化的方法（外部状态）接口或实现 concreatFlyweight：实现享元的方法 unsharedConcretaFlyweight ：实现个性化的方法 flyweightfactory：享元工厂类，用于构建池容器（集合），同时提供从池中获取对象的方法

实现的说明： websiteFactory负责用于构建池容器（集合），同时提供从池中获取对象的方法 unsharedConcretaFlyweight = user concreatFlyweight = website

public class xyms {
    public static void main(String[] args) {
        websiteFactory websiteFactory = new websiteFactory();
        website website = websiteFactory.getwebsitecatory("新闻");
        website website2 = websiteFactory.getwebsitecatory("新闻2");

        website.use(new user("nbb"));
        website2.use(new user("nxx"));
        System.out.println(websiteFactory.getpoolsize());
    }
}

class user{
    private  String name;

    public String getName() {
        return name;
    }

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

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

    @Override
    public String toString() {
        return "user{" +
                "name='" + name + '\'' +
                '}';
    }
}

abstract class website{
    abstract public void  use(user a);
}

class Concreatwebsite extends website{
private String type="";

    public Concreatwebsite(String type) {
        this.type = type;
    }

    @Override
    public void use(user a) {
        System.out.println("Concreatwebsite"+type+a);
    }
}


//厂类，根据需求，返回类
class websiteFactory{

    private HashMap<String ,website> pool = new HashMap<>();
    //根据网站类型返回一个网站，如果没有，就创建一个网站，放入到连接池中
    public website getwebsitecatory(String type){
        if(!pool.containsKey(type)){
            pool.put(type,new Concreatwebsite(type));
        }
        return pool.get(type);
    }
        //获取池中有多少实例的类型
    public int getpoolsize(){
        return pool.size();
    }
}

享元模式的integer实现

门面模式：减低客户端使用的复杂度，在实现某各功能时，需要用到class 1、 2、3，门面模式使用的facade管理下面的类，客户端只需要看facade而不需关注里面的实现类

优点，客户端不需要连接底层复杂的调用，减低开服复杂度


public class mmmshi {
    public static void main(String[] args) {
        facades facades = new facades();
        facades.dosomething();
    }
}
class facades{

    subsystem1  subsystem = new subsystem1();
    subsystem2  subsystemb = new subsystem2();
    subsystem3  subsystemc = new subsystem3();

    public void dosomething(){
        subsystem.method1();
        subsystemb.method1();
        subsystemc.method1();
   }
}
class subsystem1{
public void method1(){
    System.out.println("method1");
}
}
class subsystem2{
    public void method1(){
        System.out.println("method2");
    }
}
class subsystem3{
    public void method1(){
        System.out.println("method3");
    }
}

适配器模式：（对现有的类的增强（聚合进适配器，实现对功能扩展））

对象是配置模式：实现方法，适配器adpter获取被适配的对象adaptee，处理完后，输出

使用场景：1、希望使用某些现有类，但其接口与其他代码不兼容时，使用适配器模式

2、当希望重用几个现有的子类，这些子类缺少一些不能添加到超类的公共功能时，可以使用该模式

对象适配器模式


public class adapter1 {
    public static void main(String[] args) {
        Target adapter = new Adapter(new adaptee());
        int i = adapter.output5v();
        System.out.println(i);
    }
}
class adaptee{
    public int output220(){
       return 220;
    }
}
interface Target{
    int output5v();
}
class Adapter implements Target{
private  adaptee aa;

    public Adapter(adaptee aa) {
        this.aa = aa;
    }

    @Override
    public int output5v() {
        int i = aa.output220();
        //适配i

        return i-100;
    }
}

继承实现适配器模式（适配器继承了adapee，缺点时其他的方法都暴露）

装饰者模式：在不修改源对象的基础上，将功能附加在对象上

实现方法：

定义标准的抽象类component 原来已有的功能继承抽象类

decorator继承component，构造方法传入component类，同时处理需要增强的功能 concreaderector是多次功能的选择

Component：抽取被装饰者

decoretor ：装饰类，包含被装饰的对象，因为装饰者和被装饰者都是继承同一个抽象类，所有对外部的代码不会产生影响，通过装饰器，可以修改被修饰者的属性值

优缺点：无需修改现有对象，也无需创建对象的子类，即可扩展对象的功能。可以多扩展功能进行动态添加或删除可以扩展不同的装饰者来解决扩展不同功能的问题缺点：多层装饰会比较复杂，无法控制装饰的顺序

装饰者模式和适配器模式的区别：装饰者模式（Decorator Pattern）是指在不改变原有对象的基础之上，将功能附加到对象上，提供了比继承更有弹性的替代方案（扩展原有对象的功能），属于结构型模式。 1、用于扩展一个类的功能或给一个类添加附加职责。 2、动态的给一个对象添加功能，这些功能可以再动态的撤销。

适配器模式（Adapter Pattern）是指将一个类的接口转换成客户期望的另一个接口，使原本的接口不兼容的类可以一起工作，属于结构型设计模式。

package main.java.sjms;

public class decoreationtest1 {
    public static void main(String[] args) {
       Drink coffeB = new Chocolate(new Chocolate(new Milke(new CoffeB())));
        System.out.println(coffeB.des());
        System.out.println(coffeB.cost());
    }

}
abstract class Drink{
    private float price;
    public String des;

    public float getPrice() {
        return price;
    }

    public void setPrice(float price) {
        this.price = price;
    }

    public String getDes() {
        return des;
    }

    public void setDes(String des) {
        this.des = des;
    }

    public abstract float  cost();
    public abstract String des();
}

class Coffe extends Drink{

    @Override
    public float cost() {
        return super.getPrice();
    }

    @Override
    public String des() {
        return super.getDes();
    }


}
class CoffeB extends Coffe{

    public CoffeB() {
        setPrice(1.0f);
        setDes("黑卡");
    }
}
class CoffeC extends Coffe{

    public CoffeC() {
        setPrice(1.0f);
        setDes("白卡");
    }
}
class CoffeD extends Coffe{

    public CoffeD() {
        setPrice(1.0f);
        setDes("aa卡");
    }
}

class Decorator extends Drink{
    private Drink obj;

    public Decorator(Drink obj) {
        this.obj = obj;
    }

    public float cost() {
        return obj.cost()+super.getPrice();
    }

    @Override
    public String des() {
        return  super.getDes()+"%%"+obj.des() ;
    }

}

class Chocolate extends Decorator{

    public Chocolate(Drink obj) {
        super(obj);
        setDes("巧克力");
        setPrice(1.0f);
    }
}
class Milke extends Decorator{
    public Milke(Drink obj) {
         super(obj);
            setDes("Milke");
            setPrice(1.0f);
        }
    }

class doujain extends Decorator{
    public doujain(Drink obj) {
        super(obj);
        setDes("doujain");
        setPrice(1.0f);
    }
}