20210822自学（14中设计模式）

一、单例模式

1、双层校验

/**
 * 懒汉式，升级版，叫双层校验，单例模式， 不足“在第一次创建对象时候需要同步
 *
 * */
public class DclSingleton {
    private volatile  static  DclSingleton instance;
​
    private DclSingleton() {
    }
    private static  DclSingleton getInstance(){
        if (instance==null) {
            synchronized (DclSingleton.class){
                if (instance==null){
                    return instance = new DclSingleton();
                }
            }
        }
        return  instance;
    }
}

2、饿汉式

/**
 * 饿汉式
 * */
public class HungerSingleton {
    private final static HungerSingleton hungerSingleton = new HungerSingleton();
​
    private HungerSingleton() {
    }
    public static  HungerSingleton getInstance(){
        return hungerSingleton;
    }
}

3、懒汉式

public class LazySingleton {
    private static volatile  LazySingleton lazySingleton ;
​
    private LazySingleton() {
    }
    public static synchronized LazySingleton getInstance(){
        if (lazySingleton==null){
            lazySingleton =new LazySingleton();
            return  lazySingleton;
        }
        return  lazySingleton;
    }
}

二、简单工厂

/**
 * 抽象工厂
 * */
public interface Product {
    public void show();
}

/**
 * 简单工厂
 * */
public class SimpleFactory {
    public Product getProductP(String Pro){
        switch (Pro){
            case "1":
​
                return new ConcreteProduct();
            case "2":
​
                return new ConcreteProduct1();
​
        }
        return null;
    }
}

/**
 * 具体工厂
 * */
public class ConcreteProduct  implements Product{
    @Override
    public void show() {
        System.out.println("我是产品一");
    }
}

/**
 * 具体工厂
 * */
public class ConcreteProduct1 implements Product {
    @Override
    public void show() {
        System.out.println("我是产品二");
    }
}

public class SimpleFactoryTest {
    public static void main(String[] args) {
        SimpleFactory simpleFactory = new SimpleFactory();
        Product productP = simpleFactory.getProductP("1");
        Product productP2 = simpleFactory.getProductP("2");
        productP.show();
        productP2.show();
    }
}

三、抽象工厂

/**
 * 抽象工厂
 * */
public interface AbstractFactory {
    public Product MakeProduct();
    public Product1 MakeProduct1();
}

/**
 * 具体工厂
 * */
public class ConcreteFactory implements AbstractFactory{
    @Override
    public Product MakeProduct() {
        return new ConcreteProduct();
    }
​
    @Override
    public Product1 MakeProduct1() {
        return new ConcreteProduct2();
    }
}

/**
 * 具体工厂1
 * */
public class ConcreteFactory1 implements AbstractFactory {
    @Override
    public Product MakeProduct() {
        return new ConcreteProduct1();
    }
​
    @Override
    public Product1 MakeProduct1() {
        return new ConcreteProduct3();
    }
}

/**
 * 抽象产品
 * */
public interface Product {
​
    public void show();
}

/**
 * 抽象产品
 * */
public interface Product1 {
    public void open();
}

/**
 * 具体产品
 * */
public class ConcreteProduct implements Product{
    @Override
    public void show() {
        System.out.println("我叫阿良");
    }
}

public class ConcreteProduct1 implements Product {
    @Override
    public void show() {
        System.out.println("我叫阿良2");
    }
}

public class ConcreteProduct2 implements Product1{
    @Override
    public void open() {
        System.out.println("我阿良能开机");
    }
}

public class ConcreteProduct3 implements Product1{
    @Override
    public void open() {
        System.out.println("我阿良能开机2");
    }
}

/**
 * 抽象工厂模式
 * */
public class Test {
    public static void main(String[] args) {
        ConcreteFactory concreteFactory = new ConcreteFactory();
        Product product = concreteFactory.MakeProduct();
        product.show();
        Product1 product1 = concreteFactory.MakeProduct1();
        product1.open();
        ConcreteFactory1 concreteFactory1 = new ConcreteFactory1();
        Product product2 = concreteFactory1.MakeProduct();
        product2.show();
        Product1 product11 = concreteFactory1.MakeProduct1();
        product11.open();
    }
}

