image.png

设计模式简述

创建型模式(共五种):

• 工厂方法模式、
• 抽象工厂模式、
• 单例模式、
• 建造者模式、
• 原型模式.

结构型模式(共七种):

• 适配器模式、
• 装饰器模式、
• 代理模式、
• 外观模式、
• 桥接模式、
• 组合模式、
• 享元模式.

行为型模式(共十一种):

• 策略模式、
• 模板方法模式、
• 观察者模式、
• 迭代子模式、
• 责任链模式、
• 命令模式、
• 备忘录模式、
• 状态模式、
• 访问者模式、
• 中介者模式、
• 解释器模式

image.png

设计模式的六大原则

• 开闭原则（Open Close Principle） 开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。

• 里氏代换原则（Liskov Substitution Principle） 里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。—— From Baidu 百科

• 依赖倒转原则（Dependence Inversion Principle） 这个是开闭原则的基础，具体内容：真对接口编程，依赖于抽象而不依赖于具体。

• 接口隔离原则（Interface Segregation Principle） 这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。

• 迪米特法则（最少知道原则）（Demeter Principle） 为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。

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

image.png

工厂方法模式

• 工厂模式，属于类创建型模式，工厂父类（接口）负责定义产品对象的公共接口，而子类工厂则负责创建具体的产品对象。

• 目的：是为了把产品的实例化操作延迟到子类工厂中完成，通过工厂子类来决定究竟应该实例化哪一个产品具体对象。

• 工厂方法模式包含四个部分：
  1.抽象产品：产品对象同一的基类，或者是同一的接口
  2.具体的产品：各个不同的实例对象类
  3.抽象工厂：所有的子类工厂类的基类，或是同一的接口
  4.具体的工厂子类：负责每个不同的产品对象的实际创建

public class HumanFactory extends AbsHumanFactory {
    
    @SuppressWarnings("unchecked")
    @Override
    public <T extends Human> T createHumen(Class<T> tClass) {
        Human humen=null;
        try {
            humen= (T) Class.forName(tClass.getName()).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return (T)humen;
    }
}

抽象工厂

public abstract class AbsHumanFactory {
    
    public abstract <T extends Human> T createHumen(Class<T> tClass);
    
}

建造者模式

建造者模式，顾名思义的就是类似建房子，有一个固定的流程。
建造者模式有一个固定的建造过程。
建造者模式实现了依赖倒转原则，抽象不应该依赖细节，细节应该依赖与抽象。
建造者模式的定义是：将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。
建造者模式的角色定义，在建造者模式中存在以下4个角色：

• builder: 为创建一个产品对象的各个部件指定抽象接口
• ConcreteBuilder: 实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示，并提供一个检索产品的接口
• Director: 构造一个使用Builder接口的对象
• Product: 表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程，
  包含定义组成部件的类，包括将这些部件装配成最终产品的接口

public class XMan {
    
    private String name;
     
    private Integer age;
    
    private String xFactor;
    
    private String lover;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public XMan setAge(Integer age) {
        this.age = age;
        return this;
    }

    public String getxFactor() {
        return xFactor;
    }

    public XMan setxFactor(String xFactor) {
        this.xFactor = xFactor;
        return this;
    }

    public String getLover() {
        return lover;
    }

    public XMan setLover(String lover) {
        this.lover = lover;
        return this;
    }
}

public class WolverineDirector {
    
    public XMan constructWolverine(WolverineBuilder wolverineBuilder) {
        return wolverineBuilder
                .buildXFactor()
                .buildLover()
                .buildName()
                .buildAge()
                .buildXman();
    }
}


public class WolverineBuilder implements XManBuilder {
    
    XMan mXMan;
    
    WolverineBuilder() {
        mXMan = new XMan();
    }
    
    // need to consider 

   /* @Override
    public WolverineBuilder buildXFactor() {
        mXMan.setxFactor("claw");
        System.out.println(mXMan.getxFactor());
        return this;
    }*/
    
