Java 设计模式

    public static Singleton getInstance() {
        if (singleton == null) {  // 线程A和线程B同时看到singleton = null，如果不为null，则直接返回singleton
            synchronized(Singleton.class) { // 线程A或线程B获得该锁进行初始化
                if (singleton == null) { // 其中一个线程进入该分支，另外一个线程则不会进入该分支
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
    
}

public class Singleton {
    
    private static volatile Singleton singleton;//volatile是保证创建对象是线性执行
    
    private Singleton(){}//无参构造方法
    
    public static Singleton getInstance() {
        if (singleton == null) {  // 线程A和线程B同时看到singleton = null，如果不为null，则直接返回singleton
            synchronized(Singleton.class) { // 线程A或线程B获得该锁进行初始化
                if (singleton == null) { // 其中一个线程进入该分支，另外一个线程则不会进入该分支
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
    
}

public class Singleton{
    
    private static final Singleton singleton = new Singleton();//实例化对象
    
    private Singleton(){}
    
    public static Singleton getInstance() {
        return singleton;
    }
}

public enum Singleton {
    INSTANCE;
    
    public void doSomething() {
        System.out.println("这是枚举类型的单例模式！");
    }
}

public interface Shape{
    void draw();
}

public class Circle implements Shape{
    
    @Override
    public void draw(){
        System.out.print("形状工厂里面执行画‘Circle’的方法");
    }
}

public class Square implements Shape{
    
    @Override 
    public void draw(){
        System.out.print("形状工厂里面执行画‘Square’的方法")
    }
}

public class Rectangle implements Shape{
    
    @Overrdie
    public void draw(){
        Sysetem.out.print("形状工厂里面执行画‘Square’的方法");
    }
}

public class ShapeFactory{
	
	//返回值类型为Shape,自定义方法名称getShape，传入参数shapeType
	public static Shape getShape(String shapeType){
		//如果传入参数为空，
		if(shapeType == null == shapeType.trim().equals(""))
			return null;
		//传入可以使用的名称
		if(shapeType.equalsIgnoreCase("CIRCLE")){
			return new Circle();
		}else if(shapeType.equalsIgnoreCase("Square")){
			return new Rectangle();
		}else if(shapeType.equalsIgnoreCase("Rectangle")){
			return new Square();
		}
		return null;
	}
}

public class FactoryPatternDemo{
	public static void main(String[] args){
        
        //使用工厂类方法，获取Shape引用类型的对象，并且调用其draw方法
        Shape shape1 = ShapeFactory.getShape("CIRCLE");
        //这里是隐藏了new Circle，因为在工厂类做好了。
        shape1.draw();
        
        //使用工厂类方法，获取Shape引用类型的对象，并且调用其draw方法
        Shape shape2 = ShapeFactory.getShape("Square");
        shape2.draw();
        
         //使用工厂类方法，获取Shape引用类型的对象，并且调用其draw方法
        Shape shape3 = ShapeFactory.getShape("Rectangle");
        shape3.draw();
        
    }
}
形状工厂里面执行画‘Circle’的方法

形状工厂里面执行画‘Square’的方法

形状工厂里面执行画‘Square’的方法

public abstract class AbstractFactory {
    public abstract Color getColor(String color);
    public abstract Shape getShape(String shape) ;
}

public interface Shape {
    void draw();
}

public class Circle implements Shape {

    @Override
    public void draw() {
        System.out.println("Inside Circle::draw() method.");
    }
}

public class Rectangle implements Shape {

    @Override
    public void draw() {
        System.out.println("Inside Rectangle::draw() method.");
    }
}

public class Square implements Shape {

    @Override
    public void draw() {
        System.out.println("Inside Square::draw() method.");
    }
}

public class ShapeFactory extends AbstractFactory {
    //使用 getShape 方法获取形状类型的对象
    @Override
    public Shape getShape(String shapeType){
        //如果传入的字符串为空
        if(shapeType == null||shapeType.trim().equals("")){
            return null;
        }

        // 更具 传进来的 名称 来获取 对应的对象
        if(shapeType.equalsIgnoreCase("CIRCLE")){
            return new Circle();
        } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
            return new Rectangle();
        } else if(shapeType.equalsIgnoreCase("SQUARE")){
            return new Square();
        }
        return null;
    }

    @Override
    public Color getColor(String color) {
        return null;
    }
}

public interface Color {
    void fill();
}

public class Red implements Color {

    @Override
    public void fill() {
        System.out.println("Inside Red::fill() method.");
    }
}

//绿色
public class Green implements Color {

    @Override
    public void fill() {
        System.out.println("Inside Green::fill() method.");
    }
}

public class Blue implements Color {

    @Override
    public void fill() {
        System.out.println("Inside Blue::fill() method.");
    }
}

public class ColorFactory extends AbstractFactory {
    @Override
    public Color getColor(String color) {
        if(color == null||color.trim().equals("")){
            return null;
        }
        if(color.equalsIgnoreCase("RED")){
            return new Red();
        } else if(color.equalsIgnoreCase("GREEN")){
            return new Green();
        } else if(color.equalsIgnoreCase("BLUE")){
            return new Blue();
        }
        return null;
    }

    @Override
    public Shape getShape(String shape) {
        return null;
    }
}

public class FactoryProducer {
    public static AbstractFactory getFactory(String choice){
        if(choice.equalsIgnoreCase("SHAPE")){
            return new ShapeFactory();
        } else if(choice.equalsIgnoreCase("COLOR")){
            return new ColorFactory();
        }
        return null;
    }
}

public class AbstractFactoryPatternDemo {
    public static void main(String[] args) {
        //获取形状工厂
        AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
        //获取形状为 Circle 的对象
        Shape shape1 = shapeFactory.getShape("CIRCLE");
        //调用 Circle 的 draw 方法
        shape1.draw();

        
        //获取颜色工厂
        AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
        //获取颜色为 Blue 的对象
        Color color1 = colorFactory.getColor("BLUE");
        //调用 Blue 的 fill 方法
        color1.fill();
    }
}

@Data
public class Clazz implements Cloneable {
    private String name;
    private Student student;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student implements Serializable {
    private String name;
    private String sex;
    private Integer age;
}
 
    public static void main(String[] args) throws Exception{
        Clazz clazz1 = new Clazz();
        clazz1.setName("高三一班");
        Student stu1 = new Student("张三", "男", 18);
        clazz1.setStudent(stu1);
        System.out.println(clazz1); // Clazz(name=高三一班, student=Student(name=张三, sex=男, age=18))
        Clazz clazz2 = (Clazz)clazz1.clone();
        Student stu2 = clazz2.getStudent();
        stu2.setName("李四");
        System.out.println(clazz1); // Clazz(name=高三一班, student=Student(name=李四, sex=男, age=18))
        System.out.println(clazz2); // Clazz(name=高三一班, student=Student(name=李四, sex=男, age=18))
    }

class Person implements Cloneable {
    private String name;
    private Address address;
    
    public Person(String name, Address address) {
        this.name = name;
        this.address = address;
    }
    
    public String getName() {
        return name;
    }
    
    public Address getAddress() {
        return address;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public void setAddress(Address address) {
        this.address = address;
    }
    
    @Override
    //递归的把属性克隆
    //如果是浅克隆那就直接： return super.clone();不用把所有属性递归克隆
    protected Object clone() throws CloneNotSupportedException {
        Person cloned = (Person) super.clone();
        cloned.address = (Address) address.clone();
        return cloned;
    }
}
 
class Address implements Cloneable {
    private String city;
    
    public Address(String city) {
        this.city = city;
    }
    
    public String getCity() {
        return city;
    }
    
    public void setCity(String city) {
        this.city = city;
    }
    
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
 
public class Main {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address address = new Address("London");
        Person person1 = new Person("Alice", address);
        
        Person person2 = (Person) person1.clone();
        
        System.out.println(person1.getName());                // Alice
        System.out.println(person1.getAddress().getCity());  // London
        
        System.out.println(person2.getName());                // Alice
        System.out.println(person2.getAddress().getCity());  // London
        
        person2.setName("Bob");
        person2.getAddress().setCity("New York");
        
        System.out.println(person1.getName());                // Alice
        System.out.println(person1.getAddress().getCity());  // London
        
        System.out.println(person2.getName());                // Bob
        System.out.println(person2.getAddress().getCity());  // New York
    }
}

@Data
public class Clazz implements Cloneable, Serializable {
    private String name;
    private Student student;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
 
    protected Object deepClone() throws IOException, ClassNotFoundException {
        //先把对象以对象流的方式输出
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);//序列化
        //在以对象流输入，这样一起进出
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();//反序列化
    }
}
 
    public static void main(String[] args) throws Exception{
        Clazz clazz1 = new Clazz();
        clazz1.setName("高三一班");
        Student stu1 = new Student("张三", "男", 18);
        clazz1.setStudent(stu1);
        Clazz clazz3 = (Clazz)clazz1.deepClone();
        Student stu3 = clazz3.getStudent();
        stu3.setName("王五");
        System.out.println(clazz1); // Clazz(name=高三一班, student=Student(name=张三, sex=男, age=18))
        System.out.println(clazz3); // Clazz(name=高三一班, student=Student(name=王五, sex=男, age=18))
    }

//产品类 电脑
@Data
public class Computer {
    private String motherboard;
    private String cpu;
    private String memory;
    private String disk;
    private String gpu;
    private String power;
    private String heatSink;
    private String chassis;
}
// 抽象 builder类（接口） 组装电脑
public interface ComputerBuilder { 
    Computer computer = new Computer();
    void buildMotherboard();
    void buildCpu();
    void buildMemory();
    void buildDisk();
    void buildGpu();
    void buildHeatSink();
    void buildPower();
    void buildChassis();
    Computer build();
}
// 具体 builder类 华硕ROG全家桶电脑（手动狗头）
public class AsusComputerBuilder implements ComputerBuilder {
    @Override 
    public void buildMotherboard() {
        computer.setMotherboard("Extreme主板");
    }
    @Override
    public void buildCpu() {
        computer.setCpu("Inter 12900KS");
    }
    @Override
    public void buildMemory() {
        computer.setMemory("芝奇幻峰戟 16G*2");
    }
    @Override
    public void buildDisk() {
        computer.setDisk("三星980Pro 2T");
    }
    @Override
    public void buildGpu() {
        computer.setGpu("华硕3090Ti 水猛禽");
    }
    @Override
    public void buildHeatSink() {
        computer.setHeatSink("龙神二代一体式水冷");
    }
    @Override
    public void buildPower() {
        computer.setPower("雷神二代1200W");
    }
    @Override
    public void buildChassis() {
        computer.setChassis("太阳神机箱");
    }
    @Override
    public Computer build() {
        return computer;
    }
}
// 指挥者类 指挥该组装什么电脑
@AllArgsConstructor
public class ComputerDirector {
    private ComputerBuilder computerBuilder;
    public Computer construct() {
        computerBuilder.buildMotherboard();
        computerBuilder.buildCpu();
        computerBuilder.buildMemory();
        computerBuilder.buildDisk();
        computerBuilder.buildGpu();
        computerBuilder.buildHeatSink();
        computerBuilder.buildPower();
        computerBuilder.buildChassis();
        return computerBuilder.build();
    }
}
   // 测试
    public static void main(String[] args) {
        ComputerDirector computerDirector = new ComputerDirector(new AsusComputerBuilder());
        // Computer(motherboard=Extreme主板, cpu=Inter 12900KS, memory=芝奇幻峰戟 16G*2, disk=三星980Pro 2T, gpu=华硕3090Ti 水猛禽, power=雷神二代1200W, heatSink=龙神二代一体式水冷, chassis=太阳神机箱)
        System.out.println(computerDirector.construct());
    }

// 把指挥者类和抽象建造者合在一起的简化建造者类
public class SimpleComputerBuilder {
    private Computer computer = new Computer();
    public void buildMotherBoard(String motherBoard){
        computer.setMotherboard(motherBoard);
    }
    public void buildCpu(String cpu){
        computer.setCpu(cpu);
    }
    public void buildMemory(String memory){
        computer.setMemory(memory);
    }
    public void buildDisk(String disk){
        computer.setDisk(disk);
    }
    public void buildGpu(String gpu){
        computer.setGpu(gpu);
    }
    public void buildPower(String power){
        computer.setPower(power);
    }
    public void buildHeatSink(String heatSink){
        computer.setHeatSink(heatSink);
    }
    public void buildChassis(String chassis){
        computer.setChassis(chassis);
    }
    public Computer build(){
        return computer;
    }
}
    // 测试
    public static void main(String[] args) {
        SimpleComputerBuilder simpleComputerBuilder = new SimpleComputerBuilder();
        simpleComputerBuilder.buildMotherBoard("Extreme主板");
        simpleComputerBuilder.buildCpu("Inter 12900K");
        simpleComputerBuilder.buildMemory("芝奇幻峰戟 16G*2");
        simpleComputerBuilder.buildDisk("三星980Pro 2T");
        simpleComputerBuilder.buildGpu("华硕3090Ti 水猛禽");
        simpleComputerBuilder.buildPower("雷神二代1200W");
        simpleComputerBuilder.buildHeatSink("龙神二代一体式水冷");
        simpleComputerBuilder.buildChassis("太阳神机箱");
        // Computer(motherboard=Extreme主板, cpu=Inter 12900K, memory=芝奇幻峰戟 16G*2, disk=三星980Pro 2T, gpu=华硕3090Ti 水猛禽, power=雷神二代1200W, heatSink=龙神二代一体式水冷, chassis=太阳神机箱)
        System.out.println(simpleComputerBuilder.build());
    }

// 链式写法建造者类
public class SimpleComputerBuilder {
    private Computer computer = new Computer();
    public SimpleComputerBuilder buildMotherBoard(String motherBoard){
        computer.setMotherboard(motherBoard);
        return this;
    }
    public SimpleComputerBuilder buildCpu(String cpu){
        computer.setCpu(cpu);
        return this;
    }
    public SimpleComputerBuilder buildMemory(String memory){
        computer.setMemory(memory);
        return this;
    }
    public SimpleComputerBuilder buildDisk(String disk){
        computer.setDisk(disk);
        return this;
    }
    public SimpleComputerBuilder buildGpu(String gpu){
        computer.setGpu(gpu);
        return this;
    }
    public SimpleComputerBuilder buildPower(String power){
        computer.setPower(power);
        return this;
    }
    public SimpleComputerBuilder buildHeatSink(String heatSink){
        computer.setHeatSink(heatSink);
        return this;
    }
    public SimpleComputerBuilder buildChassis(String chassis){
        computer.setChassis(chassis);
        return this;
    }
    public Computer build(){
        return computer;
    }
}
    // 测试
    public static void main(String[] args) {
        Computer asusComputer = new SimpleComputerBuilder().buildMotherBoard("Extreme主板")
            .buildCpu("Inter 12900K")
            .buildMemory("芝奇幻峰戟 16G*2")
            .buildDisk("三星980Pro 2T")
            .buildGpu("华硕3090Ti 水猛禽")
            .buildPower("雷神二代1200W")
            .buildHeatSink("龙神二代一体式水冷")
            .buildChassis("太阳神机箱").build();
        System.out.println(asusComputer);
    }

public class Source {
 
	public void method1() {
		System.out.println("this is original method!");
	}
}

public interface Targetable {
 
	/* 与原类中的方法相同 */
	public void method1();
 
	/* 新类的方法 */
	public void method2();
}

public class Adapter extends Source implements Targetable {
 
	@Override
	public void method2() {
		System.out.println("this is the targetable method!");
	}
}

public class AdapterTest {
 
	public static void main(String[] args) {
		Targetable target = new Adapter();
		target.method1();
		target.method2();
	}
}

public class Wrapper implements Targetable {
 
	private Source source;
	
	public Wrapper(Source source){
		super();
		this.source = source;
	}
	@Override
	public void method2() {
		System.out.println("this is the targetable method!");
	}
 
	@Override
	public void method1() {
		source.method1();
	}
}

public class AdapterTest {
 
	public static void main(String[] args) {
		Source source = new Source();
		Targetable target = new Wrapper(source);
		target.method1();
		target.method2();
	}
}

public interface Sourceable {
	
	public void method1();
	public void method2();
}

public abstract class Wrapper2 implements Sourceable{
	
	public void method1(){}
	public void method2(){}
}

public class SourceSub1 extends Wrapper2 {
	public void method1(){
		System.out.println("the sourceable interface's first Sub1!");
	}
}

public class SourceSub2 extends Wrapper2 {
	public void method2(){
		System.out.println("the sourceable interface's second Sub2!");
	}
}

public class WrapperTest {
 
	public static void main(String[] args) {
		Sourceable source1 = new SourceSub1();
		Sourceable source2 = new SourceSub2();
		
		source1.method1();
		source1.method2();
		source2.method1();
		source2.method2();
	}
}

//接口
public interface SellTickets {
    void sell(); // 卖票方法
}
//直接实现类
public class TrainStation implements SellTickets{
    @Override
    public void sell() {
        System.out.println("Sell方法执行");
    }
}
//代理实现类，把直接实现类作为成员变量
public class ProxyPoint implements SellTickets{

    private TrainStation trainStation = new  TrainStation();

    @Override
    public void sell() {
        System.out.println("静态代理");
        trainStation.sell();
    }
}
//测试
public class Client {
    public static void main(String[] args) {
        //先创建代理类对象，在使用对应方法
        ProxyPoint proxyPoint = new ProxyPoint();
        proxyPoint.sell();
    }
}

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException{
        ……
        }
//使用Proxy获取代理对象
        /*
            newProxyInstance()方法参数说明：
                ClassLoader loader ： 类加载器，用于加载代理类，使用真实对象的类加载器即可
                Class<?>[] interfaces ： 真实对象所实现的接口，代理模式真实对象和代理对象实现相同的接口
                InvocationHandler h ： 代理对象的调用处理程序
         */
//其中InvocationHander h为下
/*
                        InvocationHandler中invoke方法参数说明：
                            proxy ： 代理对象
                            method ： 对应于在代理对象上调用的接口方法的 Method 实例
                            args ： 代理对象调用接口方法时传递的实际参数
                     */

public interface SellTickets {
    void sell(); // 卖票方法
}

public class TrainStation implements SellTickets{
    @Override
    public void sell() {
        System.out.println("Sell方法执行");
    }
}

public class ProxyFactory {
	//将实现类作为成员变量
    private TrainStation trainStation = new TrainStation();
	//实现获取SellTickets方法，返回类型是SellTickets。这样就用一个代理方法得到接口SellTickets所有的方法
    public SellTickets getSellTickets() {
		//封装成SellTickets类型，
        /*
        左边使用Proxy中的创建代理类方法，
        */
        SellTickets sellTickets = (SellTickets) Proxy.newProxyInstance(
                trainStation.getClass().getClassLoader(),
                trainStation.getClass().getInterfaces(),
                (proxy, method, args) -> {
                    System.out.println("JDK代理");
                    Object invoke = method.invoke(trainStation, args);
                    return invoke;
                });
        return sellTickets;///最后得到接口中所有方法
    }
}

public class Client1 {
    public static void main(String[] args) {
        //创建工厂类对象
        ProxyFactory proxyFactory = new ProxyFactory();
        //使用工厂中获取方法
        SellTickets sellTickets = proxyFactory.getSellTickets();
        //调用该方法中的sell（）方法
        sellTickets.sell();
    }
}

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>2.2.2</version>
</dependency>

public class TrainStation1 {

    public void sell() {
        System.out.println("火车站卖票");
    }
}

public class ProxyFactory_Cglib implements MethodInterceptor {
	
    private TrainStation1 station1 = new TrainStation1();

    //创建代理类对象,
    public TrainStation1 getStation1() {
        //创建Enhancer对象，类似JDK代理中的proxy类
        Enhancer enhancer = new Enhancer();
        // 设置父类
        enhancer.setSuperclass(TrainStation1.class);
        // 设置回调函数
        enhancer.setCallback(this);
        // 创建代理类
        return (TrainStation1) enhancer.create();
    }
    //重写方法
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("CGlib: intercept");
        return (TrainStation1)methodProxy.invokeSuper(o,objects);
    }
}

public class Client2 {
    public static void main(String[] args) {
        ProxyFactory_Cglib proxyFactoryCglib = new ProxyFactory_Cglib();
        TrainStation1 station1 = proxyFactoryCglib.getStation1();
        station1.sell();
    }
}

public interface ColorAPI {
    public void paint();
}

public class BlueColorAPI implements ColorAPI {
    @Override
    public void paint() {
        System.out.println("画上蓝色");
    }
}

public class RedColorAPI implements ColorAPI
{
    @Override
    public void paint() {
        System.out.println("画上红色");
    }
}

public abstract class Shape {
    protected ColorAPI colorAPI;    //添加一个颜色的成员变量以调用ColorAPI 的方法来实现给不同的形状上色

    public void setDrawAPI(ColorAPI colorAPI) {      //注入颜色成员变量
        this.colorAPI= colorAPI;
    }
    public abstract void draw();        
}

public class Circle extends Shape {
    @Override
    public void draw() {
        System.out.print("我是圆形");
        colorAPI.paint();
    }
}

public class Rectangle extends Shape {
    @Override
    public void draw() {
        System.out.print("我是长方形");
        colorAPI.paint();
    }
}

public class Client {

    public static void main(String[] args) {
        //创建一个圆形
        Shape shape = new Circle();
        //给圆形蓝色的颜料
        shape.setDrawAPI(new BlueColorAPI());
        //上色
        shape.draw();


        //创建一个长方形
        Shape shape1 = new Rectangle();
        //给长方形红色的颜料
        shape1.setDrawAPI(new RedColorAPI());
        //上色
        shape1.draw();

    }
}

public interface INodes {
    public void cook();
}

public class Noodles implements INodes {
    @Override
    public void cook() {
        System.out.println("基本方法：做饭");
    }
}

public abstract class NoodlesDecorator implements INodes {
    private Noodles  noodles;

    public NoodlesDecorator() {
    }

    public NoodlesDecorator(Noodles noodles) {
        this.noodles = noodles;
    }

    public void cook(){
       noodles.cook();
    }
}

public class EggNoodles extends NoodlesDecorator{

    public EggNoodles(Noodles noodles) {
        super(noodles);
    }

    @Override
    public void cook() {
        System.out.println("加鸡蛋");
        super.cook();
    }
}

public class Test {
    @org.junit.Test
    public void testCook(){
        //在EggNoodles中直接super了noodls对象，并且参数为noodles，所以在调用时，创建Eggnooles对象，调用父类参数，然
        //然后再后
        EggNoodles eggNoodles = new EggNoodles(new Noodles());
        //等价于
        Noodles nooles = new Noodles();
        Noodles  new EggNooles()
        eggNoodles.cook();
    }
}

public interface TravelFacade {

    void dePart();

}

public class TravelFacadeImpl implements TravelFacade{
    private HotelService hotelService;
    private FlightService flightService;
    private TicketService ticketService;
 
    public TravelFacadeImpl(){
        hotelService=new HotelService();
        flightService=new FlightService();
        ticketService=new TicketService();
    }
 
    @Override
    public void dePart(){
        hotelService.bookHotel();
        flightService.bookFlight();
        ticketService.bookTicket();
    }
}

public class FlightService {
    public void bookFLight(){
        System.out.println("去预定航班");
    }
}

public class HotelService {
    public void bookHotel(){
        System.out.println("预定酒店成功");
    }
}

public class TicketService {

    public void bookTicket(){
        System.out.println("预定门票成功");
    }
}

   @Test
    public void dePart() {
        TravelFacade travelFacade= new TravelFacadeImpl();
        travelFacade.dePart();
        
    }

// 抽象类，表示豆浆	SoyaMilk.java
public abstract class SoyaMilk {
	// 模板方法：可以做成final，不让子类去覆盖
	final void make() {
		select();
		addCondiment();
		soak();
		beat();
	}
	
	//选材料
	void select() { System.out.println("第一步：选择新鲜的豆子"); }
	//添加不同的配料：抽象方法，由子类具体实现
	abstract void addCondiment();
	//浸泡
	void soak() { System.out.println("第三步：豆子和配料开始浸泡3H"); }
	//榨汁
	void beat() { System.out.println("第四步：豆子和配料放入豆浆机榨汁"); }
}

// RedBeanSoyaMilk.java
public class ReadBeanSoyaMilk extends SoyaMilk {
	@Override
	void addCondiment() {
		System.out.println("第二步：加入上好的红豆");
	}
}

// PeanutSoyMilk.java
public class PeanutSoyaMilk extends SoyaMilk {
	@Override
	void addCondiment() {
		System.out.println("第二步：加入上好的花生");
	}
}

// Client.java
public class Client {
	public static void main(String[] args) {
		System.out.println("=======制作红豆豆浆=======");
		SoyaMilk redBeanSoyaMilk = new ReadBeanSoyaMilk();
		redBeanSoyaMilk.make();
		
		System.out.println("=======制作花生豆浆=======");
		SoyaMilk peanutSoyaMilk = new PeanutSoyaMilk();
		peanutSoyaMilk.make();
	}
}

// RedBeanSoyaMilk.java/PeanutSoyaMilk.java同上，略

//抽象类，表示豆浆，SoyaMilk
public abstract class SoyaMilk {

	//模板方法：可以做成final，不让子类去覆盖
	final void make() {
		select();
		if(customerWantCondiment()) {
			addCondiment();
		}	
		soak();
		beat();
	}

	//1.选材料
	void select() { System.out.println("第一步：选择新鲜的豆子"); }
	//2.添加不同的配料：抽象方法，由子类具体实现
	abstract void addCondiment();
	//3.浸泡
	void soak() { System.out.println("第三步：豆子和配料开始浸泡3H"); }
	//4.榨汁
	void beat() { System.out.println("第四步：豆子和配料放入豆浆机榨汁"); }

	//钩子方法：决定是否需要添加配料
	boolean customerWantCondiment() {
		return true;//默认情况下是要加配料的
	}
}

// PureSoyaMilk.java
public class PureSoyaMilk extends SoyaMilk {
	@Override
	void addCondiment() {
		// 添加配料的方法 空实现 即可
	}
	@Override
	boolean customerWantCondiment() {
		return false;
	}
}

// Client.java
public class Client {
	public static void main(String[] args) {
		System.out.println("=制作纯豆浆=");
		SoyaMilk pureSoyMilk = new PureSoyaMilk();
		pureSoyMilk.make();
	}
}

public abstract  class Duck {
    public Duck() {
    }
    public abstract void display();

    public void quack(){
        System.out.println("鸭子叫");
    }
    public void fly(){
        System.out.println("鸭子飞");
    }
    public void swim(){
        System.out.println("鸭子游泳");
    }
}

public class DryDuck extends Duck{
    @Override
    public void display() {
        System.out.println("这是旱鸭");
    }

    @Override
    public void swim() {
        System.out.println("不会游泳");
    }
}

public class Teal extends Duck{
    @Override
    public void display() {
        System.out.println("这是水鸭");
    }
    //水鸭不会飞，所以要重写这个方法
    @Override
    public void fly() {
        System.out.println("水鸭不会飞");
    }
}

public class NoflyDuck extends Duck{
    @Override
    public void display() {
        System.out.println("这是不会飞的鸭");
    }

    @Override
    public void fly() {
        System.out.println("不会飞的鸭");    }

}

public interface FlyAct {
    void fly();
}

public class CanFly implements FlyAct{
    @Override
    public void fly() {
        System.out.println("可以飞");
    }
}

public class NoFly implements FlyAct {
    @Override
    public void fly() {
        System.out.println("不会飞");
    }
}

public class DryDuck extends Duck{

    @Override
    public void display() {
        System.out.println("这是旱鸭");
    }
    public DryDuck() {
        NoFly noFly = new NoFly();
    }
}

public class Test {
    public static void main(String[] args) {
        DryDuck dryDuck = new DryDuck();
        
        dryDuck.setFlyAct(new NoFly());
        dryDuck.fly();
        
        dryDuck.setFlyAct(new CanFly());
        dryDuck.fly();
    }
}
/*
不会飞
可以飞
*/

public class GameUser {
    private SwitchRoles user;//创建引用数据类型

    public void SwitchRoles(){//切换角色的方法
        user.Switch();
    }

    public GameUser() {//无参构造方法
    }

    public GameUser(SwitchRoles user) {//有参构造方法
        this.user = user;
    }

    public void setUser(SwitchRoles user) {//setter方法
        this.user = user;
    }
}

package Interface;

public interface SwitchRoles {
    void Switch();//写入Swtich方法
}

public class A  implements SwitchRoles {
    @Override
    public void Switch() {
        System.out.println("切换战士角色");
    }
}

public class B implements SwitchRoles {
    @Override
    public void Switch() {
        System.out.println("切换法师角色");
    }
}

public class Test1 {
    public static void main(String[] args) {
        //使用策略A
        GameUser gameUser = new GameUser(new A());//创建对象，参数使用A的实现
        gameUser.SwitchRoles();
        //使用策略B
        GameUser gameUser1 = new GameUser(new B());//创建对象，参数使用B的实现
        gameUser1.SwitchRoles();
        //由切换策略B
        gameUser.setUser(new B());//利用set方法修改为实现类B
        gameUser.SwitchRoles();

    }

}

public enum Strategy {
    A{
        @Override
        public void exe() {
            System.out.println("执行具体策略A");
        }
    },
    B{
        @Override
        public  void exe() {
            System.out.println("执行具体策略B");
        }
    };
    public abstract void exe();//抽象策略
}
public class Test {
    public static void main(String[] args) {
        Map<String, Strategy> map=new LinkedHashMap<>();
        map.put("A",Strategy.A);
        map.put("B",Strategy.B);
        String str="A";
        map.get(str).exe();
    }
}

 
//促销策略(包含抽象策略和具体策略)
public enum PromotionStrategy {
    /**
     * 促销活动
     */
    MJPS{
        @Override
    	public void doPromotion() {
        	System.out.println("满减促销 , 满 100 减 20");
        }
    },
    FXPS{
        @Override
    	public void doPromotion() {
        	System.out.println("返现促销 , 返优惠券 10 元");
        }
    },
    EMPS{
        @Override
    	public void doPromotion() {
        	System.out.println("原价出售");
        }
    };
    public abstract void doPromotion();
}



//促销策略工厂类
public class PromotionStrategyFactory {
    private static HashMap<String, PromotionStrategy> ps = new HashMap<>();
    static {
        ps.put(PromotionKey.MANJIAN, PromotionStrategy.MJPS);
        ps.put(PromotionKey.FANXIAN, PromotionStrategy.FXPS);
    }

	//使用这种方式声明常量 , 可以起到逻辑上分组的作用
    public interface PromotionKey {
        String MANJIAN = "ManJian";
        String FANXIAN = "FanXian";
    }
	
	//构造函数不能被外界访问
    private PromotionStrategyFactory() {
    }

	//根据传入的键值获取相应的促销策略
    public static PromotionStrategy getPromotionStrategy(String promotionKey) {
        PromotionStrategy promotionStrategy = ps.get(promotionKey);
        return promotionStrategy != null ? promotionStrategy : PromotionStrategy.EMPS;
    }

    
}





/**
 * 促销活动
 */
public class PromotionActivity {
    /**
     * 促销策略 , 通过构造器注入
     */
    private PromotionStrategy promotionStrategy;

    public PromotionActivity(PromotionStrategy promotionStrategy) {
        this.promotionStrategy = promotionStrategy;
    }

    /**
     * 执行促销策略
     */
    public void executePromotionStrategy() {
        this.promotionStrategy.doPromotion();
    }
}



public class Main {
    public static void main(String[] args) {
        // 获取促销策略
        PromotionStrategy promotionStrategy = PromotionStrategyFactory.
                getPromotionStrategy(PromotionStrategyFactory.PromotionKey.FANXIAN);
        // 创建促销活动 , 并执行促销策略
        PromotionActivity promotionActivity = new PromotionActivity(promotionStrategy);
        // 执行促销策略
        promotionActivity.executePromotionStrategy();
    }
}

public class Game {

    private String name;

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

    public void open() {
        System.out.println(this.name + " 开放");
    }

    public void close() {
        System.out.println(this.name + " 关闭");
    }

}

public interface Command {
    void execute();
}

/**
 * @program: 设计模式
 * @description: 关闭命令
 * @author: WMS
 * @create: 2024-11-19 20:36
 **/
public class CloseCommand implements Command {


    private Game  game;

    public CloseCommand(Game game) {
        this.game = game;
    }

    @Override
    public void execute() {
       this.game.close();
    }
}

/**
 * @program: 设计模式
 * @description: 实现命令
 * @author: WMS
 * @create: 2024-11-19 20:34
 **/
public class OpenCommand implements Command {
    private Game game;

    public OpenCommand(Game game) {
        this.game = game;
    }

    @Override
    public void execute() {
        this.game.open();
    }
}

public class Manager {
    private ArrayList<Command> commands = new ArrayList<Command>();

    public void addCommand(Command command) {
        commands.add(command);
    }
    public void executeCommand() {
        for (Command c : commands) {
            c.execute();
        }
        commands.clear();
    }
}

 @Test
    public void addCommand() {
        //创建实体
        Game test1 = new Game("test1");
        //创建命令
        OpenCommand openCommand = new OpenCommand(test1);
        CloseCommand closeCommand = new CloseCommand(test1);

        //发送命令
        Manager manager = new Manager();//创建执行者
        manager.addCommand(openCommand);//添加命令
        manager.addCommand(closeCommand);//添加命令
        manager.executeCommand();//执行命令


    }

//请假条实体数据
public class LeaveRequest {
    private String name;//姓名
    private int num;//请假天数
    private String content;//请假内容

    public LeaveRequest(String name, int num, String content) {
        this.name = name;
        this.num = num;
        this.content = content;
    }

    public String getName() {
        return name;
    }

    public int getNum() {
        return num;
    }

    public String getContent() {
        return content;
    }
}

//处理者抽象类
public abstract class Handler {
    protected final static int NUM_ONE = 1;
    protected final static int NUM_THREE = 3;
    protected final static int NUM_SEVEN = 7;

    //该领导处理的请假天数区间
    private int numStart;
    private int numEnd;

    //领导上面还有领导（处理链）
    private Handler nextHandler;
     //设置上级领导（处理链的连接）
    public void setNextHandler(Handler nextHandler){
        this.nextHandler = nextHandler;
    }

    //设置请假天数范围 上不封顶
    public Handler(int numStart) {
        this.numStart = numStart;
    }

    //设置请假天数范围
    public Handler(int numStart, int numEnd) {
        this.numStart = numStart;
        this.numEnd = numEnd;
    }

   

    //提交请假条
    public final void submit(LeaveRequest leave){
        if(0 == this.numStart){
            return;
        }

        //如果请假天数达到该领导者的处理要求
        if(leave.getNum() >= this.numStart){
            this.handleLeave(leave);

            //如果还有上级 并且请假天数超过了当前领导的处理范围
            if(null != this.nextHandler && leave.getNum() > numEnd){
                this.nextHandler.submit(leave);//继续提交
            } else {
                System.out.println("流程结束");
            }
        }
    }

    //各级领导处理请假条方法（抽象处理方法）
    protected abstract void handleLeave(LeaveRequest leave);
}

//小组长（具体处理器A）
public class GroupLeader extends Handler {
    public GroupLeader() {
        //小组长处理1-3天的请假
        super(Handler.NUM_ONE, Handler.NUM_THREE);
    }

    @Override
    protected void handleLeave(LeaveRequest leave) {
        System.out.println(leave.getName() + "请假" + leave.getNum() + "天," + leave.getContent() + "。");
        System.out.println("小组长审批：同意。");
    }
}

//部门经理（具体处理器B）
public class Manager extends Handler {
    public Manager() {
        //部门经理处理3-7天的请假
        super(Handler.NUM_THREE, Handler.NUM_SEVEN);
    }

    @Override
    protected void handleLeave(LeaveRequest leave) {
        System.out.println(leave.getName() + "请假" + leave.getNum() + "天," + leave.getContent() + "。");
        System.out.println("部门经理审批：同意。");
    }
}

//总经理（具体处理器C）
public class GeneralManager extends Handler {
    public GeneralManager() {
        //部门经理处理7天以上的请假
        super(Handler.NUM_SEVEN);
    }

    @Override
    protected void handleLeave(LeaveRequest leave) {
        System.out.println(leave.getName() + "请假" + leave.getNum() + "天," + leave.getContent() + "。");
        System.out.println("总经理审批：同意。");
    }
}

//测试类(调用方法)
public class Client {
    public static void main(String[] args) {
        //请假条来一张（创建实体）
        LeaveRequest leave = new LeaveRequest("小花",5,"身体不适");

        //各位领导（调用具体的处理器）
        GroupLeader groupLeader = new GroupLeader();
        Manager manager = new Manager();
        GeneralManager generalManager = new GeneralManager();
		//设置处理链顺序
        groupLeader.setNextHandler(manager);//小组长的领导是部门经理
        manager.setNextHandler(generalManager);//部门经理的领导是总经理
        //之所以在这里设置上级领导，是因为可以根据实际需求来更改设置，如果实战中上级领导人都是固定的，则可以移到领导实现类中。

        //提交申请
        groupLeader.submit(leave);
    }
}

// 处理器接口
abstract class Handler {
    // 创建具体责任链实体
    protected Handler nextHandler;
	// setter方法
    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }
	// 责任链的抽象方法
    public abstract void handleRequest(String request);
}

// 具体处理器A
class ConcreteHandlerA extends Handler {
    // 具体处理器重写责任链方法
    @Override
    public void handleRequest(String request) {
        if ("A".equals(request)) {
            System.out.println("ConcreteHandlerA handled request: " + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        } else {
            System.out.println("No handler for request: " + request);
        }
    }
}

// 具体处理器B
class ConcreteHandlerB extends Handler {
    @Override
    public void handleRequest(String request) {
        if ("B".equals(request)) {
            System.out.println("ConcreteHandlerB handled request: " + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        } else {
            System.out.println("No handler for request: " + request);
        }
    }
}

// 客户端
public class Main {
    public static void main(String[] args) {
        // 创建具体责任链子链
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();
		// 设置责任链顺序
        handlerA.setNextHandler(handlerB);
		// 调用责任链顺序方法
        handlerA.handleRequest("A"); // Output: ConcreteHandlerA handled request: A
        handlerA.handleRequest("B"); // Output: ConcreteHandlerB handled request: B
        handlerA.handleRequest("C"); // Output: No handler for request: C
    }
}

public interface Observer {
    public void update(String message);
}

public class WeixinUser implements Observer {
    // 微信用户名
    private String name;
    public WeixinUser(String name) {
        this.name = name;
    }
    @Override
    public void update(String message) {
        System.out.println(name + "-" + message);
    }
}

public interface Subject {
    /**
     * 增加订阅者
     * @param observer
     */
    public void attach(Observer observer);
    /**
     * 删除订阅者
     * @param observer
     */
    public void detach(Observer observer);
    /**
     * 通知订阅者更新消息
     */
    public void notify(String message);
}

public class SubscriptionSubject implements Subject {
    //储存订阅公众号的微信用户
    private List<Observer> weixinUserlist = new ArrayList<Observer>();

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

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

    @Override
    public void notify(String message) {
        for (Observer observer : weixinUserlist) {
            observer.update(message);
        }
    }
}

public class Client {
    public static void main(String[] args) {
        SubscriptionSubject mSubscriptionSubject=new SubscriptionSubject();
        //创建微信用户
        WeixinUser user1=new WeixinUser("杨影枫");
        WeixinUser user2=new WeixinUser("月眉儿");
        WeixinUser user3=new WeixinUser("紫轩");
        //订阅公众号
        mSubscriptionSubject.attach(user1);
        mSubscriptionSubject.attach(user2);
        mSubscriptionSubject.attach(user3);
        //公众号更新发出消息给订阅的微信用户
        mSubscriptionSubject.notify("刘望舒的专栏更新了");
    }
}

public abstract class BaseAdapter implements ListAdapter, SpinnerAdapter {

    //数据集观察者
    private final DataSetObservable mDataSetObservable = new DataSetObservable();

    public boolean hasStableIds() {
        return false;
    }

    public void registerDataSetObserver(DataSetObserver observer) {
        mDataSetObservable.registerObserver(observer);
    }

    public void unregisterDataSetObserver(DataSetObserver observer) {
        mDataSetObservable.unregisterObserver(observer);
    }

    /**
     * 当数据集变化时，通知所有观察者
     */
    public void notifyDataSetChanged() {
        mDataSetObservable.notifyChanged();
    }

public class DataSetObservable extends Observable<DataSetObserver> {
    public void notifyChanged() {
        synchronized(mObservers) {
            for (int i = mObservers.size() - 1; i >= 0; i--) {
                mObservers.get(i).onChanged();
            }
        }
    }

@Override
    public void setAdapter(ListAdapter adapter) {
        if (mAdapter != null && mDataSetObserver != null) {
            mAdapter.unregisterDataSetObserver(mDataSetObserver);
        }
        ...
        super.setAdapter(adapter);

        if (mAdapter != null) {
            mAreAllItemsSelectable = mAdapter.areAllItemsEnabled();
            mOldItemCount = mItemCount;
            mItemCount = mAdapter.getCount();
            checkFocus();
            //创建数据观察者
            mDataSetObserver = new AdapterDataSetObserver();
            //注册观察者
            mAdapter.registerDataSetObserver(mDataSetObserver);

            ...
        }

class AdapterDataSetObserver extends AdapterView<ListAdapter>.AdapterDataSetObserver {
        @Override
        public void onChanged() {
            super.onChanged();
            if (mFastScroller != null) {
                mFastScroller.onSectionsChanged();
            }
        }

        @Override
        public void onInvalidated() {
            super.onInvalidated();
            if (mFastScroller != null) {
                mFastScroller.onSectionsChanged();
            }
        }
    }

class AdapterDataSetObserver extends DataSetObserver {
        private Parcelable mInstanceState = null;
        @Override
        public void onChanged() {
            mDataChanged = true;
            mOldItemCount = mItemCount;
            mItemCount = getAdapter().getCount();
            if (AdapterView.this.getAdapter().hasStableIds() && mInstanceState != null
                    && mOldItemCount == 0 && mItemCount > 0) {
                AdapterView.this.onRestoreInstanceState(mInstanceState);
                mInstanceState = null;
            } else {
                rememberSyncState();
            }
            checkFocus();
            //重新布局
            requestLayout();
        }

        ...

        public void clearSavedState() {
            mInstanceState = null;
        }
    }

public interface Aggregate {

	//添加元素
    public void add(String str);
    //删除元素
    public void remove(String str);
    //获取迭代器
    public Iterator getIterator();


}

public interface Iterator {
    //获取第一个元素
    String first();
    //获取下一个元素
    String next();
    //判定集合是否为空
    boolean hasNext();
}

public class ConcreteAggregate implements  Aggregate{

    private List<String> list = new ArrayList<String>();
	
    @Override
    public void add(String str) {
        list.add(str);
    }

    @Override
    public void remove(String str) {
        list.remove(str);
    }
//获取迭代器（核心部分）
    @Override
    public Iterator getIterator() {

        return (new ConcreteIterator(list));
    }
}

public class ConcreteIterator implements Iterator {

    private List<String> list;
    private int index;

    public ConcreteIterator(List<String> list) {
        this.list = list;
    }
    
    @Override
    public String first() {
        index =0;
        String str = list.get(index);
        return str;
    }

    @Override
    public String next() {
        String str = null;
        if (this.hasNext()){
            str = list.get(index++);
        }
        return str;
    }
    //判空
    @Override
    public boolean hasNext() {
        if (index<list.size()) {
            return true;
        }
        return false;
    }
    
}

public static void main(String[] args) {
        Aggregate aggregate = new ConcreteAggregate();
        aggregate.add("user1");
        aggregate.add("user2");
        aggregate.add("user3");
        aggregate.add("user4");


        Iterator iterator = aggregate.getIterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        System.out.println("get first element");
        System.out.println("iterator.first() = " + iterator.first());
    }

@Data
@AllArgsConstructor
public class ArticleText {

    private String title;

    private String content;
    private Date createTime;

    //保存历史信息，将ArticleText的信息传入的副本中
    public ArticleMemento saveText(){
        ArticleMemento articleMemento = new ArticleMemento(this.title,this.title,this.createTime);
        return articleMemento;
    }
    //获取历史信息
    public void getArticleMemento(ArticleMemento articleMemento){
        this.title = articleMemento.getTitle();
        this.content = articleMemento.getContent();
        this.createTime = articleMemento.getCreateTime();

    }
}

@Data
@AllArgsConstructor
public class ArticleMemento {
    private String title;

    private String content;
    private Date createTime;
}

public class ArticleCaretaker {
    //保存历史版本列表
    private final List<ArticleMemento> mementos = new ArrayList<>();


    //获取指定版本
    public ArticleMemento  getArticle(int index) {
       return mementos.get(index);
    }

    //添加历史版本
    public String setMementos(ArticleMemento memento){
        mementos.add(memento);
        return memento.toString();//返回添加的版本

    }
}

  @Test
    public void Demo_1(){
        //创建管理版本工具类
        ArticleCaretaker articleCaretaker = new ArticleCaretaker();

        //创建原本
        ArticleText text1 = new ArticleText("01", "我是小北", new Date());
        System.out.println(String.format("原来的标题为【%s】，内容为【%s】",text1.getTitle(),text1.getContent()));

        /*
        1.先保存到副本中
        2.再存入管理器的list集合中
         */
        ArticleMemento articleMemento = text1.saveText();
        articleCaretaker.setMementos(articleMemento);
        //修改原本
        text1  = new ArticleText("02", "我是小新", new Date());
        System.out.println(String.format("修改后的标题为【%s】，内容为【%s】",text1.getTitle(),text1.getContent()));

        //原本回滚
        text1.getArticleMemento(articleCaretaker.getArticle(0));
        System.out.println(String.format("回滚的标题为【%s】，内容为【%s】",text1.getTitle(),text1.getContent()));

    }
/*
结果：
原来的标题为【01】，内容为【我是小北】
修改后的标题为【02】，内容为【我是小新】
回滚的标题为【01】，内容为【01】
*/

public interface LogisticsState {
    void doAction(JdLogistics context);
}

@Data

public class JdLogistics  {
    private LogisticsState logisticsState;//将接口方法作为变量，达到聚合的目的，同时可以进行切换

    public void doAction(){
        //考虑到订单转态的行为有null行为，所以使用until工具包下的objects类中的requireNoNUll来返回NPE
        /*源码
        *   public static <T> T requireNonNull(T obj) {
             if (obj == null)
                throw new NullPointerException();
             return obj;
            }
        * */
        Objects.requireNonNull(logisticsState);
        logisticsState.doAction(this);

    }
}

public class OrderState implements LogisticsState {
    @Override
    public void doAction(JdLogistics context) {
        System.out.println("商家已经接单，正在处理中...");
    }
}

public class ProductOutState implements LogisticsState {
    @Override
    public void doAction(JdLogistics context) {
        System.out.println("商品已经出库...");
    }
}

 @Test
    public void test() {
        //模拟用户下单的过程
        //1、后端先启动：创建订单管理类JdLogistics
        //2、前端发送请求查看订单状态:创建各种订单类。达到if else的目的

        /* 状态1*/
        //1.
        JdLogistics jdLogistics = new JdLogistics();

        //2.
        OrderState orderState = new OrderState();
        //传入到管理器。切换状态
        jdLogistics.setLogisticsState(orderState);
        //管理器统一调动状态
        jdLogistics.doAction();

        /* 状态2*/
        ProductOutState productOutState = new ProductOutState();

        jdLogistics.setLogisticsState(productOutState);

        jdLogistics.doAction();

    }

public interface CorporateSlave {
    void accept(CorporateSlaveVisitor visitor);
}

public class Programmer implements CorporateSlave {
    private String name;

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

    public String getName() {
        return name;
    }

    @Override
    public void accept(CorporateSlaveVisitor visitor) {
        visitor.visit(this);
    }
}

public class Tester implements CorporateSlave {

    private String name;

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

    public String getName() {
        return name;
    }

    @Override
    public void accept(CorporateSlaveVisitor visitor) {
        visitor.visit(this);
    }
}

同上，省略
...

@Override
  public void accept(CorporateSlaveVisitor visitor) {
      visitor.visit(this);
  }

/**
 * Copyright (C) 2021 ShuSheng007
 * 完全享有此软件的著作权
 *
 * @author ShuSheng007
 * @time 2021/6/7 23:01
 * @description
 */
public class BigHuYouCompany {
    private List<CorporateSlave> employee= new ArrayList<>();

    public BigHuYouCompany() {
        employee.add(new Programmer("王二狗"));
        employee.add(new HumanSource("上官无需"));
        employee.add(new Tester("牛翠花"));
    }

    public void startProject(CorporateSlaveVisitor visitor){
        for (CorporateSlave slave : employee) {
            slave.accept(visitor);
        }
    }
}

/**
 * Copyright (C) 2021 ShuSheng007
 * 完全享有此软件的著作权
 *
 * @author ShuSheng007
 * @time 2021/6/7 21:54
 * @description
 */
public interface CorporateSlaveVisitor {
    void visit(Programmer programmer);

    void visit(HumanSource humanSource);

    void visit(Tester tester);
}

public class SocialApp implements CorporateSlaveVisitor {
    @Override
    public void visit(Programmer programmer) {
        System.out.println(String.format("%s: 给你一个月，先仿照微信搞个类似的APP出来,要能语音能发红包,将来公司上市了少不了你的，好好干...",programmer.getName()));
    }

    @Override
    public void visit(HumanSource humanSource) {
        System.out.println(String.format("%s: 咱现在缺人，你暂时就充当了陪聊吧，在程序员开发APP期间，你去发发软文，积攒点粉丝...",humanSource.getName()));
    }

    @Override
    public void visit(Tester tester) {
        System.out.println(String.format("%s: 这是咱创业的第一炮，一定要打响，测试不能掉链子啊，不能让APP带伤上战场，以后给你多招点人，你就是领导了...",tester.getName()));
    }
}

public class LiveApp implements CorporateSlaveVisitor {
    @Override
    public void visit(Programmer programmer) {
        System.out.println(String.format("%s: 最近小视频很火啊，咱能不能抄袭下抖音，搞他一炮,将来公司上市了，你的身价至少也是几千万，甚至上亿...",programmer.getName()));
    }

    @Override
    public void visit(HumanSource humanSource) {
        System.out.println(String.format("%s: 咱公司就数你长得靓，哪天化化妆，把你的事业线适当露一露，要是火了你在北京买房都不是梦...",humanSource.getName()));
    }

    @Override
    public void visit(Tester tester) {
        System.out.println(String.format("%s: 你也开个账户，边测试边直播，两不耽误...",tester.getName()));
    }
}

public class VisitorClient {

    public void startProject(){
        BigHuYouCompany bigHuYou= new BigHuYouCompany();
        //可以很轻松的更换Visitor，但是要求BigHuYouCompany的结构稳定
        System.out.println("-----------------启动社交APP项目--------------------");
        bigHuYou.startProject(new SocialApp());
        System.out.println("-----------------启动短视频APP项目--------------------");
        bigHuYou.startProject(new LiveApp());
    }
}

-----------------启动社交APP项目--------------------
王二狗: 给你一个月，先仿照微信搞个类似的APP出来,要能语音能发红包,将来公司上市了少不了你的，好好干...
上官无需: 咱现在缺人，你暂时就充当了陪聊吧，在程序员开发APP期间，你去发发软文，积攒点粉丝...
牛翠花: 这是咱创业的第一炮，一定要打响，测试不能掉链子啊，不能让APP带伤上战场，以后给你多招点人，你就是领导了...
-----------------启动短视频APP项目--------------------
王二狗: 最近小视频很火啊，咱能不能抄袭下抖音，搞他一炮,将来公司上市了，你的身价至少也是几千万，甚至上亿...
上官无需: 咱公司就数你长得靓，哪天化化妆，把你的事业线适当露一露，要是火了你在北京买房都不是梦...
牛翠花: 你也开个账户，边测试边直播，两不耽误...

public void startProject(CorporateSlaveVisitor visitor){
     for (CorporateSlave slave : employee) {
         slave.accept(visitor);
     }
 }

@Override
  public void accept(CorporateSlaveVisitor visitor) {
      visitor.visit(this);
  }

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

// 聊天室服务器，作为中介者
class ChatRoom {
    private List<User> users = new ArrayList<>();

    // 用户加入聊天室
    public void registerUser(User user) {
        users.add(user);
        user.setChatRoom(this);
        System.out.println(user.getName() + " has joined the chat room.");
    }

    // 用户离开聊天室
    public void unregisterUser(User user) {
        users.remove(user);
        System.out.println(user.getName() + " has left the chat room.");
    }

    // 发送消息给所有用户
    public void broadcast(User sender, String message) {
        for (User user : users) {
            if (!user.equals(sender)) {
                user.receive(sender.getName() + ": " + message);
            }
        }
    }
}

// 用户（同事类）
class User {
    private String name;
    private ChatRoom chatRoom;

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

    public String getName() {
        return name;
    }

    public void setChatRoom(ChatRoom chatRoom) {
        this.chatRoom = chatRoom;
    }

    // 用户发送消息
    public void send(String message) {
        chatRoom.broadcast(this, message);
    }

    // 用户接收消息
    public void receive(String message) {
        System.out.println(this.name + " received: " + message);
    }
}

// 聊天室客户端模拟
public class ChatRoomDemo {
    public static void main(String[] args) {
        ChatRoom chatRoom = new ChatRoom();

        User user1 = new User("Alice");
        User user2 = new User("Bob");
        User user3 = new User("Charlie");

        chatRoom.registerUser(user1);
        chatRoom.registerUser(user2);
        chatRoom.registerUser(user3);

        // Alice 发送消息
        user1.send("Hello everyone!");

        // Bob 发送消息
        user2.send("Hi Alice, how are you?");

        // Charlie 离开聊天室
        chatRoom.unregisterUser(user3);

        // Alice 再次发送消息，Charlie 不再接收
        user1.send("Charlie, are you there?");
    }
}

// 抽象表达式角色
interface Expression {
    int interpret(Context context);
}
 
// 终结符表达式角色
class TerminalExpression implements Expression {
    private int value;
 
    public TerminalExpression(int value) {
        this.value = value;
    }
 
    @Override
    public int interpret(Context context) {
        return value;
    }
}
 
// 非终结符表达式角色
class NonterminalExpression implements Expression {
    private Expression left;
    private Expression right;
 
    public NonterminalExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }
 
    @Override
    public int interpret(Context context) {
        // 实现相应的逻辑，例如加法
        return left.interpret(context) + right.interpret(context);
    }
}
 
// 环境角色
class Context {
    // 可能包含解释器运行需要的全局信息
}
 
// 客户端代码
public class InterpreterPatternExample {
    public static void main(String[] args) {
        // 创建表达式对象
        Expression expr = new NonterminalExpression(
            new TerminalExpression(10), 
            new TerminalExpression(20)
        );
 
        // 执行解释操作
        Context context = new Context();
        int result = expr.interpret(context);
 
        System.out.println("解释器计算结果: " + result);  // 输出 30
    }
}