四、桥接模式

//接口
public interface Brand {
    void open();
    void close();
    void call();
}

public abstract class Phone {
    //组合品牌
    private Brand brand;
​
    public Phone() {
    }
​
    public Phone(Brand brand) {
        this.brand = brand;
    }
    protected void open(){
        this.brand.open();
    }
    protected void close(){
        this.brand.close();
    }
    protected void call(){
        this.brand.call();
    }
}

public class UpRightPhone extends Phone{
​
    public UpRightPhone() {
    }
​
    public UpRightPhone(Brand brand) {
        super(brand);
    }
    public void open(){
        super.open();
        System.out.println("直立样式手机");
    }
    public void close(){
        super.close();
        System.out.println("直立样式手机");
    }
    public void call(){
        super.call();
        System.out.println("直立样式手机");
    }
}

//折叠式手机类，继承抽象类Phone
public class FoldedPhone extends Phone {
    //构造器
​
​
    public FoldedPhone() {
    }
​
    public FoldedPhone(Brand brand) {
        super(brand);
    }
    public void open(){
        super.open();
        System.out.println("折叠样式手机");
    }
    public void close(){
        super.close();
        System.out.println("折叠样式手机");
    }
    public void call(){
        super.call();
        System.out.println("折叠样式手机");
    }
​
}

public class Vivo implements Brand{
    @Override
    public void open() {
        System.out.println("Vivo手机开机");
    }
​
    @Override
    public void close() {
        System.out.println("Vivo手机关机");
    }
​
    @Override
    public void call() {
        System.out.println("Vivo手机打电话");
    }
}

public class XiaoMi implements Brand{
    @Override
    public void open() {
        System.out.println("小米手机开机");
    }
​
    @Override
    public void close() {
        System.out.println("小米手机关机");
    }
​
    @Override
    public void call() {
        System.out.println("小米手机打电话");
    }
}

五、建造者模式

/**
 * 抽象建造者
 * */
public abstract class Builder {
​
    public Product product = new Product();
    public abstract void buildPartA();
    public abstract void buildPartB();
    public abstract void buildPartC();
    public abstract Product getProduct();
}

/**
 * 具体建造者
 * */
public class ConcreteBuilder extends Builder {
​
    @Override
    public void buildPartA() {
        product.setPartA("我叫阿良");
    }
​
    @Override
    public void buildPartB() {
         product.setPartB("我是啊良");
    }
​
    @Override
    public void buildPartC() {
      product.setPartC("我是傻逼良");
    }
​
    @Override
    public Product getProduct() {
        return product;
    }
}

/**
 * 指挥者
 * */
public class Director {
    private Builder builder;

    public Director() {
    }

    public Director(Builder builder) {
        this.builder = builder;
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
    }
    public Product construct(){
        return builder.getProduct();
    }
}

/**
 * 具体产品
 * */
public class Product {
    private String partA;
    private String partB;
    private String partC;

    public Product(String partA, String partB, String partC) {
        this.partA = partA;
        this.partB = partB;
        this.partC = partC;
    }

    public Product() {
    }

    public String getPartA() {
        return partA;
    }

    public void setPartA(String partA) {
        this.partA = partA;
    }

    public String getPartB() {
        return partB;
    }

    public void setPartB(String partB) {
        this.partB = partB;
    }

    public String getPartC() {
        return partC;
    }

    public void setPartC(String partC) {
        this.partC = partC;
    }

    @Override
    public String toString() {
        return "Product{" +
                "partA='" + partA + '\'' +
                ", partB='" + partB + '\'' +
                ", partC='" + partC + '\'' +
                '}';
    }
}

/**
 * 建造者模式
 * */
public class Client {
    public static void main(String[] args) {
        Director director = new Director(new ConcreteBuilder());

        Product construct = director.construct();
        System.out.println(construct);
    }
}

六、类适配器模式

/**
 *  目标接口
 * */
public interface Target {
    public void request();
}

/**
 * 适配者类
 * */
public class Adaptee {
    public void specificRequest(){
        System.out.println("适配者中的业务代码被调用");
    }
}

/**
 * 适配器类
 * */
