public class AnimalFactory {

	private AnimalFactory() {
	}

	// public static Dog createDog() {
	// return new Dog();
	// }
	//
	// public static Cat createCat() {
	// return new Cat();
	// }

	public static Animal createAnimal(String type) {
		if ("dog".equals(type)) {
			return new Dog();
		} else if ("cat".equals(type)) {
			return new Cat();
		} else {
			return null;
		}
	}
}

public abstract class AbstractFactory {
    public abstract <T extends Product> T createProduct(Class<T> clazz);
}

public class ConcreteFactory extends AbstractFactory {
    @Override
    public <T extends Product> T createProduct(Class<T> clazz) {
        try {
            return (T) Class.forName(clazz.getName()).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }
}

public abstract class Product {
    public void method1() {
        System.out.println("method1");
    }
    public abstract void method2();
}

public class ConcreteProduct1 extends Product {
    @Override
    public void method2() {
        System.out.println("method2");
    }
}

AbstractFactory abstractFactory = new ConcreteFactory();
ConcreteProduct1 product = abstractFactory.createProduct(ConcreteProduct1.class);
product.method1();
product.method2();

/**
 * Weapon interface.
 */
public interface Weapon {
    WeaponType getWeaponType();
}
/**
 * WeaponType enumeration.
 */
public enum WeaponType {

    SHORT_SWORD("short sword"), SPEAR("spear"), AXE("axe"), UNDEFINED("");

    private String title;

    WeaponType(String title) {
        this.title = title;
    }

    @Override
    public String toString() {
        return title;
    }
}
/**
 * ElfWeapon.
 */
public class ElfWeapon implements Weapon {

    private WeaponType weaponType;

    public ElfWeapon(WeaponType weaponType) {
        this.weaponType = weaponType;
    }

    @Override
    public String toString() {
        return "Elven " + weaponType;
    }

    @Override
    public WeaponType getWeaponType() {
        return weaponType;
    }
}
/**
 * OrcWeapon.
 */
public class OrcWeapon implements Weapon {

    private WeaponType weaponType;

    public OrcWeapon(WeaponType weaponType) {
        this.weaponType = weaponType;
    }

    @Override
    public String toString() {
        return "Orcish " + weaponType;
    }

    @Override
    public WeaponType getWeaponType() {
        return weaponType;
    }
}

/**
 * The interface containing method for producing objects.
 */
public interface Blacksmith {
    Weapon manufactureWeapon(WeaponType weaponType);
}
/**
 * Concrete subclass for creating new objects.
 */
public class ElfBlacksmith implements Blacksmith {

    private static Map<WeaponType, ElfWeapon> ELFARSENAL;

    static {
        ELFARSENAL = new HashMap<>(WeaponType.values().length);
        for (WeaponType type : WeaponType.values()) {
            ELFARSENAL.put(type, new ElfWeapon(type));
        }
    }

    @Override
    public Weapon manufactureWeapon(WeaponType weaponType) {
        return ELFARSENAL.get(weaponType);
    }
}
/**
 * Concrete subclass for creating new objects.
 */
public class OrcBlacksmith implements Blacksmith {

    private static Map<WeaponType, OrcWeapon> ORCARSENAL;

    static {
        ORCARSENAL = new HashMap<>(WeaponType.values().length);
        for (WeaponType type : WeaponType.values()) {
            ORCARSENAL.put(type, new OrcWeapon(type));
        }
    }

    @Override
    public Weapon manufactureWeapon(WeaponType weaponType) {
        return ORCARSENAL.get(weaponType);
    }
}

public class App {

    private static final Logger LOGGER = LoggerFactory.getLogger(App.class);

    private final Blacksmith blacksmith;

    /**
     * Creates an instance of <code>App</code> which will use <code>blacksmith</code> to manufacture
     * the weapons for war.
     * <code>App</code> is unaware which concrete implementation of {@link Blacksmith} it is using.
     * The decision of which blacksmith implementation to use may depend on configuration, or
     * the type of rival in war.
     *
     * @param blacksmith a non-null implementation of blacksmith
     */
    public App(Blacksmith blacksmith) {
        this.blacksmith = blacksmith;
    }

    /**
     * Program entry point.
     *
     * @param args command line args
     */
    public static void main(String[] args) {
        // Lets go to war with Orc weapons
        App app = new App(new OrcBlacksmith());
        app.manufactureWeapons();

        // Lets go to war with Elf weapons
        app = new App(new ElfBlacksmith());
        app.manufactureWeapons();
    }

