总图

创建型设计模式

1. 抽象工厂方法模式

代码

package nwnu.sun.patterns.createtype.abstractfactory;

/**
 * 抽象工厂设计模式
 */
public class AbstractFfactory {
    public static void main(String[] args) {
        //实例化手机工厂来创建手机
        Factory factory = new Factory_phone();

        Product_Apple product_apple = factory.create_product_apple();
        product_apple.create_product();

        Product_xiaomi product_xiaomi = factory.create_product_xiaomi();
        product_xiaomi.create_product();
    }
}

/**
 * 定义抽象总工厂
 */
abstract class Factory {
    //创建苹果产品
    abstract Product_Apple create_product_apple();

    //创建小米产品
    abstract Product_xiaomi create_product_xiaomi();
}

/**
 * 手机工厂
 */
class Factory_phone extends Factory {

    @Override
    Product_Apple create_product_apple() {
        return new Product_new_Iphone();//核心代码
    }

    @Override
    Product_xiaomi create_product_xiaomi() {
        return new Product_xiaomi_phone();
    }
}

/**
 * 平板工厂
 */
class Factory_pad extends Factory {

    @Override
    Product_Apple create_product_apple() {
        return new Product_IPad();
    }

    @Override
    Product_xiaomi create_product_xiaomi() {
        return new Product_xiaomi_pad();
    }
}

/**
 * 抽象Apple产品
 */
abstract class Product_Apple {
    abstract void create_product();
}

/**
 * 定义IPhone
 */
class Product_Iphone extends Product_Apple {

    @Override
    void create_product() {
        System.out.println("库克创建IPhone手机");
    }
}

/**
 * 扩展IPhone
 */
class Product_new_Iphone extends Product_Apple {

    @Override
    void create_product() {
        System.out.println("库克创建IPhone新一代手机");
    }
}

/**
 * 定义IPad
 */
class Product_IPad extends Product_Apple {

    @Override
    void create_product() {
        System.out.println("库克创建iPad");
    }
}

/**
 * 抽象小米产品
 */
abstract class Product_xiaomi {
    abstract void create_product();
}

/**
 * 定义小米手机
 */
class Product_xiaomi_phone extends Product_xiaomi {

    @Override
    void create_product() {
        System.out.println("雷军创建小米手机");
    }
}

/**
 * 定义小米平板
 */
class Product_xiaomi_pad extends Product_xiaomi {
    @Override
    void create_product() {
        System.out.println("雷军创建小米平板");
    }
}