public class ClassAdapter extends Adaptee implements Target{
 public void request(){
   specificRequest();
 }

}

/**
 * 适配器模式
 * */
public class ClassAdapterTest {
    public static void main(String[] args) {
        System.out.println("类适配器模式测试");
         Target target =  new ClassAdapter();
         target.request();
    }
}

七、命令者模式

/**
 * 创建命令接口
 * @author shkstart
 * @create 2021-08-22 17:22
 */
public interface Command {
    //执行动作
    public void execute();
    //撤销动作
    public void undo();
}

/**
 * @author shkstart
 * @create 2021-08-22 17:28
 */
public class LightOffCommand implements Command{
    //聚合LightReceiver
    LightReceiver light;
​
    public LightOffCommand() {
    }
​
    public LightOffCommand(LightReceiver light) {
        this.light = light;
    }
​
    @Override
    public void execute() {
        //调用接受者的方法
        light.off();
​
    }
​
    @Override
    public void undo() {
        light.on();
    }
}

/**
 * @author shkstart
 * @create 2021-08-22 17:23
 */
public class LightOnCommand implements Command {
    //聚合LightReceiver
    LightReceiver light;
​
    public LightOnCommand() {
    }
​
    public LightOnCommand(LightReceiver light) {
        this.light = light;
    }
​
    @Override
    public void execute() {
        //调用接受者的方法
        light.on();
​
    }
​
    @Override
    public void undo() {
     light.off();
    }
}

/**
 * @author shkstart
 * @create 2021-08-22 17:25
 */
public class LightReceiver {
    public void on(){
        System.out.println("电灯打开了");
    }
    public void off(){
        System.out.println("电灯关闭了");
    }
}

/**
 * 没有任何命令，即空执行，用于初始化每个按钮，当调用
 * 空命令是，对象什么都不做，其实这是一种设计模式，可以
 * 省掉空命令
 * @author shkstart
 * @create 2021-08-22 17:29
 */
public class NoCommand implements Command{
    @Override
    public void execute() {

    }

    @Override
    public void undo() {

    }
}

/**
 * @author shkstart
 * @create 2021-08-22 17:32
 */
public class RemoteController {
    //开按钮的命令数组
    Command[] onCommands;
    Command[] offCommands;
    //撤销命令
    Command undoCommand;
    //构造器，完成对按钮的初始化

    public RemoteController() {
        onCommands = new Command[5];
        offCommands = new Command[5];
        for (int i = 0; i < 5; i++) {
            onCommands[i] = new NoCommand();
            offCommands[i] = new NoCommand();
        }
    }
    //给我们的按钮设置你需要的命令
    public void setCommand(int no , Command onCommand,Command offCommand){
        onCommands[no] = onCommand;
        offCommands[no] = offCommand;
    }
    //按下开按钮
    public void onButtonWasPushed(int no){
        //找到你按下开的的按钮,并调用对应的方法
        onCommands[no].execute();
        //记录这次的操作,用于撤销
        undoCommand = onCommands[no];
    }
    //按下开按钮
    public void offButtonWasPushed(int no){
        //找到你按下关的的按钮,并调用对应的方法
        offCommands[no].execute();
        //记录这次的操作,用于撤销
        undoCommand = offCommands[no];
    }
    //按下撤销按钮
    public void undoButtonWasPushed(){
        undoCommand.undo();
    }
}

/**
 * @author shkstart
 * @create 2021-08-22 17:52
 */
public class TVOffCommand implements Command{
    //聚合LightReceiver
    TVReceiver tv;

    public TVOffCommand() {
    }

    public TVOffCommand(TVReceiver tv) {
        this.tv = tv;
    }

    @Override
    public void execute() {
        //调用接受者的方法
        tv.off();

    }

    @Override
    public void undo() {
        tv.on();
    }
}

/**
 * @author shkstart
 * @create 2021-08-22 17:57
 */
public class TVOnCommand implements Command{
    //聚合LightReceiver
    TVReceiver tv;

    public TVOnCommand() {
    }

    public TVOnCommand(TVReceiver tv) {
        this.tv = tv;
    }

    @Override
    public void execute() {
        //调用接受者的方法
        tv.on();

    }

    @Override
    public void undo() {
        tv.off();
    }
}

