Runnable task  = ()->System.outprintln("执行任务"); 
ExecutorService executor = Executors.new FixedThreadPool(1);
executor.execute(task);

TimerTask task = new TimerTask(){
	@Override
	public void run(){
		"定时任务执行".sout;
	}
};

new Timer().schedule(task, 1000);

public final class ApplicationFilterChain implements FilterChain{
	private final Filter[] filters; //过滤器s
	private int pos=0;
	private final Servlet servlet;
	
	
	public ApplicationFilterChain(Filter[] filters, Servlet servlet){
		this.filters = filters;
		this.servlet = servlet;
	}
	
	
	@Override
	public void doFilter(ServletRequest request, ServletResponse responses) throws IOException, ServletException{
		//filters还没执行完
		if(pos<filters.length){
			Filter current = filters[pos++];//移动到下一个
			
			//把同一个chain传给当前filter, 当前filter可以选择chain.doFilter() 继续
			current.doFilter(request, response, this);
			return;
		}
		
		//全部filter执行完, 调用目标servlet
		servlet.service(request, response);
	}
}

/*
List: 抽象聚合类
ArrayList: 具体聚合类
Iterator: 抽象迭代器
list.iterator(): 返回的是实现了`Iterator`接口的具体迭代器对象
*/

public class ArrayList<E> extends AbstactList<E> 
implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
	public Iterator<E> iterator(){
		return new Itr();
	}
	
	private class Itr implements Iterator<E>{
		int cursor;
		int lastRet = -1;
		int expectedModCount = modCount;
		
		Itr(){}
		//判断是否还有元素
		public boolean hasNext(){
		}
	}
}

//抽象中介者
abstract class Mediator{
	public abstract void send(String msg, Colleague colleague);
}

//具体中介者
class ChatRoom extends Mediator{
	@Override
	public void send(String msg, Colleague colleague){
		for(Colleague c: sender.getMediator().getColleangues()){
			if(c!=sender){
				c.notify(msg);
			}
		}
	}
	
	private List<Colleague> colleagues = new ArrayList<>();
	
	//添加中介者的客户
	public void addColleague(Colleague c){
		colleagues.add(c);
	}
	
	public List<Colleague> getColleagues(){
		return colleagues;
	}
}

//抽象同事类
abstract class Colleague{
//内置一个中介来进行操作
	protected Mediator mediator;
	public Colleague(Mediator mediator){
		this.mediator = mediator;
	}
	
	public Mediator getMediator(){
		return mediator;
	}
	
	public abstract void notify(String msg);
}

class User extends Colleague{
	private String name;
	public User(String name, Mediator mediator){
		super(mediator);
		this.name = name;
	}
	
	public void send(String msg){
		mediator.send(name+". "+msg, this);
	}
	
	@Override
	public void notify(String msg){
		(name+"收到消息"+msg) .sout;
	}
}

public class test{
	psvm(){
		ChatRoom cr= new ChatRoom();
		User u1 = new User("A", cr);
		User u2 = new User("B", cr);
		User u3 = new User("C", cr);
			
		chatRoom.addColleague(u1);
		chatRoom.addColleague(u2);
		chatRoom.addColleague(u3);
		
		u1.send("hello");
	}
}

//发起人, 要被保存状态的对象
class Originator{
	private String state;
	
	public void setState(String state){
		this.state = state;
	}
		
	public void show(){
		sout;
	}
	
	//创建
	public Memento save(){
		return new Memento(state);
	}
	
	//恢复备忘录
	public void restore(Memento memento){
		this.state = memento.getState();
	}
}

//备忘录 (存状态)
class Memento{
	private final String state;
	
	public Memento(String state){
		this.state = state;
	}
	
	public String getState(){
		return state;
	}
}

//管理者
class Caretaker{
	private List<Memento> history = new ArrayList<>();
	
	public void add(Memento m){
		history.add(m);
	}

	public Memento get(int index){
		return history.get(index);
	}
}

public class test{
	psvm{
		Originator o = new Originator();
		Caretaker c = new Caretaker();
		
		o.setState("1");
		c.add(o.save());
		
		o.setState("2");
		c.add(o.save());
		
		o.setState("3");
		o.show();
		
		o.restore(c.get(0));
		o.show();
	}
}

public abstract class AbstractList<E> implements List<E> {

    public boolean add(E e) {
        add(size(), e);  // 模板方法的一部分
        return true;
    }

    public abstract void add(int index, E element); // 留给子类实现

    public abstract E get(int index);

    public abstract int size();
}

protected void service(HttpServletRequest req, HttpServletResponse resp) {
    if (req.getMethod().equals("GET")) {
        doGet(req, resp);
    } else if (...) {
        doPost(req, resp);
    }
}

//模板方法
public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

//钩子方法 ---> 判断的逻辑方法 & 子类重写的空方法
protected boolean tryAcquire(int arg) {
    throw new UnsupportedOperationException();
}

class Subscriber {
    public void wake(String msg) {
        System.out.println(msg);
    }
}

