/**
 * 策略抽象類
 * @author tcy
 * @Date 21-09-2022
 */
public interface AbstractMemberStrategy {
    // 一個(gè)計(jì)算價(jià)格的抽象方法
    //price商品的價(jià)格 n商品的個(gè)數(shù)
    public double calcPrice(double price, int n);
}

/**高級(jí)會(huì)員
 * @author tcy
 * @Date 21-09-2022
 */
public class StrategyAdvanceMember implements AbstractMemberStrategy {
    @Override
    public double calcPrice(double price, int n) {
        double money = price * n *0.8;
        return money;
    }
}

/**
 * 中級(jí)會(huì)員
 * @author tcy
 * @Date 21-09-2022
 */
public class StrategyIntermediateMember implements AbstractMemberStrategy {
    @Override
    public double calcPrice(double price, int n) {
        double money = price * n*0.9;
        return money;
    }
}

/**
 * 初級(jí)會(huì)員
 * @author tcy
 * @Date 21-09-2022
 */
public class StrategyPrimaryMember implements AbstractMemberStrategy {
    @Override
    public double calcPrice(double price, int n) {
        return price * n;
    }
}

/**環(huán)境類
 * @author tcy
 * @Date 21-09-2022
 */
public class Context {
    // 用戶折扣策略接口
    private AbstractMemberStrategy memberStrategy;

    // 注入構(gòu)造方法
    public Context(AbstractMemberStrategy memberStrategy) {
        this.memberStrategy = memberStrategy;
    }

    // 計(jì)算價(jià)格
    public double qoutePrice(double goodsPrice, int n){
        // 通過(guò)接口變量調(diào)用對(duì)應(yīng)的具體策略
        return memberStrategy.calcPrice(goodsPrice, n);
    }

}

/**
 * @author tcy
 * @Date 21-09-2022
 */
public class Client {
    public static void main(String[] args) {

        // 具體策略類
        AbstractMemberStrategy primaryMemberStrategy = new StrategyPrimaryMember();
        AbstractMemberStrategy intermediateMemberStrategy = new StrategyIntermediateMember();
        AbstractMemberStrategy advanceMemberStrategy = new StrategyAdvanceMember();

        // 用戶選擇不同策略
        Context primaryContext = new Context(primaryMemberStrategy);
        Context intermediateContext = new Context(intermediateMemberStrategy);
        Context advanceContext = new Context(advanceMemberStrategy);

        //一本100塊錢的書
        // 普通會(huì)員：100
        System.out.println("普通會(huì)員的價(jià)格："+ primaryContext.qoutePrice(100,1));
        // 中級(jí)會(huì)員 90
        System.out.println("中級(jí)會(huì)員的價(jià)格："+ intermediateContext.qoutePrice(100,1));
        // 高級(jí)會(huì)員 80
        System.out.println("高級(jí)會(huì)員的價(jià)格："+ advanceContext.qoutePrice(100,1));

    }
}

public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,
                          TimeUnit unit,BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

public ScheduledFuture<?> schedule(Runnable command,
                                   long delay,
                                   TimeUnit unit) {
    if (command == null || unit == null)
        throw new NullPointerException();
    RunnableScheduledFuture<?> t = decorateTask(command,
        new ScheduledFutureTask<Void>(command, null,
                                      triggerTime(delay, unit)));
    delayedExecute(t);
    return t;
}

private void delayedExecute(RunnableScheduledFuture<?> task) {
    if (isShutdown())
        reject(task);
    else {
        super.getQueue().add(task);
        if (isShutdown() &&
            !canRunInCurrentRunState(task.isPeriodic()) &&
            remove(task))
            task.cancel(false);
        else
            ensurePrestart();
    }
}

final void reject(Runnable command) {
    handler.rejectedExecution(command, this);
}