/**
 * @author shkstart
 * @create 2021-08-22 17:53
 */
public class TVReceiver {
    public void on(){
        System.out.println("电视机打开了");
    }
    public void off(){
        System.out.println("电视机关闭了");
    }
}

/**
 * 命令设计模式
 * @author shkstart
 * @create 2021-08-22 17:44
 */
public class Client {
    public static void main(String[] args) {
        //使用命令设计模式，完成通过遥控器，对电灯的操作
        LightReceiver lightReceiver = new LightReceiver();
        //创建电灯相关的开关命令
        LightOnCommand lightOnCommand = new LightOnCommand(lightReceiver);
        LightOffCommand lightOffCommand = new LightOffCommand(lightReceiver);

        RemoteController remoteController = new RemoteController();
        //需要一个遥控器
        remoteController.setCommand(0,lightOnCommand,lightOffCommand);
        System.out.println("********按下灯的开按钮*********");
        remoteController.onButtonWasPushed(0);
        System.out.println("********按下灯的开按钮*********");
        remoteController.offButtonWasPushed(0);
        System.out.println("********撤销*********");
        remoteController.undoButtonWasPushed();
        System.out.println("使用遥控器操作电视机");
        TVReceiver tvReceiver = new TVReceiver();
        TVOffCommand tvOffCommand = new TVOffCommand(tvReceiver);
        TVOnCommand tvOnCommand = new TVOnCommand(tvReceiver);
        //给我们的遥控器设置命令，
        remoteController.setCommand(1,tvOnCommand,tvOffCommand);
        System.out.println("********按下电视机的开按钮*********");
        remoteController.onButtonWasPushed(1);
        System.out.println("********按下电视机的开按钮*********");
        remoteController.offButtonWasPushed(1);
        System.out.println("********撤销*********");
        remoteController.undoButtonWasPushed();
    }
}

八、装饰器模式

public abstract class Drink {
    public String des;//描述
    private float price = 0.0f;

    public String getDes() {
        return des;
    }

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

    public float getPrice() {
        return price;
    }

    public void setPrice(float price) {
        this.price = price;
    }
    //计算费用的抽象方法
    //子类来实现
    public abstract float cost();
}

//具体的Decorator，这里就是调味品
public class Chocolate extends Decorator{
    public Chocolate(Drink obj) {
        super(obj);
        setDes("巧克力");
        setPrice(3.0f);//调味品的价格
    }
}

public class Coffee extends Drink{
    @Override
    public float cost() {
        return super.getPrice();
    }
}

public class Decorator extends Drink {
    private  Drink obj;
    @Override
    public float cost() {
        //getPrice 自己的价格
        return super.getPrice() + obj.cost();
    }
​
    public Decorator(Drink obj) {//组合
        this.obj = obj;
    }
    public String getDes(){
        // getDes 输出被装饰者的信息
        return super.des+" "+ super.getPrice()+" && "+obj.getDes();
    }
}

public class Espresso extends Coffee {
​
    public Espresso() {
        setDes("意大利咖啡");
        setPrice(6.0f);
    }
}

public class LongBlack extends Coffee{
    public LongBlack() {
        setDes("LongBlack");
        setPrice(5.0f);
    }
}

public class Mick  extends Decorator{

    public Mick(Drink obj) {
        super(obj);
        setDes("牛奶");
        setPrice(2.0f);
    }
}

public class ShortBlack extends Coffee{
    public ShortBlack() {
        setDes("ShortBlack");
        setPrice(4.0f);
    }
}

public class Soy extends Decorator{
    public Soy(Drink obj) {
        super(obj);
        setDes("豆浆");
        setPrice(1.5f);
    }
}

/**
 * 装饰器模式
 * */