class Publisher {
    List<Subscriber> subs = new ArrayList<>();

    String msg;

    public void update(String msg) {
        this.msg = msg;
        notifySubscribers();
    }

    public void notifySubscribers() {
        for (Subscriber sub : subs) {
            sub.wake(msg);
        }
    }

    public void addSubscriber(Subscriber sub) {
        subs.add(sub);
    }
}

A → 通知 → B  
B → 通知 → A
//A → B → A → B → A → B → … 无限循环

interface Observer {
    void update(String msg);
}

class ConcreteObserver implements Observer {
    private final String name;

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

    @Override
    public void update(String msg) {
        System.out.println(name + " 收到: " + msg);
    }
}

class Subject {
    private final List<Observer> observers = new ArrayList<>();
    private String msg;

    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    public void setMsg(String msg) {
        this.msg = msg;
        notifyObservers();
    }

    private void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(msg);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Subject subject = new Subject();

        subject.addObserver(new ConcreteObserver("A"));
        subject.addObserver(new ConcreteObserver("B"));

        subject.setMsg("hello");
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        SubmissionPublisher<String> publisher = new SubmissionPublisher<>();

        Flow.Subscriber<String> subscriber = new Flow.Subscriber<>() {
            private Flow.Subscription subscription;

            @Override
            public void onSubscribe(Flow.Subscription subscription) {
                this.subscription = subscription;
                subscription.request(1);
            }

            @Override
            public void onNext(String item) {
                System.out.println("收到: " + item);
                subscription.request(1);
            }

            @Override
            public void onError(Throwable throwable) {
                throwable.printStackTrace();
            }

            @Override
            public void onComplete() {
                System.out.println("结束");
            }
        };

        publisher.subscribe(subscriber);
        publisher.submit("hello");
        publisher.close();

        Thread.sleep(500);
    }
}

switch(state){
	case NEW:
	//...
	break;
	case PAID:
	//...
	break;
}

if (state == "未支付") {
    pay();
} else if (state == "已支付") {
    ship();
} else if (state == "已发货") {
    receive();
}

//状态接口
interface OrderState {
    void pay(OrderContext ctx);
    void ship(OrderContext ctx);
    void receive(OrderContext ctx);
}

//具体状态: 未支付
class UnpaidState implements OrderState {
    @Override
    public void pay(OrderContext ctx) {
        System.out.println("支付成功");
        ctx.setState(new PaidState());
    }

    @Override
    public void ship(OrderContext ctx) {
        throw new IllegalStateException("未支付，不能发货");
    }

    @Override
    public void receive(OrderContext ctx) {
        throw new IllegalStateException("未发货，不能收货");
    }
}

//具体状态: 已支付
class PaidState implements OrderState {
    @Override
    public void pay(OrderContext ctx) {
        throw new IllegalStateException("已经支付过了");
    }

    @Override
    public void ship(OrderContext ctx) {
        System.out.println("发货成功");
        ctx.setState(new ShippedState());
    }

    @Override
    public void receive(OrderContext ctx) {
        throw new IllegalStateException("未发货，不能收货");
    }
}

...

//上下文 (核心对象)
class OrderContext {
    private OrderState state;

    public OrderContext(OrderState state) {
        this.state = state;
    }

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

    public void pay() {
        state.pay(this);
    }

    public void ship() {
        state.ship(this);
    }

    public void receive() {
        state.receive(this);
    }
}

// 测试
public class Client {
    public static void main(String[] args) {
        OrderContext ctx = new OrderContext(new UnpaidState());

        ctx.request(); // 去支付
        ctx.request(); // 发货
        ctx.request(); // 收货
    }
}

//策略接口
public interface Comparator<T>{
	int compare(T o1,  T  o2);
}

List<Integer> list = Arrays.asList(3, 1, 2);

// 不同策略
Collections.sort(list, new Comparator<Integer>() {
    public int compare(Integer a, Integer b) {
        return a - b; // 升序
    }
});

public interface RejectedExecutionHandler {  
    void rejectedExecution(Runnable r, ThreadPoolExecutor executor);  
}

interface Visitor {
    void visit(EmployeeA a);
    void visit(EmployeeB b);
}

interface Element {
    void accept(Visitor visitor);
}

class EmployeeA implements Element {
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

public class Demo{
	public static void main(String[] args){
		//a的静态类型(编译时类型) 是 Animal
		//a的动态类型(运行时类型) 是 Dog
		Animal   a = new Dog();
		a.speak();
	}

}   

//Visitor接口
public interface ElementVisitor<R, P> {
    R visitPackage(PackageElement e, P p);
    R visitType(TypeElement e, P p);
    R visitVariable(VariableElement e, P p);
    R visitExecutable(ExecutableElement e, P p);
}

//被访问者
public interface Element {
    <R, P> R accept(ElementVisitor<R, P> v, P p);
}

//具体元素
class TypeElementImpl implements Element {
    public <R, P> R accept(ElementVisitor<R, P> v, P p) {
        return v.visitType(this, p);
    }
}