    private void manufactureWeapons() {
        Weapon weapon;
        weapon = blacksmith.manufactureWeapon(WeaponType.SPEAR);
        LOGGER.info(weapon.toString());
        weapon = blacksmith.manufactureWeapon(WeaponType.AXE);
        LOGGER.info(weapon.toString());
    }
}

public interface AbstractFactory {
    public abstract Product createProductA();
    public abstract Product createProductB();
}

public interface Product {
    public abstract void method();
}

public class Product1Factory implements AbstractFactory {
    @Override
    public Product createProductA() {
        return new ConcreteProduct1();
    }
    @Override
    public Product createProductB() {
        return new ConcreteProduct2();
    }
}

public class Product2Factory implements AbstractFactory {
    @Override
    public Product createProductA() {
        return new ConcreteProduct3();
    }
    @Override
    public Product createProductB() {
        return new ConcreteProduct4();
    }
}

AbstractFactory f = new ConcreteProduct1Factory();
Product a = f.createProductA();
a.method();

f = new ConcreteProduct2Factory();
a = f.createProductB();
a.method();

public interface CarBuilder {
    CarBuilder buildWheel();
    CarBuilder buildEngine();
    CarBuilder buildSeats(int number);
    CarBuilder buildContainer();
    Car getCar();
}

public class Car {
    List<String> config = new ArrayList<>();
    public void addConfig(String config) {
        this.config.add(config);
    }
    @Override
    public String toString() {
        return config.stream().reduce("", (x, y) -> x.concat(y).concat("\r\n"));
    }
}

public class TrunkBuilder implements CarBuilder {
    private Car car = new Car();
    @Override
    public CarBuilder buildWheel() {
        car.addConfig("car has a big wheel");
        return this;
    }
    @Override
    public CarBuilder buildEngine() {
        car.addConfig("car has a little engine");
        return this;
    }
    @Override
    public CarBuilder buildSeats(int number) {
        car.addConfig(MessageFormat.format("car has a {0} seats", number));
        return this;
    }
    @Override
    public CarBuilder buildContainer() {
        car.addConfig("car has a big containers");
        return this;
    }
    @Override
    public Car getCar() {
        return car;
    }
}

Car car = new TrunkBuilder().buildContainer()
        .buildEngine()
        .buildSeats(3)
        .buildWheel()
        .getCar();
System.out.println(car);
car = new TrunkBuilder()
        .buildEngine()
        .buildWheel()
        .getCar();
System.out.println(car);

public interface Prototype {
    Object clone();
}

public class ConcretePrototype implements Prototype, Cloneable, Serializable {
    private static final long serialVersionUID = 7231405363797237036L;
    @Override
    public Object clone() {
            // 使用json序列化
            // Gson gson = new Gson();
            // return gson.fromJson(gson.toJson(this), this.getClass());

            // 使用流
        try (
                //将对象写到流里
                ByteArrayOutputStream bos = new ByteArrayOutputStream();
                ObjectOutputStream oos = new ObjectOutputStream(bos);
        ) {
            oos.writeObject(this);
            try (//从流里读回来
                 ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
                 ObjectInputStream ois = new ObjectInputStream(bis);
             ) {
                return ois.readObject();
            }
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }
}

public class PrototypeManager {
    // Singleton implements
    private Map<String, Prototype> prototypeMap = new HashMap<>();
    public void addPrototype(String name, Prototype prototype) {
        prototypeMap.put(name, prototype);
    }
    public void removePrototype(String name) {
        prototypeMap.remove(name);
    }
    public Prototype getPrototype(String name) {
        return (Prototype) prototypeMap.get(name).clone();
    }
}

public class Client {
    public static void main(String[] args) {
        PrototypeManager prototypeManager = new PrototypeManager();
        prototypeManager.addPrototype("first",new ConcretePrototype());
        Prototype first = prototypeManager.getPrototype("first");
    }
}

public class Singleton {
	// 构造私有
	private Singleton() {
	}

	// 自己造一个
	// 静态方法只能访问静态成员变量，加静态
	// 为了不让外界直接访问修改这个值，加private
	private static Singleton s = new Singleton();