public class CoffeeBar {
    public static void main(String[] args) {
        //1.点一份longBlack
        Drink order = new LongBlack();
        System.out.println("费用一："+order.cost());
        System.out.println("描述="+order.getDes());
        //2.加入一份牛奶
        System.out.println("---------------------------");
        order= new Mick(order);
        System.out.println("加入一份牛奶后 ="+order.cost());
        System.out.println("加入一份牛奶后描述 ="+order.getDes());
        //3. order 加入一份巧克力
        System.out.println("---------------------------");
        order= new Chocolate(order);
        System.out.println("加入一份牛奶后+加入一份巧克力 ="+order.cost());
        System.out.println("加入一份牛奶+加入一份巧克力后描述 ="+order.getDes());
        //4.order 再加入一份巧克力
        System.out.println("---------------------------");
        order= new Chocolate(order);
        System.out.println("加入一份牛奶后+加入2份巧克力 ="+order.cost());
        System.out.println("加入一份牛奶+加入2份巧克力后描述 ="+order.getDes());


    }
}

九、外观模式

public class DVDPlayer {
    //使用单例模式,使用饿汉式
    private static DVDPlayer instance= new DVDPlayer();
​
    private DVDPlayer() {
    }
    public static DVDPlayer getInstance(){
        return instance;
    }
    public void on(){
        System.out.println(" dvd on");
​
    }
    public void off(){
        System.out.println(" dvd off ");
    }
    public void play(){
        System.out.println(" dvd is playing ");
    }
   public void pause(){
       System.out.println(" dvd pause... ");
   }
}

/**
 * 外观
 * */
public class HomeTheaterFacade {
    //定义各个子系统对象
    private TheaterLight theaterLight;
    private Popcorn popcorn;
    private Stereo stereo;
    private Projector projector;
    private Screen screen;
    private DVDPlayer dvdPlayer;
    // 构造器
    public HomeTheaterFacade() {
        this.theaterLight = TheaterLight.getInstance();
        this.popcorn = Popcorn.getInstance();
        this.stereo = Stereo.getInstance();
        this.projector = Projector.getInstance();
        this.screen = Screen.getInstance();
        this.dvdPlayer = DVDPlayer.getInstance();
    }
    //操作分成4布
    public void ready(){
        popcorn.on();
        popcorn.pop();
        screen.down();
        projector.on();
        stereo.on();
        dvdPlayer.on();
        theaterLight.dim();
    }
    public void play(){
        dvdPlayer.play();
​
    }
    public void pause(){
        dvdPlayer.pause();
    }
    public void end(){
        popcorn.off();
        theaterLight.bright();
        screen.up();
        projector.off();
        stereo.off();
        dvdPlayer.off();
    }
​
​
}

/**
 * 爆米花机
 * */
public class Popcorn {
    private static Popcorn instance = new Popcorn();
    public static Popcorn getInstance(){
        return instance;
    }
    public void on(){
        System.out.println(" popcorn on ");
    }
    public void off(){
        System.out.println(" popcorn ff ");

    }
    public void pop(){
        System.out.println(" popcorn is poping ");

    }
}

public class Projector {
    private static Projector instance = new Projector();
    public static Projector getInstance(){
        return instance;
    }
    public void on(){
        System.out.println(" Projector on ");
    }
    public void off(){
        System.out.println(" Projector ff ");

    }
    public void focus(){
        System.out.println(" projector is projector ");

    }
}

public class Screen {
    private static Screen instance = new Screen();
    public static Screen getInstance(){
        return instance;
    }

    public void up(){
        System.out.println(" Screen up ");
    }
    public void down(){
        System.out.println(" Screen down ");

    }

}

public class Stereo {
    private static Stereo instance = new Stereo();
    public static Stereo getInstance(){
        return instance;
    }
    public void on(){
        System.out.println(" Stereo on ");
    }
    public void off(){
        System.out.println(" Stereo down ");
​
    }
    public void up(){
        System.out.println(" Stereo up.. ");
    }
}

public class TheaterLight {
    private static TheaterLight instance = new TheaterLight();
    public static TheaterLight getInstance(){
        return instance;
    }
    public void on(){
        System.out.println(" TheaterLight on ");
    }
    public void off(){
        System.out.println(" TheaterLight down ");
​
    }
    public void dim(){
        System.out.println(" TheaterLight dim.. ");
    }
    public void bright(){
        System.out.println(" TheaterLight bright.. ");
    }
​
}

/**
 * 外观模式一个继承和实现都没有    就只用到聚合
 * */