    @Override
    public XManBuilder buildXFactor() {
         mXMan.setxFactor("claw");
         System.out.println(mXMan.getxFactor());
         return this;
    }

    @Override
    public WolverineBuilder buildLover() {
        mXMan.setLover("Jane");
        System.out.println(mXMan.getLover());
        return this;
    }

    @Override
    public WolverineBuilder buildName() {
        mXMan.setName("Wali");
        System.out.println(mXMan.getName());
        return this;
    }
    
    @Override
    public WolverineBuilder buildAge() {
        mXMan.setAge(18);
        System.out.println(mXMan.getAge());
        return this;
    }
    
    @Override
    public XMan buildXman() {
        System.out.println("Wolverine is successfully built");
        return mXMan;
    }

}


public interface XManBuilder {
    
    XManBuilder buildXFactor();
    
    XManBuilder buildLover();
    
    XManBuilder buildName();
    
    XManBuilder buildAge();
    
    XMan buildXman();
}

单例模式

Singleton的静态属性instance中，只有instance为null的时候才创建一个实例，构造函数私有，确保每次都只创建一个，避免重复创建

public class Singleton {
    
    /**
     * 防止外部创建实例 私有 
     * Singleton.
     */
    private Singleton() {

    }
    
    /**
     * 唯一实例 
     * 内存可见性：通俗来说就是，线程A对一个volatile变量的修改，对于其它线程来说是可见的，即线程每次获取volatile变量的值都是最新的。
     * https://www.cnblogs.com/chengxiao/p/6528109.html
     */
    private static volatile Singleton mInstance;

    public static Singleton getInstance() {
        
        if (mInstance == null) {//第一个锁，如果没有实例
            
            /**
             * 第二个锁，如果没有任何线程创建Singleton实例  对象锁 - 若多个线程拥有同一个MyObject类的对象，则这些方法只能以同步的方式执行
             * https://www.cnblogs.com/hapjin/p/5452663.html
             */
            synchronized (Singleton.class) { 
                if (mInstance == null) {
                    mInstance = new Singleton();
                }
            }
        }
        return mInstance;
    }
    
    public static void main(String[] args) {
        System.out.println(mInstance);
    }
}

原型模式

博客参考
原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。
这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式

public class ShallowCopy  extends BaseMessage implements Cloneable {

    @Override
    protected Object clone() throws CloneNotSupportedException {
        ShallowCopy shallowCopy=null;
        try {
            shallowCopy= (ShallowCopy) super.clone();
        }catch (Exception e){
            e.printStackTrace();
        }
        return shallowCopy;
    }

}


public class DeepCopy extends BaseMessage implements Cloneable {

    @SuppressWarnings("unchecked")
    @Override
    protected Object clone() throws CloneNotSupportedException {
        DeepCopy deepCopy=null;
        try {
            deepCopy= (DeepCopy) super.clone();
            this.setImgList((ArrayList<String>) this.getImgList().clone());
        }catch (Exception e){
            e.printStackTrace();
        }
        return deepCopy;
    }
}



public abstract class BaseMessage {

    /**
     * 发件人
     */
    private String send;

    /**
     * 收件人
     */
    private String receiver;

    /**
     * 消息
     */
    private String message;

    private ArrayList<String> imgList = new ArrayList<>();

    public ArrayList<String> getImgList() {
        return imgList;
    }

    public void setImgList(ArrayList<String> imgList) {
        this.imgList = imgList;
    }

    public String getSend() {
        return send;
    }

    public void setSend(String send) {
        this.send = send;
    }

    public String getReceiver() {
        return receiver;
    }

    public void setReceiver(String receiver) {
        this.receiver = receiver;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public void addImage(String image){
        getImgList().add(image);
    }

   /*
    * 发送消息
 
    public void sendMessage(){
        System.out.println(getReceiver()+getMessage()+"     娃娃图片数量"+getImgList().size()+"     发件人"+getSend());
    }
}