2021-10-11设计模式

单例模式（饿汉式 懒汉式）

package cn.tedu.day01;
//双重锁！！！同步代码块
public class SinglePlus {
    private SinglePlus(){};
    //一个线程更改volatile修饰的变量，其它线程就会及时更新
    private volatile  static SinglePlus instance;
    public static SinglePlus getInstance(){
        if (instance == null){
            synchronized (SinglePlus.class){
                if (instance==null){
                    instance=new SinglePlus();
                }
            }
        }
        return instance;
    }
}

装饰者模式

对一个对象的功能进行扩展

1. 派生子类，不建议，耦合性太高，任何一个类修改，都会影响其他的类。继承
2. 装饰者模式，动态的给一个对象添加额外的功能，装饰者模式比派生子类更加灵活，降低耦合

 装饰者模式中的要求

1. 装饰者中包含被装饰者
2. 装饰者和被装饰者的功能名称需要保持一致
3. 装饰者和被装饰者需要实现同一类型

简单实现+++++++以下参考

package cn.tedu.day01;
/*约束*/
public abstract class Person {
    public abstract void get();
}

package cn.tedu.day01;
/*被装饰者*/
public class Son extends Person{
    @Override
    public void get() {
        System.out.println("被装饰者的get功能");
    }
}

package cn.tedu.day01;
/*装饰者包含被装饰者*/
public class Father extends Person{
    private Son son;
    public Father(){};
    public Father(Son son){
        this.son=son;
    }
    @Override
    public void get() {
        son.get();
        System.out.println("装饰者模式新加功能");
    }
}

package cn.tedu.day01;

public class Test {
    public static void main(String[] args) {
        Son son = new Son();
        Father father = new Father(son);
        father.get();
    }
}

模板方法模式

定义一个算法的骨架，并允许子类为一个或多个步骤提供实现，模板方法使子类可以在不改变算法结构的情况下，重新定义算法的某些步骤

使用场景：一次性实现一个算法不变的地方，并将可变的行为留给子类来实现

                  各子类中公共的行为提取出来并集中到一个公共父类中，从而避免代码重复，提高代码复用性。

举个栗子：想要泡一杯茶或咖啡，第一步将水煮沸，第二步是加入咖啡或者茶，第三步是将饮料倒入杯子中，第四步就是加入调料品。第一步与第三步都是一样的，可以定义在基类，第二步和第四步是他们之间的差异可以在具体的子类中去实现。

简单实现+++++++以下参考

package cn.tedu.day01;
/*举个栗子：想要泡一杯茶或咖啡，第一步将水煮沸，
第二步是加入咖啡或者茶，
第三步是将饮料倒入杯子中，第四步就是加入调料品。
第一步与第三步都是一样的，可以定义在基类，
第二步和第四步是他们之间的差异可以在具体的子类中去实现。*/
public abstract class Drink {
    public void makeDrink(){
        boiling();
        join();
        decant();
        addCondiments();
    }
    public void boiling(){
        System.out.println("煮沸");
    }
    public abstract void join();
    public void decant(){
        System.out.println("倒杯子中");
    }
    public abstract void addCondiments();
}

package cn.tedu.day01;

public class Coffee extends Drink {
    @Override
    public void join() {
        System.out.println("倒咖啡");
    }

    @Override
    public void addCondiments() {
        System.out.println("加牛奶和糖");
    }
}

package cn.tedu.day01;

public class Tea extends Drink {
    @Override
    public void join() {
        System.out.println("倒茶");
    }

    @Override
    public void addCondiments() {
        System.out.println("加蜂蜜柚子");
    }
}

package cn.tedu.day01;

public class DrinkTest {
    public static void main(String[] args) {
        System.out.println("制作咖啡ing：：：");
        Coffee coffee = new Coffee();
        coffee.makeDrink();
        System.out.println("制作茶ing：：：");
        Tea tea = new Tea();
        tea.makeDrink();
    }
}

工厂模式

工厂是最常用创建模式之一（单例），创建对象不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象！！！

降低耦合性

简单实现+++++++以下参考！！！

package cn.tedu.day01;
//工厂的规则
public interface Phone {
    public abstract void makePhone();
}

package cn.tedu.day01;

public class XiaoMi implements Phone{
    public void makePhone(){
        System.out.println("小米10");
    }
}

package cn.tedu.day01;

public class HuaWei implements Phone{
    public void makePhone(){
        System.out.println("华为P30");
    }
}

package cn.tedu.day01;

public class Factory {
    public static Phone getInstance(String brand){
        if (brand.equals("华为")){
            return new HuaWei();
        }else if(brand.equals("小米")){
            return new XiaoMi();
        }else{
            return null;
        }
    }
}

package cn.tedu.day01;
/*客户端调用调用者*/
public class PhoneTest {
    public static void main(String[] args) {
        Phone xiaomi = Factory.getInstance("小米");
        xiaomi.makePhone();
        Phone huawei = Factory.getInstance("华为");
        huawei.makePhone();
    }
}