public class Client {
    public static void main(String[] args) {
        //这里直接调用.。很麻烦
        HomeTheaterFacade homeTheaterFacade = new HomeTheaterFacade();
        homeTheaterFacade.ready();
        homeTheaterFacade.play();
​
        homeTheaterFacade.end();
    }
}

十、工厂方法模式

/**
 * 抽象工厂
 * */
public interface AbstractFactory {
    public Product MakeProduct();
}

/**
 * 抽象产品
 * */
public interface Product {
    public void show();
}

/**
 * 具体工厂
 * */
public class ConcreteFactory implements AbstractFactory{
    @Override
    public Product MakeProduct() {
        return new ConcreteProduct();
    }
}

public class ConcreteFactory1 implements AbstractFactory{
    @Override
    public Product MakeProduct() {
        return new ConcreteProduct1();
    }
}

/**
 * 具体产品
 * */
public class ConcreteProduct implements Product{
    @Override
    public void show() {
        System.out.println("我是阿良");
    }
}

public class ConcreteProduct1 implements Product{
    @Override
    public void show() {
        System.out.println("我是阿达");
    }
}

/***
 * 工厂方法模式
 */

public class Test {
    public static void main(String[] args) {
        ConcreteFactory concreteFactory = new ConcreteFactory();
        Product product = concreteFactory.MakeProduct();
        product.show();
        ConcreteFactory1 concreteFactory1 = new ConcreteFactory1();
        Product product1 = concreteFactory1.MakeProduct();
        product1.show();

    }
}

十一、享元模式

/**
 * @author shkstart
 * @create 2021-08-22 10:07
 */
public abstract class Website {
    public abstract void use(User user);//抽象方法
}

/**
 * @author shkstart
 * @create 2021-08-22 10:07
 */
public class ConcreteWebsite extends Website{
    //共享的部分，内部状态
    private String type= "";//网站发布的形式
   //构造器
    public ConcreteWebsite(String type) {
        this.type = type;
    }
​
​
    @Override
    public void use(User user) {
        System.out.println("网站的发布形式为："+type+"在使用中..使用者是："+user.getName());
    }
}

/**
 * @author shkstart
 * @create 2021-08-22 10:43
 */
public class User {
    private String name ;
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public User() {
    }
​
    public User(String name) {
        this.name = name;
    }
}

/**
 * 网站工厂类，根据需要返回一个网站
 * @author shkstart
 * @create 2021-08-22 10:10
 */
public class WebsiteFactory {
    //集合，充当池的作用
    private HashMap<String,ConcreteWebsite> pool = new HashMap<>();
    //根据网站的类型，返回一个网站，如果没有就创建一个网站
    //并放入到池中，并返回
    public Website getWebSiteCategory(String type){
        if (!pool.containsKey(type)){
            pool.put(type,new ConcreteWebsite(type));
        }
        return (Website) pool.get(type);
    }
    public int getWebSiteCount(){
        return pool.size();
    }

}

/**
 * 享元模式
 * @author shkstart
 * @create 2021-08-22 10:15
 */
public class Client {
    public static void main(String[] args) {
        //创建一个工厂类
        WebsiteFactory factory = new WebsiteFactory();
        Website website = factory.getWebSiteCategory("新闻");
​
        website.use(new User("阿良"));
        System.out.println("------------------");
//        WebsiteFactory factory = new WebsiteFactory();
        Website website2 = factory.getWebSiteCategory("博客");
        website2.use(new User("阿达"));
        System.out.println(factory.getWebSiteCount());
        System.out.println("------------------");
        Website website3 = factory.getWebSiteCategory("博客");
        website3.use(new User("傻逼良"));
        System.out.println(factory.getWebSiteCount());
​
    }
}

十二、观察者模式

/**
 * 抽象观察者
 * */
public interface Observer {
    public void notify(String msg);
}

/**
 * 抽象主题
 * */
public abstract class Subject {
    protected List<Observer> list = new ArrayList<>();
    public synchronized void addConcreteObserver(Observer concreteObserver){
        if (!list.contains(concreteObserver)){
            list.add(concreteObserver);
        }
    }
    public void removeConcreteObserver(Observer concreteObserver){
        if(list.contains(concreteObserver)){
            list.remove(concreteObserver);
        }
    }
    public abstract void notifyObserver(String msg);
​
}