	// 提供公共的访问方式
	// 为了保证外界能够直接使用该方法，加静态
	public static Singleton getSingleton() {
		return s;
	}
}

public class Singleton {
	private Singleton() {
	}
	// 使用volatile禁止指令重排
	private volatile static Singleton t = null;
	// 锁范围较大，如果可以接受重复初始化，可以不加锁，如基本类型的延迟加载
	public synchronized static Singleton getSingleton() {
		Singleton result = t;// 局部变量保证在t被初始化的情况下读取一次，可以提高性能
		if (result == null) {// 这里有线程安全问题 所以要加锁
			t = result = new Singleton();
		}
		return result;
	}
	// 缩小锁范围，但是要做双重检查 jdk 1.5以后有效
	public static Singleton getSingleton() {
		Singleton result = t;// 局部变量保证在t被初始化的情况下读取一次，可以提高性能
		if (result == null) {
			synchronized(Singleton.class){
				result = t;
				if (result == null) {// 双重检查
					t = result = new Singleton();
				}
			}
		}
		return result;
	}
}

public class Singleton {
    private static class StaticHolder {
        private static Singleton instance;
        static {
            instance = new Singleton();
        }
    }
    private Singleton(){
    }
    public static Singleton getInstance() {
        return StaticHolder.instance;
    }
}

// 普通单例需要使用transient和readResolve方法保证反序列化后使用一个实例
private static final transient Singleton INSTANCE = new Singleton();
private Object readResolve() throws ObjectStreamException {
   // instead of the object we're on,
   // return the class variable INSTANCE
  return INSTANCE;
}

// 枚举实现
public enum Singleton {
    INSTANCE;
    Singleton() {
    }
    public void operate() {
    }
}

public abstract class DwarvenMineWorker {
  private static final Logger LOGGER = LoggerFactory.getLogger(DwarvenMineWorker.class);
  public void goToSleep() {
    LOGGER.info("{} goes to sleep.", name());
  }
  public void wakeUp() {
    LOGGER.info("{} wakes up.", name());
  }
  public void goHome() {
    LOGGER.info("{} goes home.", name());
  }
  public void goToMine() {
    LOGGER.info("{} goes to the mine.", name());
  }
  private void action(Action action) {
    switch (action) {
      case GO_TO_SLEEP:
        goToSleep();
        break;
      case WAKE_UP:
        wakeUp();
        break;
      case GO_HOME:
        goHome();
        break;
      case GO_TO_MINE:
        goToMine();
        break;
      case WORK:
        work();
        break;
      default:
        LOGGER.info("Undefined action");
        break;
    }
  }
  public void action(Action... actions) {
    for (Action action : actions) {
      action(action);
    }
  }
  public abstract void work();
  public abstract String name();
  static enum Action {
    GO_TO_SLEEP, WAKE_UP, GO_HOME, GO_TO_MINE, WORK
  }
}

public class DwarvenTunnelDigger extends DwarvenMineWorker {
  private static final Logger LOGGER = LoggerFactory.getLogger(DwarvenTunnelDigger.class);
  @Override
  public void work() {
    LOGGER.info("{} creates another promising tunnel.", name());
  }
  @Override
  public String name() {
    return "Dwarven tunnel digger";
  }
}

public class DwarvenGoldDigger extends DwarvenMineWorker {
  private static final Logger LOGGER = LoggerFactory.getLogger(DwarvenGoldDigger.class);
  @Override
  public void work() {
    LOGGER.info("{} digs for gold.", name());
  }
  @Override
  public String name() {
    return "Dwarf gold digger";
  }
}

public class DwarvenCartOperator extends DwarvenMineWorker {
  private static final Logger LOGGER = LoggerFactory.getLogger(DwarvenCartOperator.class);
  @Override
  public void work() {
    LOGGER.info("{} moves gold chunks out of the mine.", name());
  }
  @Override
  public String name() {
    return "Dwarf cart operator";
  }
}

public class DwarvenGoldmineFacade {
  private final List<DwarvenMineWorker> workers;
  public DwarvenGoldmineFacade() {
    workers = new ArrayList<>();
    workers.add(new DwarvenGoldDigger());
    workers.add(new DwarvenCartOperator());
    workers.add(new DwarvenTunnelDigger());
  }
  public void startNewDay() {
    makeActions(workers, DwarvenMineWorker.Action.WAKE_UP, DwarvenMineWorker.Action.GO_TO_MINE);
  }
  public void digOutGold() {
    makeActions(workers, DwarvenMineWorker.Action.WORK);
  }
  public void endDay() {
    makeActions(workers, DwarvenMineWorker.Action.GO_HOME, DwarvenMineWorker.Action.GO_TO_SLEEP);
  }
  private static void makeActions(Collection<DwarvenMineWorker> workers,
      DwarvenMineWorker.Action... actions) {
    for (DwarvenMineWorker worker : workers) {
      worker.action(actions);
    }
  }
}

DwarvenGoldmineFacade facade = new DwarvenGoldmineFacade();
facade.startNewDay();
// Dwarf gold digger wakes up.
// Dwarf gold digger goes to the mine.
// Dwarf cart operator wakes up.
// Dwarf cart operator goes to the mine.
// Dwarven tunnel digger wakes up.
// Dwarven tunnel digger goes to the mine.
facade.digOutGold();
// Dwarf gold digger digs for gold.
// Dwarf cart operator moves gold chunks out of the mine.
// Dwarven tunnel digger creates another promising tunnel.
facade.endDay();
// Dwarf gold digger goes home.
// Dwarf gold digger goes to sleep.
// Dwarf cart operator goes home.
// Dwarf cart operator goes to sleep.
// Dwarven tunnel digger goes home.
// Dwarven tunnel digger goes to sleep.

public interface RowingBoat {
  void row();
}

public class FishingBoat {
  private static final Logger LOGGER = LoggerFactory.getLogger(FishingBoat.class);
  public void sail() {
    LOGGER.info("The fishing boat is sailing");
  }
}
public class Captain {

  private RowingBoat rowingBoat;
  // default constructor and setter for rowingBoat
  public Captain(RowingBoat rowingBoat) {
    this.rowingBoat = rowingBoat;
  }

  public void row() {
    rowingBoat.row();
  }
}
public class FishingBoatAdapter implements RowingBoat {

  private static final Logger LOGGER = LoggerFactory.getLogger(FishingBoatAdapter.class);

  private FishingBoat boat;

  public FishingBoatAdapter() {
    boat = new FishingBoat();
  }

