黑马程序员--银行管理系统

最新推荐文章于 2015-12-24 10:25:58 发布

d6d6d6d6d6d

最新推荐文章于 2015-12-24 10:25:58 发布

阅读量869

点赞数

本文链接：https://blog.csdn.net/d6d6d6d6d6d/article/details/11650107

版权

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IO开发S</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------

、
项目总结：银行管理系统这个项目，与我们生活是息息相关的，虽然我们经常去取钱，但是很多细节没有去重视，通过这次项目我了解到,在用面向对象来设计程序的时候，我们要把整个事情的逻辑弄清楚，然后抽取出其中的对象有几个，根据对象与对象之间的关系，来设计应该有几各类，各个类在设计的时候，始终要遵循“高内聚，低耦合”的原则，

面向对象的分析与设计

有三种对应类型的客户：VIP客户，普通客户，快速客户，异步随机生成各种类型的客户，各类型客户在其对应窗口按顺序依次办理业务。

面向对象重要原则：谁拥有数据，谁就要有操作这些的方法。

当我要把一个集合中的东西拿走，这个拿走的方法有返回值，返回至就是被拿走的那个家伙

currentTimeMillis
public static long currentTimeMillis()
返回以毫秒为单位的当前时间。注意，当返回值的时间单位是毫秒时，值的粒度取决于基础操作系统，并且粒度可能更大。
例如，许多操作系统以几十毫秒为单位测量时间。

银行管理系统

需求！
银行内有6个业务窗口，1-4号为普通窗口，5号窗口为快速窗口，6号为VIP窗口。

有三种对应类型的客户，VIP客户，普通客户，快速客户（办理如交水电费，电话费）

异步随机生成各种类型的客户，生成各类型的客户的概率比例：

VIP客户：普通客户：快速客户：1：6：3

客户办理业务所需时间有最大值和最小值，在该范围内，随机设定每个VIP客户以及普通客户办理业务所需时间，快速客户办理业务所需时间为最小值

各类型客户在其对应窗口按顺序依次办理业务。

快速窗口和VIP窗口在当前没有属于自己的任务的时候要为普通客户服务。如果有属于自己对应服务的客户等待时，要首先为其服务

NumberManager类
//号码管理类
//号码发生器
public class NumberManager {
//第一个号码
private int lastNumber=1;
//等待排队人号码的数组
List<Integer> queueNumber=new ArrayList<Integer>();

public synchronized Integer generateManager(){
  queueNumber.add(lastNumber);
  return lastNumber++;
}

//取排队人号码的方法
public synchronized Integer fetchServicesManager(){
  if (queueNumber.size()>0) {
   return queueNumber.remove(0);
  }
  return null;
}
}

号码管理器：

NumberMachine类
public class NumberMachine {
private NumberManager commonManager=new NumberManager();
private NumberManager expressManager=new NumberManager();
private NumberManager vipManager=new NumberManager();

public NumberManager getCommonManager() {
  return commonManager;
}
public NumberManager getExpressManager() {
  return expressManager;
}
public NumberManager getVipManager() {
  return vipManager;
}

private NumberMachine() {
}

//单例模式
//饿汉式
public static NumberMachine getInstans(){
  return instans;
}
private static NumberMachine instans=new NumberMachine();

//懒汉式
/*private NumberManager instans2=null;
public static NumberManager getinstans2(){
  if (instans2==null) {
   instans2=new NumberManager();
  }
  return instans2;
}*/
}

服务窗口