/**
 * 具体观察者
 * */
public class ConcreteObserver implements Observer {
    @Override
    public void notify(String msg) {
        System.out.println(msg);
    }
}

public class ConcreteObserver1 implements Observer{
   private String name ;
    @Override
    public void notify(String msg) {
        System.out.println(msg);
    }
​
    public ConcreteObserver1(String name) {
        this.name = name;
    }
​
    public ConcreteObserver1() {
    }
​
    @Override
    public String toString() {
        return "ConcreteObserver1{" +
                "name='" + name + '\'' +
                '}';
    }
}

/**
 * 具体主题
 * */
public class ConcreteSubject extends Subject {
​
    @Override
    public void notifyObserver(String msg) {
        if (!list.isEmpty()){
            for (Observer s :list){
                System.out.print(s);
                s.notify(msg);
            }
        }
    }
}

/**
 * 观察者模式
 * */
public class Test {
    public static void main(String[] args) {
        ConcreteObserver1 observer1 = new ConcreteObserver1("阿良");
        ConcreteObserver1 observer2 = new ConcreteObserver1("阿达");
        ConcreteSubject concreteSubject = new ConcreteSubject();
        concreteSubject.addConcreteObserver(observer1);
        concreteSubject.addConcreteObserver(observer2);
        concreteSubject.notifyObserver(" 我是小天才");
​
        concreteSubject.notifyObserver("黄祖鸿是个小天才");
    }
}

十三、代理模式

/**
 * 抽象主题
 * */
public interface Subject {
    public void show();
    public void open();
}

public class RealSubject implements Subject{
    @Override
    public void show() {
        System.out.println("我阿良能讲话");
    }

    @Override
    public void open() {
        System.out.println("我阿良能开电脑");
    }

    public RealSubject() {
    }

}

public class Proxy implements Subject{
     public RealSubject realSubject;
    @Override
    public void show() {
        System.out.println("我能代替阿良讲话");
        realSubject.show();
    }
​
    @Override
    public void open() {
        System.out.println("我能代替阿良开电脑");
        realSubject.open();
    }
​
    public Proxy(RealSubject realSubject) {
        this.realSubject = realSubject;
    }
}

public class Test {
    public static void main(String[] args) {
        Proxy proxy = new Proxy(new RealSubject());
        proxy.open();
        proxy.show();
    }
}

十四、模板方法模式

/**
 * 抽象类，表示豆浆
 * @author 黄祖鸿
 * @create 2021-08-22 15:39
 */
public abstract class SoyaMilk {
    //模板方法，make，模板方法可以做成final，不让子类去覆盖
    final void make(){
        select();
        addCondiments();
        soak();
        beat();
    }
    //选材料
    void select(){
        System.out.println("第一步：选择好的新鲜的黄豆");
    }
    //添加不同的配料，抽象方法
    abstract void addCondiments();
    //侵泡
    void soak(){
        System.out.println("第三步，黄豆和配料开始浸泡，需要3个小时");
​
    }
    void beat(){
        System.out.println("第四步：黄豆个配料方法豆浆机去打碎");
    }
}

/**
 * @author shkstart
 * @create 2021-08-22 15:45
 */
public class RedBeanSoyaMilk extends SoyaMilk {
    @Override
    void addCondiments() {
        System.out.println("加入上好的红豆 ");
    }
}

/**
 * @author shkstart
 * @create 2021-08-22 15:46
 */
public class PeanutSoyaMilk extends SoyaMilk{
​
    @Override
    void addCondiments() {
        System.out.println("加入上好的花生");
    }
}

/**
 * 模板方法模式
 * @author shkstart
 * @create 2021-08-22 15:46
 */
public class Client {
    //制造红豆豆浆
    public static void main(String[] args) {
        System.out.println("制作红豆豆浆");
        SoyaMilk redBeanSoyaMilk = new RedBeanSoyaMilk();
        redBeanSoyaMilk.make();
​
        System.out.println("-------------");
        System.out.println("制作黄豆豆浆");
        SoyaMilk peanutSoyaMilk = new PeanutSoyaMilk();
        peanutSoyaMilk.make();
    }
}