2. 工厂方法模式(类）

代码

package nwnu.sun.patterns.createtype.factorymethed;

/**
 * 工厂方法模式
 */
public class FactoryMethed {
    public static void main(String[] args) {
        Factory factoryA = new FactoryA();
        Product productA = factoryA.create_factory();
        productA.info();
    }

}

interface Factory {
    Product create_factory();
}

class FactoryA implements Factory {

    @Override
    public Product create_factory() {
        return new ProducyA();
    }
}

class FactoryB implements Factory {

    @Override
    public Product create_factory() {
        return new ProducyB();
    }
}

interface Product {
    void info();
}

class ProducyA implements Product {
    @Override
    public void info() {
        System.out.println("创建产品A");
    }
}

class ProducyB implements Product {
    @Override
    public void info() {
        System.out.println("创建产品B");
    }
}

3. 生成器模式

代码

package nwnu.sun.patterns.structtype.build;

import java.util.ArrayList;
import java.util.List;

/**
 * 构造器模式
 */
public class build {
    public static void main(String[] args) {
        Construct construct = new Construct();
        Builder builder1 = new BuilderPlan1();
        construct.Construct_build(builder1);
        builder1.getresult();

        Builder builder2 = new BuilderPlan2();
        construct.Construct_build(builder2);
        builder2.getresult();
    }
}


class Construct {
    public Builder Construct_build(Builder builder) {
        builder.buildpart();
        return builder;
    }
}

abstract class Builder {
    abstract void buildpart();

    abstract Product_apple getresult();
}

class BuilderPlan1 extends Builder {
    Product_apple product_apple = new Product_apple();

    @Override
    void buildpart() {
        product_apple.add("手机");
        product_apple.add("卡针");
        product_apple.add("充电线");
    }

    @Override
    Product_apple getresult() {
        product_apple.show();
        return product_apple;
    }
}

class BuilderPlan2 extends Builder {
    Product_apple product_apple = new Product_apple();

    @Override
    void buildpart() {
        product_apple.add("手机");
        product_apple.add("卡针");
        product_apple.add("充电线");
        product_apple.add("18w快充头（牛逼）");
    }

    @Override
    Product_apple getresult() {
        product_apple.show();
        return product_apple;
    }
}


class Product_apple {
    List<String> apple = new ArrayList<>();

    public void add(String string) {
        apple.add(string);
    }

    public void show() {
        System.out.print("产品组成：");
        for (String s : apple)
            System.out.print(s + " ");
        System.out.println("\n");
    }
}

4. 原型模式

代码

package nwnu.sun.patterns.createtype.prototype;

/**
 * @author nwnu
 * @date 2022/10/15 20:45
 * @description 1.0
 */
public class Prototype {
    public static void main(String[] args) {
        Product product = new Product("iPhone", 1999.0);
        System.out.println(product.getName());
        System.out.println(product.clone().getName());
    }
}
interface Prototy {
    public Product clone();
}
class Product implements Prototy {
    private String name;
    private Double price;

    public Product(String name, Double price) {
        this.name = name;
        this.price = price;
    }
    public Product() {
    }
    public String getName() {
        return name;
    }
    
    @Override
    public Product clone() {
        Product product = new Product();
        product.name = this.name;
        product.price = this.price;
        return product;
    }
}

5. 单例模式

饿汉式

/**
 * 饿汉式实现单例模式
 */
public class Singleton {
    private static Singleton instance = new Singleton();
    private Singleton() {
    }
    public static Singleton getInstance() {
        return instance;
    }
}

getInstance()方法中添加了synchronized关键字，使其变成一个同步方法，目的是为了在多线程环境下保证单例对象唯一。

优点： 只有在使用时才会实例化单例，一定程度上节约了资源。

缺点： 第一次加载时要立即实例化，反应稍慢。每次调用getInstance()方法都会进行同步，这样会消耗不必要的资源。这种模式一般不建议使用。

懒汉式

/**
 *懒汉式实现单例
 */
class Person {
    private static Person person;
    private Person() {
    }
    // synchronized方法,多线程情况下保证单例对象唯一
    public static synchronized  Person getInstance() {
    	if(person == null){
    		person =  new Person();
    	}
        return person;
    }
}

结构型设计模式

1. 适配器模式（对象+类）

代码

public class AdapterPattern {
    public static void main(String[] args) {
        USB usb = new Adapter();
        usb.Request();
    }
}

class USB {
    public void Request() {
        System.out.println("USB数据线");
    }
}

class Adapter extends USB {
    private TypeC typeC = new TypeC();

    @Override
    public void Request() {
        typeC.SpecificRequest();
    }
}

class TypeC {
    public void SpecificRequest() {
        System.out.println("Type-C数据线");
    }
}

2. 桥接模式

代码

package nwnu.sun.patterns.bridge;

/**
 * @author nwnu
 * @date 2022/10/14 9:18
 * @description 1.0
 */
public class Bridge {
    public static void main(String[] args) {
        //实例车
        Car car = new xin_nengyuan();
        //设置车颜色
        Color red = new Red();
        car.setColor(red);
        car.setProductname("比亚迪");
        car.print_color();
        //更改颜色
        Color yellow = new Yellow();
        car.setColor(yellow);
        car.print_color();
    }

}

abstract class Car {
    protected Color color;
    private String productname;

    public void setColor(Color color) {
        this.color = color;
    }

    public void setProductname(String productname) {
        this.productname = productname;
    }

    public String getProductname() {
        return productname;
    }

    abstract void print_color();
}

class xin_nengyuan extends Car {
    @Override
    public void print_color() {
        color.print_color(getProductname());
    }
}

interface Color {
    public void print_color(String product);
}

class Red implements Color {
    @Override
    public void print_color(String product) {
        System.out.println(product + "颜色是： 红色");
    }
}

class Yellow implements Color {
    @Override
    public void print_color(String product) {
        System.out.println(product + "颜色是: 黄色");
    }
}

重点：将抽象部分与实现部分相分离，使可以独立变化

3. 组合模式

代码

abstract class AbstractFile {
    public String name;

    public void printName(int number) {
    }

    abstract Boolean add(AbstractFile abstractFile);

    abstract Boolean remove(AbstractFile abstractFile);

    abstract void show(int number);
}

class File extends AbstractFile {
    @Override
    public Boolean add(AbstractFile abstractFile) {
        return false;
    }

    @Override
    public Boolean remove(AbstractFile abstractFile) {
        return false;
    }

    @Override
    public void show(int number) {
    }

    @Override
    public void printName(int number) {
        System.out.print("文件:");
        while (number >= 0) {
            System.out.print(" ");
            number--;
        }
        System.out.println(name);
    }

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

}

class Folder extends AbstractFile {
    private List<AbstractFile> list = new ArrayList<>();

    @Override
    public Boolean add(AbstractFile abstractFile) {
        return list.add(abstractFile);
    }

    @Override
    public Boolean remove(AbstractFile abstractFile) {
        return list.remove(abstractFile);
    }

    @Override
    public void printName(int number) {
        System.out.print("目录:");
        while (number >= 0) {
            System.out.print(" ");
            number--;
        }
        System.out.println(name);
    }

    @Override
    public void show(int number) {
        for (AbstractFile list : list) {
            if (list instanceof File) {
                list.printName(number);
            } else {
                int number1 = number;
                list.printName(number);
                list.show(number1 + 2);
            }
        }
    }

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

4. 装饰器模式

public class Decorat {
    public static void main(String[] args) {
        Person student = new Student("张三");
        student = new DecoratorA(student);
        student = new DecoratorB(student);
        student.operaction();
        //对象链
        new DecoratorB(new DecoratorA(new Student("李四"))).operaction();

    }
}
class Student extends Person {
    public Student(String name) {
        this.name = name;
    }

    @Override
    public void operaction() {
        System.out.print(name + ":" + "学习");
    }
}

/**
 * 装饰器
 */
abstract class Decorator extends Person {
    protected Person person;//定义指向person的指针
}

/**
 * 装饰器A
 */
class DecoratorA extends Decorator {
    public DecoratorA(Person person) {
        this.person = person;
    }

    @Override
    public void operaction() {
        person.operaction();
        System.out.print(" 写作业");
    }
}
/**
 * 装饰器B
 */
class DecoratorB extends Decorator {
    public DecoratorB(Person person) {
        this.person = person;
    }

    @Override
    public void operaction() {
        person.operaction();
        System.out.println(" 考试");
    }
}

5. 外观模式

public class Appearance {
    public static void main(String[] args) {
        Facade facade = new Facade();
        facade.function1();

    }
}
class Facade {
    private System1 system1;
    private System2 system2;
    private System3 system3;

    public Facade() {
        system1 = new System1();
        system2 = new System2();
        system3 = new System3();
    }

    public void function1() {
        system1.run();
    }

    public void function2() {
        system2.run();
    }

    public void function3() {
        system3.run();
    }
}

class System1 {
    public void run() {
        System.out.println("子系统1运行");
    }
}

class System2 {
    public void run() {
        System.out.println("子系统2运行");
    }
}

class System3 {
    public void run() {
        System.out.println("子系统3运行");
    }
}

6. 享元模式

定义：享元模式(Flyweight):运用共享技术有效地支持大量细粒度的对象.[DP]

它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似对象的开销，从而提高系统资源的利用率。

结构：

享元（Flyweight ）模式中存在以下两种状态：

1. 内部状态，即不会随着环境的改变而改变的可共享部分。
2. 外部状态，指随环境改变而改变的不可以共享的部分。

享元模式的实现要领就是区分应用中的这两种状态，并将外部状态外部化。

代码：

package nwnu.sun.patterns.structtype.flyweight;

import java.util.*;

/**
 * @author nwnu
 * @date 2022/10/15 10:15
 * @description 1.0
 */
public class Flyweight {
    public static void main(String[] args) {
        ShapeFactory sha = new ShapeFactory();

        Random random = new Random();
        String[] color = {"red", "bule", "yellow"};

        for (int i = 0; i < 10; i++) {
            System.out.println("第" + i + "次创建");
            int index = random.nextInt(color.length);
            Shape shape = sha.getShape(color[index]);
            shape.draw(random.nextInt(100), random.nextInt(200));
        }
    }
}

class ShapeFactory {
    private Map<String, Shape> map = new HashMap<String, Shape>();

    public Shape getShape(String key) {
        if (!map.containsKey(key)) {
            System.out.println("create new circle ,color is:" + key);
            map.put(key, new Circle(key));
        }
        return map.get(key);
    }
}


abstract class Shape {
    protected String color;

    public abstract void draw(int x, int y);
}

class Circle extends Shape {
    public Circle(String color) {
        this.color = color;
    }

    @Override
    public void draw(int x, int y) {
        System.out.println("circle color " + color + "location is：" + x + "," + y);
    }
}

7. 代理模式

代码

package nwnu.sun.patterns.structtype.proxy;

/**
 * @author nwnu
 * @date 2022/10/15 11:24
 * @description 1.0
 */
public class Proxy {
    public static void main(String[] args) {
        Subject subject = new Realsubject();
        subject.buy();
        //代理后
        System.out.println("-----");
        ProxySubject proxySubject = new ProxySubject(subject);
        proxySubject.buy();
    }
}

/**
 * 对象接口
 */
interface Subject {
    abstract void buy();
}

/**
 * 代理对象
 */
class ProxySubject implements Subject {
    protected Subject subject;

    public ProxySubject(Subject subject) {
        this.subject = subject;
    }

    @Override
    public void buy() {
        System.out.println("选房");
        subject.buy();
        System.out.println("入住");

    }
}

/**
 * 对象
 */
class Realsubject implements Subject {
    @Override
    public void buy() {
        System.out.println("付钱");
    }
}

行为设计模式

1.责任链模式

代码

package nwnu.sun.patterns.behaivor;

/**
 * @author nwnu
 * 学生-->请假
 * 辅导员（7天）-->院长（15天）-->校长（<30天）
 */
public class Behaivor {
    public static void main(String[] args) {
        Handler fudaoyuan = new FuDaoYuan().setHandler(new YuanZhang().setHandler(new XiaoZhang()));
        fudaoyuan.request(18);


    }
}
abstract class Handler {
    //后继指针
    protected Handler handler;

    public Handler setHandler(Handler handler) {
        this.handler = handler;
        return handler;
    }

    abstract void request(int days);
}

/**
 * 辅导员
 */
class FuDaoYuan extends Handler {
    @Override
    public void request(int days) {
        if (days < 7) {
            System.out.println("辅导员审批通过");
        } else {
            handler.request(days);
        }
    }
}

/**
 * 院长
 */
class YuanZhang extends Handler {
    @Override
    public void request(int days) {
        if (days < 15) {
            System.out.println("院长审批通过");

        } else {
            handler.request(days);
        }
    }
}

/**
 * 校长
 */
class XiaoZhang extends Handler {
    @Override
    public void request(int days) {
        System.out.println("校长审批通过");
    }
}

2.命令模式

代码

package nwnu.sun.patterns.behaivor;

/**
 * @author nwnu
 * @date 2022/10/15 17:21
 * @description 1.0
 */
public class Commandmoshi {
    public static void main(String[] args) {
        Tv tv = new Tv();
        Command command_on = new OnCommand(tv);//开机
        Command command_off = new OffCommand(tv);//关机

        Invoker invoker = new Invoker();//执行命令

        System.out.println("=======开机=======");
        invoker.setCommand(command_on);
        invoker.call();
        System.out.println("========关机=======");
        invoker.setCommand(command_off);
        invoker.call();
    }
}

class Invoker {
    private Command command;

    public void setCommand(Command command) {
        this.command = command;
    }

    public void call() {
        command.execute();
    }
}

class Tv { // 接受者
    public void OnAction() {
        System.out.println("成功执行开机");
    }

    public void OffAction() {
        System.out.println("成功执行关机");
    }
}

abstract class Command { // 命令接口
    protected Tv tv;

    abstract void execute();
}

class OnCommand extends Command {//开机命令

    public OnCommand(Tv tv) {
        this.tv = tv; //调用tv的OnAction()方法
    }

    @Override
    public void execute() {
        tv.OnAction();
    }
}

class OffCommand extends Command {//关机命令

    public OffCommand(Tv tv) {
        this.tv = tv;//调用tv的OffAction()方法
    }

    @Override
    public void execute() {
        tv.OffAction();
    }
}

3.解释器模式（类）

代码

package nwnu.sun.patterns.behaivor;

import java.util.*;

/**
 * @author nwnu
 * 解释器设计模式
 * 文法例子：
 * 区域：  A区，B区，C区
 * 人员： 开发人员，测试人员，运维人员
 * 识别： A区的开发人员
 */
public class Expression {
    public static void main(String[] args) {
        Context context = new Context();
        context.check("A区的开发人员");
        context.check("*区的开发人员");
    }
}

class Context {
    private String[] region = {"A区", "B区", "C区"};
    private String[] person = {"开发人员", "测试人员", "运维人员"};
    private NonTermainalExpression nonTermainalExpression;

    public Context() {
        nonTermainalExpression = new NonTermainalExpression(new TerminPression(region), new TerminPression(person));
    }

    public void check(String str) {
        Boolean flag = nonTermainalExpression.Interpret(str);
        if (flag) {
            System.out.println("识别成功");
        } else {
            System.out.println("识别失败");
        }
    }

}

interface AbstractExpression {
    public Boolean Interpret(String info);
}

class NonTermainalExpression implements AbstractExpression {// 定义非终结符

    private TerminPression region;
    private TerminPression person;

    public NonTermainalExpression(TerminPression region, TerminPression person) {
        this.region = region;
        this.person = person;
    }

    @Override
    public Boolean Interpret(String info) {
        String[] data = info.split("的");
        return region.Interpret(data[0]) && person.Interpret(data[1]);
    }

}

class TerminPression implements AbstractExpression {// 定义终结符
    private Set<String> set = new HashSet<String>(); //定义规则

    public TerminPression(String[] datas) {// 构造器
        for (String str : datas) {
            set.add(str);
        }
    }

    @Override
    public Boolean Interpret(String info) {
        return set.contains(info);
    }
}

4.迭代器模式

代码

package nwnu.sun.patterns.createtype.iterator;
import java.util.*;

/**
 * @author nwnu
 * @date 2022/10/15 21:39
 * @description 1.0
 */
public class Iterator {
    public static void main(String[] args) {
        String[] name = {"数据结构", "计算机组成原理", "计算机网络"};
        Double[] price = {78.0, 66.3, 11.6, 15.8};
        //数据初始化
        BookAggreagte bookAggreagte = new BookAggreagte();
        for (int i = 0; i < 3; i++) {
            bookAggreagte.add(new Book(name[i], price[i]));
        }
        //自定义迭代
        BookIterator iterator = bookAggreagte.createIterator();
        while (iterator.hashNext()) {
            Book next = (Book) iterator.Next();
            System.out.println(next.getName() + " " + next.getPrice());
        }
    }
}


interface IteratorSun {
    public Boolean hashNext();

    public Object Next();
}

class BookIterator implements IteratorSun {
    private BookAggreagte bookAggreagte;
    private int index;

    public BookIterator(BookAggreagte bookAggreagte) {
        this.bookAggreagte = bookAggreagte;
    }

    @Override
    public Boolean hashNext() {
        if (index < bookAggreagte.size()) {
            return true;
        }
        return false;
    }

    @Override
    public Object Next() {
        Book book = bookAggreagte.get(index);
        index++;
        return book;
    }
}


interface Aggreagte {
    public BookIterator createIterator();
}

class BookAggreagte implements Aggreagte {
    private List<Book> list = new ArrayList<>();

    public void add(Book book) {
        list.add(book);
    }

    public int size() {
        return list.size();
    }

    public Book get(int index) {
        return list.get(index);
    }

    /**
     * 创建迭代器对象
     * @return
     */
    @Override
    public BookIterator createIterator() {
        return new BookIterator(this);
    }

}
class Book {
    private String name;
    private Double price;

    public String getName() {
        return name;
    }

    public Double getPrice() {
        return price;
    }

    public Book(String name, Double price) {
        this.name = name;
        this.price = price;
    }
}

5.中介者模式

代码

package nwnu.sun.patterns.behaivor;
import java.util.*;

/**
 * @author nwnu
 * 定义中介者：用来绑定各个同事，并在同事之间传递消息
 * 同事：通信的对象
 * 机制：同事之间不用引用，通过中介者调用，类似于消息队列的作用
 */
public class MediatorPattern {
    public static void main(String[] args) {
        ColleageA zhangsan = new ColleageA("张三");
        ColleageB lisi = new ColleageB("李四");
        ConcreateMediator mediator = new ConcreateMediator();
        //同事绑定中介者
        zhangsan.setMediator(mediator);
        lisi.setMediator(mediator);
        //中介者维护同事
        mediator.addColleage(zhangsan);
        mediator.addColleage(lisi);
        //张三发送消息
        mediator.sendMessage("你好啊", zhangsan);
    }
}


interface Mediator {
    public void sendMessage(String info, Colleage colleage);//中介者发送消息
}

class ConcreateMediator implements Mediator {
    //维护同事
    private List<Colleage> list = new ArrayList<>();

    public void addColleage(Colleage colleage) {
        list.add(colleage);
    }

    @Override
    public void sendMessage(String info, Colleage colleage) {
        if (colleage == list.get(0)) {
            list.get(1).reciverMessage(info);
        } else {
            list.get(0).reciverMessage(info);
        }
    }
}

abstract class Colleage {
    protected String name;
    protected Mediator mediator;//同事与中介者绑定

    abstract void sendMessage(String info, Colleage colleage);

    abstract void reciverMessage(String info);
}

/**
 * 同事A
 */
class ColleageA extends Colleage {

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

    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }

    @Override
    public void sendMessage(String info, Colleage colleage) {
        mediator.sendMessage(info, this);
    }

    @Override
    public void reciverMessage(String info) {
        System.out.println(name + "收到消息：" + info);
    }
}

/**
 * 同事B
 */
class ColleageB extends Colleage {
    public ColleageB(String name) {
        this.name = name;
    }

    public void setMediator(Mediator mediator) {//设置中介者
        this.mediator = mediator;
    }

    @Override
    public void sendMessage(String info, Colleage colleage) {
        mediator.sendMessage(info, this);
    }

    @Override
    public void reciverMessage(String info) {
        System.out.println("同事" + name + "收到消息：" + info);
    }
}

6.备忘录模式

代码

package nwnu.sun.patterns.behaivor;
import com.sun.org.apache.xpath.internal.operations.Or;
import java.util.*;

/**
 * @author nwnu
 * @date 2022/10/16 12:16
 * @description 1.0
 */
public class memoPattern {
    public static void main(String[] args) {
        Originator originator = new Originator("1024");//备份对象
        Caretaker caretaker = new Caretaker();//创建管理者

        Memento memento1 = originator.createMemento();//第一次备份
        caretaker.add(memento1);
        //改变state，再次备份
        originator.setstate("2048");
        Memento memento2 = originator.createMemento();//第二次备份
        caretaker.add(memento2);
        //输出所有备份
        caretaker.show();

        //获取第i次备份
        Memento memento = caretaker.get(2);
        System.out.println(memento.getState());
    }
}

class Originator {
    private String state;

    public void setstate(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }

    public Originator(String state) {
        this.state = state;
    }

    public Memento createMemento() {//创建备份
        return new Memento(state);
    }
}

class Memento {//备忘录
    private String state;

    public void setState(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }

    public Memento(String state) {
        this.state = state;
    }
}

class Caretaker {
    private List<Memento> mementoList = new ArrayList<Memento>();

    public void add(Memento memento) {
        mementoList.add(memento);
    }

    public Memento get(int index) {
        if (index > 0 && index <= mementoList.size()) {
            return mementoList.get(index - 1);
        }
        return null;
    }

    public void show() {
        int index = 1;
        for (Memento memento : mementoList) {
            System.out.println("第" + index + "次备份" + memento.getState());
            index++;
        }
    }
}

7.观察者模式

代码

package nwnu.sun.patterns.behaivor;

import java.util.*;
import java.util.ArrayList;

/**
 * @author nwnu
 * @date 2022/10/16 12:50
 * @description 1.0
 */
public class ObserverPattern {
    public static void main(String[] args) {
        BilibiliUp up = new BilibiliUp("杨幂");//定义UP主
        ConcreateObserver fans1 = new ConcreateObserver("张三", up);//张三关注up
        ConcreateObserver fans2 = new ConcreateObserver("李四", up);//李四关注up
        System.out.println("=====更新前=====");
        System.out.println("up状态：" + up.getState());
        System.out.println(fans1.getName() + "状态：" + fans1.getState());
        System.out.println(fans2.getName() + "状态：" + fans1.getState());
        up.setState("上线");//Up主更新状态
        System.out.println("=====更新后=====");
        System.out.println("up状态：" + up.getState());
        System.out.println(fans1.getName() + "状态：" + fans1.getState());
        System.out.println(fans2.getName() + "状态：" + fans1.getState());
    }
}

abstract class Subject {
    abstract String getState();

    abstract void attach(Observer observer);//注册观察者

    abstract void detach(Observer observer);//删除观察者

    abstract void notify_Observer();//状态改变后，更新所有观察者
}

class BilibiliUp extends Subject {
    private String state = "未上线";
    private String name;
    private List<Observer> observerlist;

    public String getState() {
        return state;
    }

    public String getName() {
        return name;
    }

    public BilibiliUp(String name) {
        this.observerlist = new ArrayList<>();
        this.name = name;
    }

    public void setState(String state) {
        this.state = state;
        notify_Observer();//up更新状态，立即通知粉丝
    }


    @Override
    void attach(Observer observer) {
        observerlist.add(observer);
    }

    @Override
    void detach(Observer observer) {
        observerlist.remove(observer);
    }

    @Override
    void notify_Observer() {
        for (Observer observer : observerlist) {
            observer.Update(state);//更新粉丝状态
        }
    }
}

abstract class Observer {
    abstract void Update(String state);
}

class ConcreateObserver extends Observer {
    private String state;
    private String name;
    private Subject subject;

    public String getState() {
        return state;
    }

    public String getName() {
        return name;
    }

    public ConcreateObserver(String name, Subject subject) {
        this.name = name;
        this.state = subject.getState();
        subject.attach(this);//初始化up
    }

    @Override
    public void Update(String state) {
        this.state = state;
    }
}

8.State(状态模式)

代码

package nwnu.sun.patterns.behaivor.state;

/**
 * @author nwnu
 * @date 2022/10/16 17:05
 * @description 1.0
 */
public class StatePattern {
    public static void main(String[] args) {
        Context context = new Context();
        for (int i = 1; i <= 15; i++) {
            context.request();
        }
    }
}

class Context {//贩卖机
    private int conunt;//数量
    private State state;//状态

    public int getConunt() {
        return conunt;
    }

    public void setConunt(int conunt) {
        this.conunt = conunt;
    }

    public State getState() {
        return state;
    }

    public void setState(State state) {
        this.state = state;
    }

    public Context() {
        this.conunt = 5;
        this.state = new StateHvProduct();
    }

    public void request() {
        state.handler(this);//依据货物数量更新内部状态
    }
}

interface State {
    void handler(Context context);
}

class StateHvProduct implements State {//有货

    @Override
    public void handler(Context context) {
        if (context.getConunt() > 0) {
            System.out.println("有货,数量：" + context.getConunt());
            context.setConunt(context.getConunt() - 1);
        } else {
            System.out.print("没货！ ");
            context.setState(new StateNoProduct());//没货，更改内部状态
            context.request();//继续请求
        }
    }
}

class StateNoProduct implements State {//无货

    @Override
    public void handler(Context context) {
        context.setConunt(5);
        System.out.println("补货成功，数量5");
        context.setState(new StateHvProduct());//补货后，更改内部状态
        context.request();//继续请求
    }
}

9.策略模式

代码

package nwnu.sun.patterns.behaivor;

/**
 * @author nwnu
 * @date 2022/10/16 21:58
 * @description 1.0
 */
public class Strategypattern {
    public static void main(String[] args) {
        Strategy strategy = new PlusStrategy();//定义加策略
        TwonumberContext context = new TwonumberContext(strategy);
        context.operation(5, 1);
    }
}

/**
 * 客户，调用具体算法
 */
class TwonumberContext {
    private Strategy strategy;

    public TwonumberContext(Strategy strategy) {
        this.strategy = strategy;
    }

    public void operation(int a, int b) {
        strategy.twonumber_opreation(a, b);
    }
}

/**
 * 算法 接口
 */
interface Strategy {
    public void twonumber_opreation(int a, int b);
}

/**
 * 加法策略
 */
class PlusStrategy implements Strategy {
    @Override
    public void twonumber_opreation(int a, int b) {
        System.out.println(a + "+" + b + "=" + (a + b));
    }
}

/**
 * 加法策略
 */
class JianStrategy implements Strategy {
    @Override
    public void twonumber_opreation(int a, int b) {
        System.out.println(a + "-" + b + "=" + (a - b));
    }
}

10.模板方法（类）

代码

package nwnu.sun.patterns.behaivor;

/**
 * @author nwnu
 * @date 2022/10/16 23:06
 * @description 1.0
 */
public class TemplateMethedPattern {
    public static void main(String[] args) {
        Person student = new Student();
        Person teacher = new Teacher();
        student.TemplateMethed();
        teacher.TemplateMethed();

    }

}

abstract class Person {
    public void TemplateMethed() {
        System.out.println("进教室");
        PrimitiveOperation1();
        System.out.println("出教室");
        PrimitiveOperation2();
    }

    public abstract void PrimitiveOperation1();

    public abstract void PrimitiveOperation2();
}

class Student extends Person {

    @Override
    public void PrimitiveOperation1() {
        System.out.println("学生听课");

    }

    @Override
    public void PrimitiveOperation2() {
        System.out.println("学生写作业");

    }
}

class Teacher extends Person {

    @Override
    public void PrimitiveOperation1() {
        System.out.println("老师讲课");

    }

    @Override
    public void PrimitiveOperation2() {
        System.out.println("老师布置作业");

    }
}

访问者模式

代码

package nwnu.sun.patterns.behaivor;

import java.util.ArrayList;
import java.util.List;

/**
 * @author nwnu
 * @date 2022/10/17 0:16
 * @description 1.0
 */
public class Visitorpattern {
    public static void main(String[] args) {
        Struct struct = new Struct();
        Visitor visitor1 = new Visitor1();
        Visitor visitor2 = new Visitor2();
        struct.visit(visitor1);
        System.out.println("=====");
        struct.visit(visitor2);
    }
}


interface Visitor {
    void visitStudent(StudentV studentV);

    void visitTeacher(PersonV personV);
}

class Visitor1 implements Visitor { // 访问者1

    @Override
    public void visitStudent(StudentV studentV) {
        System.out.println("访问者1访问学生：" + studentV.name);
    }

    @Override
    public void visitTeacher(PersonV personV) {
        System.out.println("访问者1访问老师：" + personV.name);
    }
}

class Visitor2 implements Visitor { // 访问者2

    @Override
    public void visitStudent(StudentV studentV) {
        System.out.println("访问者2访问：" + studentV.name);
    }

    @Override
    public void visitTeacher(PersonV personV) {
        System.out.println("访问者2访问：" + personV.name);
    }
}


class Struct {
    private List<PersonV> personVList = new ArrayList<>();

    public Struct() {
        personVList.add(new StudentV("张三"));
        personVList.add(new StudentV("李四"));
        personVList.add(new StudentV("王五"));
        personVList.add(new TeacherV("李老师"));
        personVList.add(new TeacherV("陈老师"));
        personVList.add(new TeacherV("王老师"));
    }

    public void visit(Visitor visitor) {
        for (PersonV personV : personVList) {
            personV.accept(visitor);
        }
    }
}

abstract class PersonV {
    protected String name;

    abstract void accept(Visitor visitor);
}

class StudentV extends PersonV {

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

    public void accept(Visitor visitor) {
        visitor.visitStudent(this);
    }
}

class TeacherV extends PersonV {
    public TeacherV(String name) {
        this.name = name;
    }

    public void accept(Visitor visitor) {
        visitor.visitTeacher(this);
    }
}

原文地址：http://www.cnblogs.com/nwnusun/p/16797741.html