设计者模式

一、工厂方法模式 -----------> 创建复杂且大量的对象

     实现：定一个抽象类，各个自类去实现每一类的方法，最后由一个工厂模式去返回想要的对象，注重于对象

　　优点 :

　　　ａ.用户只需知道所需产品对应的工厂，无需关心是怎么实现的

　　　b.加入新产品符合开闭原则，提供可扩展性

二、策略模式 ------------>需要实现大量的不同的方法

　　实现：主要是写一个抽象接口的方法，由它的子类去实现,注重于方法，主要是为了取代if ... else .... 可以通过传入类似于HashMap去处理

三、建造者模式　------------> 适用于复杂参数初始化，可以通过建造者模式来构建

　　1.优点

　　　a.封装性好，创建和使用分离

　　　b.拓展性好、建造类之间独立、一定程度上解耦　　

　　2.缺点

　　  ａ.产生多余的Builder对象

　　   b.内部发生变化，建造者都需要修改的，成本比较大

　　3.建造者模式和工厂模式的区别

　　   建造者模式:当创建对象需要很多方法时候适合用建造者模式（方法）

　　　工厂模式： 当需要一个对象适用于工厂模式（对象）

　　　案例：

　　　　　public class Course {
　　　　　　private String courseName;
　　　　　　public Course(CourseBuilder courseBuilder){
　　　　　　　　this.courseName = courseBuilder.courseName;
　　　　　　　　System.out.println(this.courseName);
　　　　　　}
　　　　　public static class CourseBuilder{
　　　　　　private String courseName;
　　　　　public CourseBuilder buildeCourseName(String courseName){
　　　　　　this.courseName = courseName;
　　　　　　return this;
　　　　}
　　　　public Course build() {
　　　　　　return new Course(this);
　　　　}
　　　}
　　}

三、原型模式

　　    (1).适用于场景 : 类初始化消耗较多资源、new 产生一个对象需要非常繁琐的过程、构造函数比较复杂、循环体产生大量的对象

　　　(2). 优点 : 原型模式性能比直接new 一个对象性能高、其次简化创建过程

　　　(3). 缺点 : 必须配备克隆方法（核心）

　　　　  复写Object的clone的方法

　　　　　public class Mail implements Cloneable{
　　　　　@Override
　　　　　public Object clone() throws CloneNotSupportedException {
　　　　　　System.out.println("这里是克隆模式");
　　　　　　return super.clone();

　　　　}

　　　　使用:

　　　　Mail mail = (Mail) new Mail().clone();

　　　　这里涉及到深拷贝和浅拷贝的概念以及区别

　　　　浅拷贝只是复制了对象的引用地址，两个对象指向同一个内存地址，所以修改其中任意的值，另一个值都会随之变化，这就是浅拷贝     

　　　　深拷贝是将对象及值复制过来，两个对象修改其中任意的值另一个值不会改变，这就是深拷贝 

四、外观模式（门面模式）： 定义一个高层接口，让子系统更加容易使用

　　　　优点：

　　　　简化调用过程，无需了解调用的方法，避免带来的风险

　　　　减少系统依赖、松散耦合(迪米特法则:最少知道的原则)

　　　　缺点：

　　　　不符合开闭的原则 ： 对于扩展是开放的，对于修改是关闭　　

五、装饰者模式(类似于继承对象，主要使用抽象类作为继承)

　　优点 ： 不改变原有的对象情况下给对象一个扩展功能

　　缺点  ： 会出现很多类，增加程序复杂性

　　装饰者和适配器的区别

　　装饰者：它和原来的的类具有相同的接口

　　适配器：它和原来的类的接口是不同的

　　

六、适配器模式(方法结果相同或者相似，但是只是接口命名不同)

　　有类适配器模式、对象适配器模式

　　优点 ： 现有的类进行复用但不需要改变，目标类和适配器类解耦，提高了可扩展性

　　适配器和外观模式的区别

　　适配器： 只是再原有的基础上做了一下复用

　　外观模式：再原有的基础上定义了新的接口,做了一个简单的访问接口

七、桥接模式（通过组合的方式建立两个类之间的联系）

　　优点：分离了抽象部分和具体实体，易扩展性

八、代理模式 ： 代理对象在客户端和目标对象之间起到中介作用

　　优点：将代理对象与真实对象被调用的目标对象分离,降低耦合程度，拓展性好

　　分为静态代理、动态代理

九、策略模式 : 主要是为了取代if ... else .... 可以通过传入类似于HashMap去处理

十、观察者模式 : 

　　被观察对象需要继承Observable ,需要调用setChange() 、notifyObservers()

　　观察者对象需要继承Observer,会重写update()方法

　　//实现方式

　　被观察者.addObservers(观察者)

十一、责任链模式：

一、工厂方法模式(定一个抽象类，各个自类去实现每一类的方法，最后由一个工厂模式去返回想要的对象，注重于对象)
    可以和策略模式做一个对比
    案例：
    public interface IceCream {