public class ServicesWindow {
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 stat(){
  Executors.newSingleThreadExecutor().execute(new Runnable(){
   public void run(){
    while (true==true) {
     switch (type) {
      case COMMON:
       common();
       break;
      case EXPRESS:
       express();
       break;
      case VIP:
       vip();
       break;

     }
    }
   }

});
}

private void common() {
  String windowName="第"+windowId+"号"+type+"窗口";

  Integer number=NumberMachine.getInstans().getCommonManager().fetchServicesManager();
  System.out.println(windowName+"正在获取任务。。。。");
  if (number!=null) {
   //模拟正在服务
   System.out.println(windowName+"为第"+number+"号客户服务。。。。");
   //服务开始时间,以毫秒计算
   long beginTime=System.currentTimeMillis();
   //假设正在为客户服务,其实就是让程序睡一会儿。。。
   //最大随机数,0---9000
   int maxRandom=Constants.MAX_SERVICES_TIME-Constants.MIN_SERVICES_TIME;
   long servicesTime=new Random().nextInt(maxRandom)+1+Constants.MIN_SERVICES_TIME;
   try {
    Thread.sleep(servicesTime);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   //服务花费时间=结束时间-开始时间
   long costTime=System.currentTimeMillis()-beginTime;

   System.out.println(windowName+"为第"+number+"号客户服务完成，耗时"+(costTime/1000)+"秒");
  }else {
   System.out.println(windowName+"没有获取到普通任务,空闲1秒!!!!");
   try {
    Thread.sleep(1000);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
}

private void express() {
  String windowName="第"+windowId+"号"+type+"窗口";

  Integer number=NumberMachine.getInstans().getExpressManager().fetchServicesManager();
  System.out.println(windowName+"正在获取任务。。。。");
  if (number!=null) {
   //模拟正在服务
   System.out.println(windowName+"为第"+number+"号快速客户服务。。。。");
   //服务开始时间,以毫秒计算
   long beginTime=System.currentTimeMillis();
   //假设正在为客户服务,其实就是让程序睡一会儿。。。
   //最大随机数,0---9000
   int maxRandom=Constants.MAX_SERVICES_TIME-Constants.MIN_SERVICES_TIME;
   long servicesTime=new Random().nextInt(maxRandom)+1+Constants.MIN_SERVICES_TIME;
   try {
    Thread.sleep(servicesTime);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   //服务花费时间=结束时间-开始时间
   long costTime=System.currentTimeMillis()-beginTime;

   System.out.println(windowName+"为第"+number+"号客户服务完成，耗时"+(costTime/1000)+"秒");
  }else {
   System.out.println(windowName+"没有获取到快速客户任务,空闲1秒!!!!");
   common();
  }
}

private void vip() {
  String windowName="第"+windowId+"号"+type+"窗口";

  Integer number=NumberMachine.getInstans().getVipManager().fetchServicesManager();
  System.out.println(windowName+"正在获取任务。。。。");
  if (number!=null) {
   //模拟正在服务
   System.out.println(windowName+"为第"+number+"号VIP客户服务。。。。");
   //服务开始时间,以毫秒计算
   long beginTime=System.currentTimeMillis();
   //假设正在为客户服务,其实就是让程序睡一会儿。。。
   //最大随机数,0---9000
   int maxRandom=Constants.MAX_SERVICES_TIME-Constants.MIN_SERVICES_TIME;
   long servicesTime=new Random().nextInt(maxRandom)+1+Constants.MIN_SERVICES_TIME;
   try {
    Thread.sleep(servicesTime);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   //服务花费时间=结束时间-开始时间
   long costTime=System.currentTimeMillis()-beginTime;

   System.out.println(windowName+"为第"+number+"号客户服务完成，耗时"+(costTime/1000)+"秒");
  }else {
   System.out.println(windowName+"没有获取到"+type+"任务,空闲1秒!!!!");
   common();
  }
}
}

服务类型：枚举（普通，快速，VIP）

public enum CustomerType {
COMMON,VIP,EXPRESS;

public String toString(){
  switch (this) {
  case COMMON:
   return "普通";
  case VIP:
   return "VIP";
  case EXPRESS:
   return "快速";
  }
  return null;
}
}

开始模拟循环叫号：
public static void main(String[] args) {
  //先弄出几个普通窗口来
  for (int i = 1; i < 5; i++) {
   ServicesWindow commonWindow=new ServicesWindow();
   commonWindow.setWindowId(i);
   commonWindow.stat();
  }

  ServicesWindow expressWindow=new ServicesWindow();
  expressWindow.setType(CustomerType.EXPRESS);
  expressWindow.stat();

  ServicesWindow vipWindow=new ServicesWindow();
  vipWindow.setType(CustomerType.VIP);
  vipWindow.stat();

  //1秒钟来一个普通客户
  Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
    new Runnable(){
     public void run(){
      Integer number=NumberMachine.getInstans().getCommonManager().generateManager();
      System.out.println("第"+number+"号，普通客户正在等在服务。。。。。。。。。。。。。。。。。。。。。。");
     }
    },
    0,
    Constants.COMMON_CUSTMER_INTERVAL_TIME,
    TimeUnit.SECONDS
    );

  //3秒钟来一个快速客户
  Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
    new Runnable(){
     public void run(){
      Integer number=NumberMachine.getInstans().getExpressManager().generateManager();
      System.out.println("第"+number+"号，快速客户正在等在服务。。。。。。。。。。。。。。。。。。。。。。");
     }
    },
    0,
    Constants.COMMON_CUSTMER_INTERVAL_TIME*3,
    TimeUnit.SECONDS
    );

  //6秒钟来一个VIP客户
  Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
    new Runnable(){
     public void run(){
      Integer number=NumberMachine.getInstans().getVipManager().generateManager();
      System.out.println("第"+number+"号，VIP客户正在等在服务。。。。。。。。。。。。。。。。。。。。。。。");
     }
    },
    0,
    Constants.COMMON_CUSTMER_INTERVAL_TIME*6,
    TimeUnit.SECONDS
    );
}

d6d6d6d6d6d

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员--银行管理系统

、项目总结：银行管理系统这个项目，与我们生活是息息相关的，虽然我们经常去取钱，但是很多细节没有去重视，通过这次项目我了解到,在用面向对象来设计程序的时候，我们要把整个事情的逻辑弄清楚，然后抽取出其中的对象有几个，根据对象与对象之间的关系，来设计应该有几各类，各个类在设计的时候，始终要遵循“高内聚，低耦合”的原则，面向对象的分析与设计有三种对应类型的客户：VIP客户，普通客户，快速
复制链接

扫一扫