银行业务调度系统，张老师讲过可以使用继承，用3个类来模拟不同的窗口类型，我的代码如：
1.CommonService 是基类，也是普通服务窗口，里面提供了service方法表示服务，service方法里面又调用了不同的方法，如：不同的休息时间，子类须重新这些方法，以满足不同的业务
2.ExpressServiceWindow为快速窗口类，继承CommonService 类，重写了部分方法，见代码，问题也在代码里面，不太好描述问题
package bank;

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

// 普通用户服务窗口类
public class CommonServiceWindow {
        // 窗口类型，默认为普通
        private CustomerType type = CustomerType.COMMON;
        // 窗口号，默认为1
        private int windowId = 1;

        // 窗口启动业务服务
        public void start() {
                // 线程池
                ExecutorService pool = Executors.newSingleThreadExecutor();
                pool.execute(new Runnable() {
                        public void run() {
                                while (true) {
                                        service(); // 调用service服务，这里解决了switch语句块的问题
                                }
                        }
                });
        }

        // 窗口服务方法，final固定此方法不能被重写，此方法为模版
        public final void service() {
                String windowName = "第" + windowId + "号" + type + "窗口，"; // type有可能是快速或VIP
                Integer serviceNumber = nextServiceNumber();
                System.out.println(windowName + "正在获取任务");
                if (serviceNumber != null) {
                        System.out.println(windowName + "为第" + serviceNumber + "个" + type
                                        + "客户服务");
                        long beginTime = System.currentTimeMillis();
                        long serveTime = serviceTime();
                        try {
                                Thread.sleep(serveTime);
                        } catch (InterruptedException e) {
                                e.printStackTrace();
                        }
                        long costTime = System.currentTimeMillis() - beginTime;
                        System.out.println(windowName + "为第" + serviceNumber + "个" + type
                                        + "客户完成服务，耗时" + costTime / 1000 + "秒");
                } else {
                        doOther(windowName);
                }
        }

        // 普通窗口服务方法
        protected final void commonService() {
                String windowName = "第" + windowId + "号" + type + "窗口，"; // type有可能是快速或VIP
                Integer serviceNumber = NumberMachine.getInstance().getCommonManager()
                                .fetchServiceNumber();
                System.out.println(windowName + "正在获取任务");
                if (serviceNumber != null) {
                        System.out.println(windowName + "为第" + serviceNumber + "个普通客户服务");
                        long beginTime = System.currentTimeMillis();
                        int maxRand = Constants.MAX_SERVICE_TIME
                                        - Constants.MIN_SERVICE_TIME;
                        long serveTime = new Random().nextInt(maxRand) + 1
                                        + Constants.MIN_SERVICE_TIME; // 1000 到 10000
                        try {
                                Thread.sleep(serveTime);
                        } catch (InterruptedException e) {
                                e.printStackTrace();
                        }
                        long costTime = System.currentTimeMillis() - beginTime;
                        System.out.println(windowName + "为第" + serviceNumber
                                        + "个普通客户完成服务，耗时" + costTime / 1000 + "秒");
                } else {
                        System.out.println(windowName + "没有取到任务，先休息一秒钟");
                        try {
                                Thread.sleep(1000);
                        } catch (InterruptedException e) {
                                e.printStackTrace();
                        }
                }
        }

        // 下一个服务号码，子类重写此方法，以便获取不同的类型的服务号码
        protected Integer nextServiceNumber() {
                return NumberMachine.getInstance().getCommonManager()
                                .fetchServiceNumber();
        }

        // 服务时间因客户类型不同而不同，子类可重写此方法，来设置对应的服务时间
        protected long serviceTime() {
                int maxRand = Constants.MAX_SERVICE_TIME - Constants.MIN_SERVICE_TIME;
                long serveTime = new Random().nextInt(maxRand) + 1
                                + Constants.MIN_SERVICE_TIME; // 1000 到 10000
                return serveTime;
        }

        // 下一个服务号码为空时，窗口该做的事情，子类可重写此方法，来设置
        protected void doOther(String windowName) {
                System.out.println(windowName + "没有取到任务，先休息一秒钟");
                try {
                        Thread.sleep(1000);
                } catch (InterruptedException e) {
                        e.printStackTrace();
                }
        }

        public void setType(CustomerType type) {
                this.type = type;
        }

        public void setWindowId(int windowId) {
                this.windowId = windowId;
        }
}

1. 
   

复制代码

// 快速客户服务窗口
public class ExpressServiceWindow extends CommonServiceWindow{
       
        public ExpressServiceWindow() {
                this.setType(CustomerType.EXPRESS);
        }

        @Override
        protected Integer nextServiceNumber() {
                return NumberMachine.getInstance().getExpressManager().fetchServiceNumber();
        }

        @Override
        protected long serviceTime() {
                return Constants.MIN_SERVICE_TIME;
        }

        @Override
        protected void doOther(String windowName) {
                System.out.println(windowName + "没有取到任务");
                super.commonService();  // 问题是：这里写成super.service()就更好理解了，应为子类覆盖了父类的对应的方法，而此时，我还是想在记录继续使用父类 service方法，
                                                       // 而不用一些子类的重写的方法，不知道如何办？我的办法就是就父类写了一个final方法去调用，有没有其他办法，看着有点别扭

        }
}

全部代码为，使用 MainClass2启动

楼主你好，如果帖子已经没问题了，那么把帖子的类型改为“已解决”。如果不会改看我的个性签名