    public void taste();
    }

    public class AppleIceCream implements IceCream {
    public void taste(){ System.out.println("这是苹果口味的冰激凌");
    }
    }

    public class BananaIceCream implements IceCream {
    public void taste() { System.out.println("这是香蕉口味的冰激凌");
        }
    }

    
   public class IceCreamFactory {
    public static IceCream creamIceCream(String taste){
        IceCream iceCream = null; // 这里我们通过switch来判断，具体制作哪一种口味的冰激凌
        switch(taste){
            case "Apple":
                iceCream = new AppleIceCream();
            break;
            case "Orange":
                iceCream = new OrangeIceCream();
                break;
        }
        return iceCream;
    }
  }

  //代码实现
    IceCream appleIceCream = IceCreamFactory.creamIceCream("Apple");
    appleIceCream.taste();
    IceCream bananaIceCream = IceCreamFactory.creamIceCream("Banana");
    bananaIceCream.taste();

二、建造者模式
三、原型模式
四、外观模式（门面模式）： 定义一个高层接口，让子系统更加容易使用
五、装饰者模式(类似于继承对象，主要使用抽象类作为继承)
六、适配器模式(方法结果相同或者相似，但是只是接口命名不同)
九、策略模式 : 主要是为了取代if ... else .... 可以通过传入类似于HashMap去处理
    案例：主要是写一个抽象接口的方法，有它的自类去实现(注重于方法)
    public abstract class CashSuper {
    public abstract double acceptCash(double money);
    }

    public class CashRebate extends CashSuper {
    @Override
    public double acceptCash(double money) {
        return money * 0.8;
    }
    }

十、观察者模式 :
　　被观察对象需要继承Observable ,需要调用setChange() 、notifyObservers()

　　观察者对象需要继承Observer,会重写update()方法


    public class People implements Observer {
    @Override
    public void update(Observable observable, Object o) {
        System.out.println(o.toString());
    }
    }

    public class Prodect extends Observable {
    private String msg = null;

    public void setChange(String msg){
        this.msg = msg;
        setChanged();
    }

    @Override
    protected synchronized void setChanged() {
        super.setChanged();
    }
    @Override
    public void notifyObservers() {
        super.notifyObservers(msg);
    }
}

　　      //实现方式
    //被观察者
        Prodect prodect = new Prodect();
    //观察者
        People people = new People();
        prodect.addObserver(people);
        prodect.setChange("你好");
        prodect.notifyObservers();


　　被观察者.addObservers(观察者)
十一、责任链模式：
      public abstract class Leader {
    
        //需要子类继承，所以使用protected
    protected String leaderName;  //领导的姓名
    protected Leader nextLeader;  //写一个领导对象
    
    //通过构造方法注入领导的姓名或者也可以添加其他信息
    public Leader(String leaderName){
        this.leaderName = leaderName;
    }
 
    //采用set方法注入下一个领导
    public void setNextLeader(Leader nextLeader) {
        this.nextLeader = nextLeader;
    }
    
    //处理请假请求业务的抽象方法
    public abstract void headerRequest(LeaveRequest leaveRequest);
    }
 

--------------责任链的实现--------------------------------
      public class DeputyManager extends Leader{
 
    public DeputyManager(String leaderName) {
        super(leaderName);
    }
 
    @Override
    public void headerRequest(LeaveRequest leaveRequest) {
        if (leaveRequest.getLeaveDays() < 20) {  //副总监只处理小于20天的请假请求
            System.out.println("副总监批");
            System.out.println(leaveRequest.getLeaveName()+",请假"+leaveRequest.getLeaveDays()+"天,原因："+leaveRequest.getReason());
        } else if(this.nextLeader != null){   //大于20天的交给下一个领导处理，首先需要判断下一个领导是否存在
            this.nextLeader.headerRequest(leaveRequest);
        }        
    }
    }

-------------代码实现-------------------------------------
     director.setNextLeader(deputyManager)
     deputyManager.setNextLeader(manager)