黑马程序员---银行系统知识点总结

来源：互联网发布：外卖消费人群数据分析编辑：程序博客网时间：2024/06/06 09:03

---------------------- 黑马程序员 Android培训、期待与您交流！ ---------------------

需求 : 首先是客户的产生，其实就是银行的取号机器产生的，不管是普通客户、快速客户还是VIP客户，都要在取号机取号，取过号后要加入排序的队列，一个取号机器中可以取出三种类别的号，分别是普通号、快速号和VIP号，所以我们首先可以把产生号的机制看做一个对象，它有产生号和让别人获取号的功能，如下代码所示：

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

public class NumberManager {
          private int lastNumber=1;
          private List<Integer> queueNumber=new ArrayList<Integer>();//定义一个集合用于存放取出的号码
          public synchronized Integer generateNewNumber(){                 //定义一个功能产生号码
                      queueNumber.add(lastNumber);
                       return lastNumber++;
          }
          public synchronized Integer fetchServiceNumber(){               //定义一个功能让外部获取等待的号码
                     Integer serverNumber=null;
                    if (queueNumber.size()>0) {
                                   serverNumber= queueNumber.remove(0);
                    }
                     return serverNumber;
        }
}
       然后我们可以把取号机器封装成一个类，通过调用其内部的方法来使用上面的取号机制，但因为不管谁来取号都是用的同一个取号机，所以要用到单例的设计模式，代码如下：

public class NumberMachine {
           private NumberManager commonManager=new NumberManager();
           private NumberManager fastManager=new NumberManager();
          private NumberManager VIPManager=new NumberManager();
          public NumberManager getCommonManager() {//分别提供方法获得相应的内部取号机制的对象
                      return commonManager;
             }
           public NumberManager getFastManager() {
                      return fastManager;
             }
            public NumberManager getVIPManager() {
                      return VIPManager;
            }
         private NumberMachine(){}                                                 //单例设计模式，构造函数私有化，对外提供获取对象的静态方法
         private static NumberMachine instance=new NumberMachine();
          public static NumberMachine getInstance(){
                       return instance;
          }
}

然后是银行的窗口，窗口对外提供一个叫号的方法，内部调用取号机制的获得等待号码的方法，分为普通窗口、快速窗口和VIP窗口，通过switch方法来决定那个窗口叫号，当叫到的号不为空时就服务，当普通窗口没有人等待时就休息一定时间再叫，当快速窗口和VIP窗口没有等待的客户时就叫普通号并为之服务。因为要定义三个变量控制那个窗口叫号，可以用枚举的方法把三个变量封装成枚举的实例元素，代码如下

public enum CustomerType {
         COMMON,FAST,VIP;
          public String toString(){                            //复写toString()方法
        switch (this) {
                 case COMMON:
                         return "普通";
                case FAST:
                         return "快速";
                case VIP:
                           return "VIP";
        }
     return null;
  }
}
做完枚举后用之实例决定叫号窗口，代码如下

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

public class ServiceWindow {
         private CustomerType type=CustomerType.COMMON;
         private int windowId=1;
         public void setType(CustomerType type) {
                   this.type = type;
         }
        public void setWindowId(int windowId) {
                    this.windowId = windowId;
          }