  @Override
  public void row() {
    boat.sail();
  }
}

var captain = new Captain(new FishingBoatAdapter());
captain.row();

/*
 * 针对用户操作的四种功能接口
 */
public interface UserDao {
	public abstract void add();
	public abstract void delete();
	public abstract void update();
	public abstract void find();
}

//适配器类
public abstract class UserAdapter implements UserDao {
	@Override
	public void add() {
	}
	@Override
	public void delete() {
	}
	@Override
	public void update() {
	}
	@Override
	public void find() {
	}
}

// 适配器模式实现类
public class UserDaoImpl2 extends UserAdapter {
	@Override
	public void add() {
		System.out.println("添加功能");
	}
}

public class EnumerationIteratorAdaptor implements Iterator {
    private Enumeration enumeration;
    public EnumerationIteratorAdaptor(Enumeration enumeration) {
        this.enumeration = enumeration;
    }
    public boolean hasNext() {
        return enumeration.hasMoreElements();
    }
    public Object next() {
        return enumeration.nextElement();
    }
    public void remove() {
        throw new UnsupportedOperationException("adapter not implement method");
    }
}

interface RemoteServiceInterface {
    long doRemoteFunction(int value) throws Exception;
}

public class RemoteService implements RemoteServiceInterface {
    private static final Logger LOGGER = LoggerFactory.getLogger(RemoteService.class);
    private static RemoteService service = null;
    static synchronized RemoteService getRemoteService() {
        if (service == null) {
            service = new RemoteService();
        }
        return service;
    }
    private RemoteService() {}
    @Override
    public long doRemoteFunction(int value) {
        long waitTime = (long) Math.floor(Math.random() * 1000);
        try {
            sleep(waitTime);
        } catch (InterruptedException e) {
            LOGGER.error("Thread sleep interrupted", e)
        }
        return waitTime >= 200 ? value * 10 : -1;
    }
}

public class ServiceAmbassador implements RemoteServiceInterface {
    private static final Logger LOGGER = LoggerFactory.getLogger(ServiceAmbassador.class);
    private static final int RETRIES = 3;
    private static final int DELAY_MS = 3000;
    ServiceAmbassador() {}
    @Override
    public long doRemoteFunction(int value) {
        return safeCall(value);
    }

    private long checkLatency(int value) {
        RemoteService service = RemoteService.getRemoteService();
        long startTime = System.currentTimeMillis();
        long result = service.doRemoteFunction(value);
        long timeTaken = System.currentTimeMillis() - startTime;
        LOGGER.info("Time taken (ms): " + timeTaken);
        return result;
    }

    private long safeCall(int value) {
        int retries = 0;
        long result = -1;
        for (int i = 0; i < RETRIES; i++) {
            if (retries >= RETRIES) {
                return -1;
            }
            if ((result = checkLatency(value)) == -1) {
                LOGGER.info("Failed to reach remote: (" + (i + 1) + ")");
                retries++;
                try {
                    sleep(DELAY_MS);
                } catch (InterruptedException e) {
                    LOGGER.error("Thread sleep state interrupted", e);
                }
            } else {
                break;
            }
        }
        return result;
    }
}

public class Client {
    private ServiceAmbassador serviceAmbassador;
    Client() {
        serviceAmbassador = new ServiceAmbassador();
    }
    long useService(int value) {
        long result = serviceAmbassador.doRemoteFunction(value);
        LOGGER.info("Service result: " + result)
        return result;
    }
}

/**
 * Interface that both the Controller and the Delegate will implement.
 */
public interface Printer {
    /**
     * Method that takes a String to print to the screen. This will be implemented on both the
     * controller and the delegate allowing the controller to call the same method on the delegate
     * class.
     *
     * @param message to be printed to the screen
     */
    void print(final String message);
}
/**
 * Specialised Implementation of {@link Printer} for a Canon Printer, in this case the message to be
 * printed is appended to "Canon Printer : ".
 */
public class CanonPrinter implements Printer {
    private static final Logger LOGGER = LoggerFactory.getLogger(CanonPrinter.class);
    /**
     * {@inheritDoc}
     */
    @Override
    public void print(String message) {
        LOGGER.info("Canon Printer : {}", message);
    }
}
/**
 * Specialised Implementation of {@link Printer} for a HP Printer, in this case the message to be
 * printed is appended to "HP Printer : ".
 */
public class HpPrinter implements Printer {
    private static final Logger LOGGER = LoggerFactory.getLogger(HpPrinter.class);
    /**
     * {@inheritDoc}
     */
    @Override
    public void print(String message) {
        LOGGER.info("HP Printer : {}", message);
    }
}
/**
 * Delegator Class to delegate the implementation of the Printer. This ensures two things: - when
 * the actual implementation of the Printer class changes the delegation will still be operational -
 * the actual benefit is observed when there are more than one implementors and they share a
 * delegation control
 */
public class PrinterController implements Printer {
    private final Printer printer;
    public PrinterController(Printer printer) {
        this.printer = printer;
    }
    /**
     * This method is implemented from {@link Printer} however instead on providing an implementation,
     * it instead calls upon the class passed through the constructor. This is the delegate, hence the
     * pattern. Therefore meaning that the caller does not care of the implementing class only the
     * owning controller.
     *
     * @param message to be printed to the screen
     */
    @Override
    public void print(String message) {
        printer.print(message);
    }
}

PrinterController hpPrinterController = new PrinterController(new HpPrinter());
PrinterController canonPrinterController = new PrinterController(new CanonPrinter());
PrinterController epsonPrinterController = new PrinterController(new EpsonPrinter());

hpPrinterController.print(MESSAGE_TO_PRINT);
canonPrinterController.print(MESSAGE_TO_PRINT);
epsonPrinterController.print(MESSAGE_TO_PRINT);

public interface WizardTower {
  void enter(Wizard wizard);
}

public class IvoryTower implements WizardTower {
  private static final Logger LOGGER = LoggerFactory.getLogger(IvoryTower.class);
  public void enter(Wizard wizard) {
    LOGGER.info("{} enters the tower.", wizard);
  }
}

@ToString
@NoArgsConstructor
public class Wizard {
  private final String name;
}

public class WizardTowerProxy implements WizardTower {
  private static final Logger LOGGER = LoggerFactory.getLogger(WizardTowerProxy.class);
  private static final int NUM_WIZARDS_ALLOWED = 3;
  private int numWizards;
  private final WizardTower tower;
  public WizardTowerProxy(WizardTower tower) {
    this.tower = tower;
  }
  @Override
  public void enter(Wizard wizard) {
    if (numWizards < NUM_WIZARDS_ALLOWED) {
      tower.enter(wizard);
      numWizards++;
    } else {
      LOGGER.info("{} is not allowed to enter!", wizard);
    }
  }
}

WizardTowerProxy proxy = new WizardTowerProxy(new IvoryTower());
proxy.enter(new Wizard("Red wizard")); // Red wizard enters the tower.
proxy.enter(new Wizard("White wizard")); // White wizard enters the tower.
proxy.enter(new Wizard("Black wizard")); // Black wizard enters the tower.
proxy.enter(new Wizard("Green wizard")); // Green wizard is not allowed to enter!
proxy.enter(new Wizard("Brown wizard")); // Brown wizard is not allowed to enter!

public interface Phone {
	public abstract void call();
}

public class IPhone implements Phone {
	@Override
	public void call() {
		System.out.println("手机可以打电话了");
	}
}

// 装饰抽象类
public abstract class PhoneDecorate implements Phone {
	private Phone p;
	public PhoneDecorate(Phone p) {
		this.p = p;
	}
	@Override
	public void call() {
		this.p.call();
	}
}

public class MusicPhoneDecorate extends PhoneDecorate {
	public MusicPhoneDecorate(Phone p) {
		super(p);
	}
	@Override
	public void call() {
		super.call();
		System.out.println("手机可以听音乐");
	}
}

public class RingPhoneDecorate extends PhoneDecorate {
	public RingPhoneDecorate(Phone p) {
		super(p);
	}
	@Override
	public void call() {
		System.out.println("手机可以听彩铃");
		super.call();
	}
}

Phone p = new IPhone();
p.call();
System.out.println("------------");

// 需求：我想在接电话前，听彩铃
PhoneDecorate pd = new RingPhoneDecorate(p);
pd.call();// 听彩铃打电话

// 需求：我想在接电话后，听音乐
pd = new MusicPhoneDecorate(p);
pd.call();// 打电话听音乐

// 需求：我要想手机在接前听彩铃，接后听音乐
// 自己提供装饰类，在打电话前听彩铃，打电话后听音乐或者嵌套使用装饰类
pd = new RingPhoneDecorate(new MusicPhoneDecorate(p));
pd.call();// 同时听彩铃打电话听音乐

// Jdk中的装饰模式
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
Scanner sc = new Scanner(System.in);

/**
 * Event enumeration.
 */
@ToString
public enum Event {
    STARK_SIGHTED("Stark sighted"),
    WARSHIPS_APPROACHING("Warships approaching"),
    TRAITOR_DETECTED("Traitor detected");

    private String description;

    Event(String description) {
        this.description = description;
    }
}
/**
 *
 * EventEmitter is the base class for event producers that can be observed.
 *
 */
public abstract class EventEmitter {
    private List<EventObserver> observers;
    public EventEmitter() {
        observers = new LinkedList<>();
    }
    public EventEmitter(EventObserver obs) {
        this();
        registerObserver(obs);
    }
    public final void registerObserver(EventObserver obs) {
        observers.add(obs);
    }
    protected void notifyObservers(Event e) {
        for (EventObserver obs : observers) {
            obs.onEvent(e);
        }
    }
    public abstract void timePasses(Weekday day);
}
/**
 * Observers of events implement this interface.
 */
public interface EventObserver {
    void onEvent(Event e);
}

/**
 * KingJoffrey observes events from {@link KingsHand}.
 */
public class KingJoffrey implements EventObserver {
    private static final Logger LOGGER = LoggerFactory.getLogger(KingJoffrey.class);
    @Override
    public void onEvent(Event e) {
        LOGGER.info("Received event from the King's Hand: {}", e.toString());
    }
}
/**
 * KingsHand observes events from multiple sources and delivers them to listeners.
 */
public class KingsHand extends EventEmitter implements EventObserver {
    public KingsHand() {
    }
    public KingsHand(EventObserver obs) {
        super(obs);
    }
    @Override
    public void onEvent(Event e) {
        notifyObservers(e);
    }
    @Override
    public void timePasses(Weekday day) {
        // NOP
    }
}
/**
 * LordBaelish produces events.
 */
public class LordBaelish extends EventEmitter {
    public LordBaelish() {
    }
    public LordBaelish(EventObserver obs) {
        super(obs);
    }
    @Override
    public void timePasses(Weekday day) {
        if (day.equals(Weekday.FRIDAY)) {
            notifyObservers(Event.STARK_SIGHTED);
        }
    }
}
/**
 * LordVarys produces events.
 */
public class LordVarys extends EventEmitter {
    public LordVarys() {
    }
    public LordVarys(EventObserver obs) {
        super(obs);
    }
    @Override
    public void timePasses(Weekday day) {
        if (day.equals(Weekday.SATURDAY)) {
            notifyObservers(Event.TRAITOR_DETECTED);
        }
    }
}
/**
 * Scout produces events.
 */
public class Scout extends EventEmitter {
    public Scout() {
    }
    public Scout(EventObserver obs) {
        super(obs);
    }
    @Override
    public void timePasses(Weekday day) {
        if (day.equals(Weekday.TUESDAY)) {
            notifyObservers(Event.WARSHIPS_APPROACHING);
        }
    }
}
/**
 * Weekday enumeration
 */
@ToString
public enum Weekday {
    MONDAY("Monday"),
    TUESDAY("Tuesday"),
    WEDNESDAY("Wednesday"),
    THURSDAY("Thursday"),
    FRIDAY("Friday"),
    SATURDAY("Saturday"),
    SUNDAY("Sunday");
    private String description;
    Weekday(String description) {
        this.description = description;
    }
}

KingJoffrey kingJoffrey = new KingJoffrey();
KingsHand kingsHand = new KingsHand(kingJoffrey);

List<EventEmitter> emitters = new ArrayList<>();
emitters.add(kingsHand);
emitters.add(new LordBaelish(kingsHand));
emitters.add(new LordVarys(kingsHand));
emitters.add(new Scout(kingsHand));

for (Weekday day : Weekday.values()) {
    for (EventEmitter emitter : emitters) {
        emitter.timePasses(day);
    }
}

public interface Weapon {
  void wield();
  void swing();
  void unwield();
  Enchantment getEnchantment();
}
public class Sword implements Weapon {
  private final Enchantment enchantment;
  public Sword(Enchantment enchantment) {
    this.enchantment = enchantment;
  }
  @Override
  public void wield() {
    LOGGER.info("The sword is wielded.");
    enchantment.onActivate();
  }
  @Override
  public void swing() {
    LOGGER.info("The sword is swinged.");
    enchantment.apply();
  }
  @Override
  public void unwield() {
    LOGGER.info("The sword is unwielded.");
    enchantment.onDeactivate();
  }
  @Override
  public Enchantment getEnchantment() {
    return enchantment;
  }
}

public class Hammer implements Weapon {
  private final Enchantment enchantment;
  public Hammer(Enchantment enchantment) {
    this.enchantment = enchantment;
  }
  @Override
  public void wield() {
    LOGGER.info("The hammer is wielded.");
    enchantment.onActivate();
  }
  @Override
  public void swing() {
    LOGGER.info("The hammer is swinged.");
    enchantment.apply();
  }
  @Override
  public void unwield() {
    LOGGER.info("The hammer is unwielded.");
    enchantment.onDeactivate();
  }
  @Override
  public Enchantment getEnchantment() {
    return enchantment;
  }
}

public interface Enchantment {
  void onActivate();
  void apply();
  void onDeactivate();
}

public class FlyingEnchantment implements Enchantment {
  @Override
  public void onActivate() {
    LOGGER.info("The item begins to glow faintly.");
  }
  @Override
  public void apply() {
    LOGGER.info("The item flies and strikes the enemies finally returning to owner's hand.");
  }
  @Override
  public void onDeactivate() {
    LOGGER.info("The item's glow fades.");
  }
}

public class SoulEatingEnchantment implements Enchantment {
  @Override
  public void onActivate() {
    LOGGER.info("The item spreads bloodlust.");
  }
  @Override
  public void apply() {
    LOGGER.info("The item eats the soul of enemies.");
  }
  @Override
  public void onDeactivate() {
    LOGGER.info("Bloodlust slowly disappears.");
  }
}

Sword enchantedSword = new Sword(new SoulEatingEnchantment());
enchantedSword.wield();
enchantedSword.swing();
enchantedSword.unwield();
// The sword is wielded.
// The item spreads bloodlust.
// The sword is swinged.
// The item eats the soul of enemies.
// The sword is unwielded.
// Bloodlust slowly disappears.
Hammer hammer = new Hammer(new FlyingEnchantment());
hammer.wield();
hammer.swing();
hammer.unwield();
// The hammer is wielded.
// The item begins to glow faintly.
// The hammer is swinged.
// The item flies and strikes the enemies finally returning to owner's hand.
// The hammer is unwielded.
// The item's glow fades.

public abstract class LetterComposite {
    private List<LetterComposite> children = new ArrayList<>();
    public void add(LetterComposite letter) {
        children.add(letter);
    }
    public int count() {
        return children.size();
    }
    protected void printThisBefore() {
    }
    protected void printThisAfter() {
    }
    public void print() {
        printThisBefore();
        for (LetterComposite letter : children) {
            letter.print();
        }
        printThisAfter();
    }
}

public class Letter extends LetterComposite {
    private char c;
    public Letter(char c) {
        this.c = c;
    }
    @Override
    protected void printThisBefore() {
        System.out.print(c);
    }
}

public class Word extends LetterComposite {
    public Word(List<Letter> letters) {
        for (Letter l : letters) {
            this.add(l);
        }
    }
    @Override
    protected void printThisBefore() {
        System.out.print(" ");
    }
}

public class Sentence extends LetterComposite {
    public Sentence(List<Word> words) {
        for (Word w : words) {
            this.add(w);
        }
    }
    @Override
    protected void printThisAfter() {
        System.out.print(".");
    }
}

public class Messenger {
    LetterComposite messageFromOrcs() {
        List<Word> words = new ArrayList<>();
        words.add(new Word(Arrays.asList(new Letter('W'), new Letter('h'), new Letter('e'), new Letter('r'), new Letter('e'))));
        words.add(new Word(Arrays.asList(new Letter('t'), new Letter('h'), new Letter('e'), new Letter('r'), new Letter('e'))));
        words.add(new Word(Arrays.asList(new Letter('i'), new Letter('s'))));
        words.add(new Word(Arrays.asList(new Letter('a'))));
        words.add(new Word(Arrays.asList(new Letter('w'), new Letter('h'), new Letter('i'), new Letter('p'))));
        words.add(new Word(Arrays.asList(new Letter('t'), new Letter('h'), new Letter('e'), new Letter('r'), new Letter('e'))));
        words.add(new Word(Arrays.asList(new Letter('i'), new Letter('s'))));
        words.add(new Word(Arrays.asList(new Letter('a'))));
        words.add(new Word(Arrays.asList(new Letter('w'), new Letter('a'), new Letter('y'))));
        return new Sentence(words);
    }
    LetterComposite messageFromElves() {
        List<Word> words = new ArrayList<>();
        words.add(new Word(Arrays.asList(new Letter('M'), new Letter('u'), new Letter('c'), new Letter('h'))));
        words.add(new Word(Arrays.asList(new Letter('w'), new Letter('i'), new Letter('n'), new Letter('d'))));
        words.add(new Word(Arrays.asList(new Letter('p'), new Letter('o'), new Letter('u'), new Letter('r'), new Letter('s'))));
        words.add(new Word(Arrays.asList(new Letter('f'), new Letter('r'), new Letter('o'), new Letter('m'))));
        words.add(new Word(Arrays.asList(new Letter('y'), new Letter('o'), new Letter('u'), new Letter('r'))));
        words.add(new Word(Arrays.asList(new Letter('m'), new Letter('o'), new Letter('u'), new Letter('t'), new Letter('h'))));
        return new Sentence(words);
    }
}

LetterComposite orcMessage = new Messenger().messageFromOrcs();
orcMessage.print(); // Where there is a whip there is a way.
LetterComposite elfMessage = new Messenger().messageFromElves();
elfMessage.print(); // Much wind pours from your mouth.

public interface Creature {
  String getName();
  Size getSize();
  Movement getMovement();
  Color getColor();
  Mass getMass();
}
public class Dragon extends AbstractCreature {
  public Dragon() {
    super("Dragon", Size.LARGE, Movement.FLYING, Color.RED, new Mass(39300.0));
  }
}

/**
 * Base class for selectors.
 */
public abstract class AbstractSelector<T> implements Predicate<T> {
  public AbstractSelector<T> and(AbstractSelector<T> other) {
    return new ConjunctionSelector<>(this, other);
  }
  public AbstractSelector<T> or(AbstractSelector<T> other) {
    return new DisjunctionSelector<>(this, other);
  }
  public AbstractSelector<T> not() {
    return new NegationSelector<>(this);
  }
}
public class ConjunctionSelector<T> extends AbstractSelector<T> {
  private List<AbstractSelector<T>> leafComponents;
  @SafeVarargs
  ConjunctionSelector(AbstractSelector<T>... selectors) {
    this.leafComponents = List.of(selectors);
  }
  /**
   * Tests if *all* selectors pass the test.
   */
  @Override
  public boolean test(T t) {
    return leafComponents.stream().allMatch(comp -> (comp.test(t)));
  }
}

public class MovementSelector extends AbstractSelector<Creature> {
  private final Movement movement;
  public MovementSelector(Movement m) {
    this.movement = m;
  }
  @Override
  public boolean test(Creature t) {
    return t.getMovement().equals(movement);
  }
}
public class MassGreaterThanSelector extends AbstractSelector<Creature> {
  private final Mass mass;
  public MassGreaterThanSelector(double mass) {
    this.mass = new Mass(mass);
  }
  @Override
  public boolean test(Creature t) {
    return t.getMass().greaterThan(mass);
  }
}

List<Creature> redCreatures = creatures.stream().filter(new ColorSelector(Color.RED)).collect(Collectors.toList());
List<Creature> heavyCreatures = creatures.stream().filter(new MassGreaterThanSelector(500.0).collect(Collectors.toList());

AbstractSelector specialCreaturesSelector = new ColorSelector(Color.RED).and(new MovementSelector(Movement.FLYING)).and(new SizeSelector(Size.SMALL).not());
List<Creature> specialCreatures = creatures.stream().filter(specialCreaturesSelector).collect(Collectors.toList());

public interface ISpecification<T> {
    boolean isSatisfiedBy(T candidate);
    ISpecification and(ISpecification specification);
    ISpecification or(ISpecification specification);
    ISpecification not();
}
// 父类依赖子类的场景，只有再非常明确不会变化的场景中存在，它缺乏扩展性
public abstract class CompositeSpecification<T> implements ISpecification<T> {
    @Override
    public ISpecification and(ISpecification specification) {
        return new AndSpecification(this, specification);
    }
    @Override
    public ISpecification or(ISpecification specification) {
        return new OrSpecification(this, specification);
    }
    @Override
    public ISpecification not() {
        return new NotSpecification(this);
    }
}

public class AndSpecification<T> extends CompositeSpecification<T> {
    private ISpecification left;
    private ISpecification right;
    public AndSpecification(ISpecification left, ISpecification right) {
        this.left = left;
        this.right = right;
    }
    @Override
    public boolean isSatisfiedBy(T candidate) {
        return left.isSatisfiedBy(candidate) && right.isSatisfiedBy(candidate);
    }
}
public class OrSpecification extends CompositeSpecification {
    private ISpecification left;
    private ISpecification right;
    public OrSpecification(ISpecification left, ISpecification right) {
        this.left = left;
        this.right = right;
    }
    @Override
    public boolean isSatisfiedBy(Object candidate) {
        return left.isSatisfiedBy(candidate) || right.isSatisfiedBy(candidate);
    }
}
public class NotSpecification extends CompositeSpecification {
    private ISpecification specification;
    public NotSpecification(ISpecification specification) {
        this.specification = specification;
    }
    @Override
    public boolean isSatisfiedBy(Object candidate) {
        return !specification.isSatisfiedBy(candidate);
    }
}

public class CustomSpecification extends CompositeSpecification<Integer> {
    Integer object;
    public CustomSpecification(Integer object) {
        this.object = object;
    }
    @Override
    public boolean isSatisfiedBy(Integer candidate) {
        return candidate > object;
    }
}

// 大于15或者大于20
ISpecification<Integer> integerISpecification15 = new CustomSpecification(15);
ISpecification<Integer> integerISpecification20 = new CustomSpecification(20);
IntStream.range(0, 31)
        .filter(
                i -> integerISpecification15.or(integerISpecification20).isSatisfiedBy(i)
        )
        .forEach(System.out::println);

public interface Potion {
  void drink();
}

public class HealingPotion implements Potion {
  private static final Logger LOGGER = LoggerFactory.getLogger(HealingPotion.class);
  @Override
  public void drink() {
    LOGGER.info("You feel healed. (Potion={})", System.identityHashCode(this));
  }
}

public class HolyWaterPotion implements Potion {
  private static final Logger LOGGER = LoggerFactory.getLogger(HolyWaterPotion.class);
  @Override
  public void drink() {
    LOGGER.info("You feel blessed. (Potion={})", System.identityHashCode(this));
  }
}

public class InvisibilityPotion implements Potion {
  private static final Logger LOGGER = LoggerFactory.getLogger(InvisibilityPotion.class);
  @Override
  public void drink() {
    LOGGER.info("You become invisible. (Potion={})", System.identityHashCode(this));
  }
}

public class PotionFactory {
  private final Map<PotionType, Potion> potions;
  public PotionFactory() {
    potions = new EnumMap<>(PotionType.class);
  }
  Potion createPotion(PotionType type) {
    Potion potion = potions.get(type);
    if (potion == null) {
      switch (type) {
        case HEALING:
          potion = new HealingPotion();
          potions.put(type, potion);
          break;
        case HOLY_WATER:
          potion = new HolyWaterPotion();
          potions.put(type, potion);
          break;
        case INVISIBILITY:
          potion = new InvisibilityPotion();
          potions.put(type, potion);
          break;
        default:
          break;
      }
    }
    return potion;
  }
}

PotionFactory factory = new PotionFactory();
factory.createPotion(PotionType.INVISIBILITY).drink(); // You become invisible. (Potion=6566818)
factory.createPotion(PotionType.HEALING).drink(); // You feel healed. (Potion=648129364)
factory.createPotion(PotionType.INVISIBILITY).drink(); // You become invisible. (Potion=6566818)
factory.createPotion(PotionType.HOLY_WATER).drink(); // You feel blessed. (Potion=1104106489)
factory.createPotion(PotionType.HOLY_WATER).drink(); // You feel blessed. (Potion=1104106489)
factory.createPotion(PotionType.HEALING).drink(); // You feel healed. (Potion=648129364)

public abstract class GetTime {
    // 需求：请给我计算出一段代码的运行时间
    // final防止子类覆盖
    public final long getTime() {
        long start = System.currentTimeMillis();
        code();
        long end = System.currentTimeMillis();
        if (isTraceMode()) {
            System.out.println("start at:" + start);
            System.out.println("end at:" + end);
        }
        return end - start;
    }
    // 必须实现，使用abstract 模版方法使用protected降低访问权限，符合迪米特法则
    protected abstract void code();
    // 可选实现，使用钩子，提供默认实现，子类选择是否覆盖父类方法
    public boolean isTraceMode() {
        return true;
    }
}

public class ForDemo extends GetTime {
	@Override
	protected void code() {
		for (int x = 0; x < 100000; x++) {
			System.out.println(x);
		}
	}
}

// 主题
public interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

public class MySubject implements Subject {
    private String message;
    List<Observer> observers = new ArrayList<Observer>();
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(this, this);
        }
    }
    public String getMessage() {
        return message;
    }
    public void setMessage(String message) {
        this.message = message;
    }
}
// 观察者
public interface Observer {
    void update(Subject subject, Object args);
}

public class MyObserver implements Observer {
    public MyObserver(Subject subject) {
        subject.registerObserver(this);
    }
    public void update(Subject subject, Object args) {
        if (subject instanceof MySubject) {
            MySubject mySubject = (MySubject) args;
            System.out.println(mySubject.getMessage());
        }
    }
}
//测试
@Test
public void update() throws Exception {
    MySubject subject = new MySubject();
    MyObserver myObserver = new MyObserver(subject);
    MyObserver myObserver1 = new MyObserver(subject);
    MyObserver myObserver2 = new MyObserver(subject);
    MyObserver myObserver3 = new MyObserver(subject);
    MyObserver myObserver4 = new MyObserver(subject);
    subject.setMessage("hello");
    subject.notifyObservers();
}