          public void start(){
                  Executors.newSingleThreadExecutor().execute(new Runnable(){
                               public void run(){
                                          while (true) {
                                                        switch (type) {
                                                                case COMMON:
                                                                            commonService();
                                                                             break;
                                                                    case FAST:
                                                                               fastService();
                                                                             break;
                                                                   case VIP:
                                                                             VIPService();
                                                                               break;
                                                       }
                                         }
                          }
                           });
}
public void commonService(){
                String windowName="第"+windowId+"号"+type+"窗口";
                 Integer number=NumberMachine.getInstance().getCommonManager().fetchServiceNumber();
                System.out.println(windowName+"正在获取服务任务");
                if (number!=null) {
                         long beginTime=System.currentTimeMillis();
                          int maxRand=Constants.MAX_SERVER_TIME-Constants.MIN_SERVER_TIME;
                           long serverTime=new Random().nextInt(maxRand)+1+Constants.MIN_SERVER_TIME;
                         try {
                                     Thread.sleep(serverTime);
                         } catch (Exception e) {
                                    // TODO: handle exception
                                     e.printStackTrace();
                        }
               long costTime=System.currentTimeMillis()-beginTime;
                System.out.println(windowName+"为第"+number+"个普通客户完成服务，耗时"+costTime/1000+"秒");
              }else {
                          System.out.println(windowName+"没有取到服务任务，先休息一秒种");
                          try {
                                  Thread.sleep(1000);
                          } catch (Exception e) {
                                    // TODO: handle exception
                                   e.printStackTrace();
                         }
              }
}
public void fastService(){
              String windowName="第"+windowId+"号"+type+"窗口";
                Integer number=NumberMachine.getInstance().getFastManager().fetchServiceNumber();
                System.out.println(windowName+"正在获取服务任务");
               if (number!=null) {
                         long beginTime=System.currentTimeMillis();
                        try {
                                            Thread.sleep(Constants.MIN_SERVER_TIME);
                         } catch (Exception e) {
                                        // TODO: handle exception
                                        e.printStackTrace();
                       }
              long costTime=System.currentTimeMillis()-beginTime;
               System.out.println(windowName+"为第"+number+"个"+type+"客户完成服务，耗时"+costTime/1000+"秒");
              }else {
                            System.out.println(windowName+"没有取到服务任务");
                             commonService();           //快速窗口空闲的时候可以处理普通客户

             }
}
public void VIPService(){
                 String windowName="第"+windowId+"号"+type+"窗口";
                 Integer number=NumberMachine.getInstance().getVIPManager().fetchServiceNumber();
                  System.out.println(windowName+"正在获取服务任务");
                if (number!=null) {
                              long beginTime=System.currentTimeMillis();
                            int maxRand=Constants.MAX_SERVER_TIME-Constants.MIN_SERVER_TIME;
                            long serverTime=new Random().nextInt(maxRand)+1+Constants.MIN_SERVER_TIME;
                            try {
                                       Thread.sleep(serverTime);
                           } catch (Exception e) {
                                         // TODO: handle exception
                                       e.printStackTrace();
                            }
                       long costTime=System.currentTimeMillis()-beginTime;
                        System.out.println(windowName+"为第"+number+"个"+type+"客户完成服务，耗时"+costTime/1000+"秒");
                }else {
                            System.out.println(windowName+"没有取到服务任务");
                             commonService();                //VIP窗口空闲的时候可以处理普通客户


                }
         }
}

窗口代码中用到的常量可以另外封装成一个类，如下

public class Constants {
           public static int MAX_SERVER_TIME=10000;
          public static int MIN_SERVER_TIME=1000;
           public static int COMMON_CUSTOMER_HERE_TIME=1;
}

然后通过主线程来new出一定的窗口，并开户窗口的叫号方法，然后用调度线程池技术来定时的产生客户，实现代码如下

import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class MainClass {

/**
* @param args
*/
public static void main(String[] args) {
            // TODO Auto-generated method stub
            for (int i = 1; i < 5 ; i++) {
             ServiceWindow commonWindow=new ServiceWindow();
            commonWindow.setWindowId(i);
              commonWindow.start();
  }
          ServiceWindow fastWindow=new ServiceWindow();
          fastWindow.setType(CustomerType.FAST);
           fastWindow.start();
          ServiceWindow VIPWindow=new ServiceWindow();
           VIPWindow.setType(CustomerType.VIP);
           VIPWindow.start();
           Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
                      new Runnable(){
                              public void run(){
                                   Integer number=NumberMachine.getInstance().getCommonManager().generateNewNumber();
                                   System.out.println(number+"号普通客户等待服务");
                }
           },
            0,
           Constants.COMMON_CUSTOMER_HERE_TIME,
            TimeUnit.SECONDS);
             Executors.newScheduledThreadPool(1).scheduleAtFixedRate(       //分别产生线程来生成号码产生客户
                       new Runnable(){
                             public void run(){
                                   Integer number=NumberMachine.getInstance().getFastManager().generateNewNumber();
                                  System.out.println(number+"号快速客户等待服务");
                               }
                  },
                 0,
                 Constants.COMMON_CUSTOMER_HERE_TIME*2,
               TimeUnit.SECONDS);
            Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
                        new Runnable(){
                                    public void run(){
                                                 Integer number=NumberMachine.getInstance().getVIPManager().generateNewNumber();
                                                 System.out.println(number+"号VIP客户等待服务");
                                    }
                     },
                     0,
                     Constants.COMMON_CUSTOMER_HERE_TIME*6,
                    TimeUnit.SECONDS);
            }

}

---------------------- 黑马程序员 Android培训、期待与您交流！ ---------------------

0 0