学习笔记总结

 

Io和基础加强

 

JAVA.IO的学习日记：

 主要知识点：.File类是IO包中唯一代表文件本身信息的类，可以利用File类中的方法对文件进行创建、删除、获取文件信息等操作。

    .RandomAccessFile提供的方法可以从文件的任意位置对文件进行访问，在读取等长记录文件的时候可以节省很多时间；

    .InputStream类的int read()方法可以一次读取一个字节的内容，当返回值为-1时表示读取结束；。

    .OutputStream类是相对于外部文件的输出流，该类的void write()方法可以向外部文件写入数据；void flush()方法可以将内存缓冲区中的数据清空并立即写入到外部设备中；

    .创建FileInputStream类的对象时，指定文件必须存在并且可读；创建OutputStream实例对象时，指定文件可以不存在，若存在则不能不其他应用程序打开。

    .Reader和Writer类可以对字符流进行处理，大多用于文本文件的访问；

    .PipedInputStream类和PipedOutputStream类用于在两个线程之间建立管道通信；一个线程可以使用PipedInputStream类从另一个线程使用的PipedOutputStream类中读取数据；

代码：

  import java.io.*;

 public class Sender extends Thread{

private PipedOutputStream out = new PipedOutputStream();

private PipedOutputStream getOutputStream(){

return out;

}

public void run(){

String strInfo = new String("Hello,Sender");

try{

out.write(strInfo.getBytes());

out.close();

}catch(Exception ex){}

}

 }

 

 import java.io.*;

 public class Receiver extends Thread{

private PipedInputStream in = new PipedInputStream();

private PipedInputStream getInputStream(){

return in;

}

public void run(){

byte[] buf = new byte[1024];

try{

int len = in.read(buf);

System.out.println(

                                          "the following message comes from sender :"

                                           +new String(buf,0,len));

in.close();

}catch(Exception ex){}

}

 }

 

 public class PipedStreamTest{

public static void main(String [] args) throws Exception{

Sender t1 = new Sender();

Receiver t2 = new Receiver();

PipedOutputStream out = t1.getOutputStream();

PipedInputStream in = t2.getInputStream();

out.connect(in);//in.connect(out);

t1.start();

t2.start();

}

 }

 

 UDP与TCP

TCP:传输控制协议，面向连接的通信协议，等待应答

UDP:用户数据报 ，是无连接的通信协议，不等待应答

ServerSocket类

构造函数

public ServerSocket()

public ServerSocket(int port) //默认数量是50个

public ServerSocket(int port,int backlog)

public ServerSocket(int port,int backlog,

  InetAddress bindAddr)

close()

accept() 返回socket对象

Socket类

构造方法

public Socket()

public Socket(String host,int port)

public Socket(InetAddress address,int port)

public Socket(String host,int port,

 InetAddress localAddr,int localPort)

public Socket(InetAddress address,int port,

  InetAddress localAddr,int localPort)

方法

getInputStream() 返回输入流对象

getOutputStream()返回输出流对象

 //基于TCP的服务器端

 import java.net.*;

 import java.io.*;

 public class TcpServer {

 

     /**

      * @param args

      */

     public static void main(String[] args) throws Exception {

         // TODO Auto-generated method stub

         ServerSocket ss=new ServerSocket(8001); //创建服务器socket对象

         Socket s=ss.accept(); //等待客户端连接，返回socket对象

         InputStream ips= s.getInputStream();//返回 输入流对象

         OutputStream ops=s.getOutputStream();//获得 输出流对象

         

         ops.write("welcome,jiedian's Server/n".getBytes());

         

         BufferedReader br = new BufferedReader(new InputStreamReader(ips));

         //包装网络输入流，字节流

         System.out.println(br.readLine());

         /*

         byte[] buf=new byte[1024];

         int length=ips.read(buf);

         System.out.println(new String(buf,0,length));

         */

         

         br.close();

         //ips.close();

         ops.close();

         s.close();

         ss.close();

     }

 

 }

 

 

高薪技术主要知识点： 

静态导入，装拆箱，枚举

import static java.lang.Math.*;//静态导入

public class JavaBase {

 

    public static void main(String[] args) {

 

 

        System.out.println(max(3, 6));// 比较那个数大

        System.out.println(abs(3 - 6));// 绝对值的差

        /**

         * 可变参数实例

         */

        System.out.println(add(2, 3));

        System.out.println(add(3, 5, 4, 6, 7));

        /**

         * 11.当字节在-128~127进行Integer装箱后为同一个对象（享元模式）FlyWeight

         */

        Integer i1 = 23;

        Integer i2 = 23;

        Integer i3 = 128;

        Integer i4 = 128;

        System.out.println(i1 == i2);

        System.out.println(i3 == i4);

        /**

         * 简单枚举

         */

        Week w1 = Week.SUN;

        System.out.println(w1);

        System.out.println(w1.name());

        System.out.println(w1.ordinal());

        System.out.println(Week.valueOf("MON"));// 把字符串变成对应的对象

        System.out.println(Week.values().length);

        /**

         * 复杂枚举

         */

        Student s = Student.EAT.doingWhat();

        System.out.println(s);

 

    }

 

    /**

     *可变参数方法，可变参数的出现，我们就不需要太多的重构方法了！

     */

    public static int add(int x, int... y) {

        int sum = x;

        // for(int i = 0;i<y.length;i++){

        // sum +=y[i];

        // }

        /**

         * for循环增强

         */

        for (int a : y) {

            sum += a;

        }

        return sum;

    }

 

    /**

     *简单枚举

     */

    public enum Week {

        SUN(1), MON, TUE, WED, THI, FRI, SAT;

        private Week() {

            System.out.println("first");

        }// 枚举中的构造方法必须私有

 

        private Week(int day) {

            System.out.println("second");

        }

    }

 

    /**

     * 复杂枚举，枚举可以实现单例，并且非常方便，我们可以采用内部类的方式实现单例

     */

    public enum Student {// Bad do what;

        SLEEP(10) {

            public Student doingWhat() {

                System.out.println("睡醒了吃");

                return EAT;

            }

        },

        EAT(10) {

            public Student doingWhat() {

                System.out.println("吃饱了睡");

                return SLEEP;

            }

        };

        public abstract Student doingWhat();

 

        private int time = 0;

 

        private Student(int time) {

            this.time = time;

        }

    }

}

 

反射：

package com.itcast.refl;

 

import java.lang.reflect.Array;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.util.Arrays;

 

public class Reflection {

 

    public static void main(String[] args) throws ClassNotFoundException,

            SecurityException, NoSuchMethodException, IllegalArgumentException,

            InstantiationException, IllegalAccessException,

            InvocationTargetException, NoSuchFieldException {

        // Class 代表内存中的一份字节码

        /**

         * 得到字节码 类名.classs 如：System.class; 对象.getClass

         * Class.forName("类名")；如：Class.forName("java.util.Date");

         * 其实每一个类在内存中就是以字节码的形式存在！ 以下是得到字节码的三种方法！

         */

        String str = "cpp";

        Class cls1 = str.getClass();

        Class cls2 = String.class;

        Class cls3 = Class.forName("java.lang.String");

 

        System.out.println(cls1 == cls2);

        System.out.println(cls3 == cls2);

 

        System.out.println(cls1.isPrimitive());// 字节码是否为基本类型的判断

        System.out.println(int.class.isPrimitive());

 

        System.out.println(int.class == Integer.class);

        System.out.println(int.class == Integer.TYPE);

 

        System.out.println(int[].class.isArray());// 判断是否为数组

 

 

        Constructor constructor = String.class

                .getConstructor(StringBuffer.class);

        String str2 = (String) constructor.newInstance(new StringBuffer("cpp"));

        System.out.println(str2.charAt(2));// 用反射的到字符串的查找方法，并输出查找结果

 

 

        // 无参构造方法的实现

        ReflectionPoint pt1 = new ReflectionPoint(3, 5);

        Field fieldy = pt1.getClass().getField("y");// 得到可见的变量

        System.out.println(fieldy.get(pt1));

        // 得到私有变量

        Field fieldx = pt1.getClass().getDeclaredField("x");// 得到可见的变量

        fieldx.setAccessible(true);// 允许访问私有属性！也叫暴力反射

        System.out.println(fieldx.get(pt1));

 

 

        changeStringValue(pt1);

        System.out.println(pt1);

 

        Method methodCharAt = String.class.getMethod("charAt", int.class);

        System.out.println("取出第二个字符" + methodCharAt.invoke(str, 1));

 

        // 一般调用main方法

        Test.main(new String[] { "asd", "qwe", "sdf" });

        // 用反射调用main方法

        String startingClassName = "im.fldy.Test";

        Method mainMethod = Class.forName(startingClassName).getMethod("main",

                String[].class);

        mainMethod.invoke(null, (Object) new String[] { "asd", "qwe", "sdf" });

 

        int[] a1 = new int[] { 1, 2, 34, 5, 5 };

        int[] a2 = new int[4];

        int[][] a3 = new int[2][1];

        String[] a4 = new String[] { "q", "ssda", "asd" };

        System.out.println(a1.getClass() == a2.getClass());

        System.out.println(a1.getClass().getName());// [I 整型数组名

        System.out.println(a3.getClass().getName());// [[I 字符数组名

        System.out.println(a1.getClass().getSuperclass().getName());

        System.out.println(a3.getClass().getSuperclass().getName());

 

        // 下面是检查是否可以直接打印集合中的元素结果发现Int[]数组中的元素不能直接遍历

        System.out.println(a1);

        System.out.println(a4);

        System.out.println(Arrays.asList(a1));

        System.out.println(Arrays.asList(a4));

 

        // 打印数组中的所有元素

        printObject(a1);

        printObject(a4);

    }

 

    // 对于Int数组不能直接打印其中的元素，我们可以采用下面的办法

    // 用反射的原理先判断传入的对象是不是数组，这样我们就可以同时遍历Int[]和String[]了

    private static void printObject(Object obj) {

        // TODO Auto-generated method stub

        Class claz = obj.getClass();

        if (claz.isArray()) {

            int len = Array.getLength(obj);

            for (int i = 0; i < len; i++) {

                System.out.println(Array.get(obj, i));

            }

        } else {

            System.out.println(obj);

        }

    }

 

    /**

     * 本方法利用反射的原理对传进去的ReflectionPoint类中的String字符串变量进行替换 如一些非法字符，不良言语等等替换

     */

 

    private static void changeStringValue(Object obj)

            throws IllegalArgumentException, IllegalAccessException {

        Field[] fields = obj.getClass().getFields();

        for (Field field : fields) {

            if (field.getType() == String.class) {

                String oldValue = (String) field.get(obj);

                String newValue = oldValue.replace('操', '*');

                field.set(obj, newValue);

            }

        }

    }

 

    public static class ReflectionPoint {

        private int x;

        public int y;

        public String d = "楼哈";

        public String ds = "和得有";

        public String dsa = "苹果电脑";

 

        public ReflectionPoint(int x, int y) {

            super();

            this.x = x;

            this.y = y;

        }

 

        @Override

        public String toString() {

            return "1：" + d + "2：" + ds + "3：" + dsa + "";

 

        }

    }

 

}

 

class Test {

    public static void main(String[] args) {

        for (String arg : args) {

            System.out.println(arg);

        }

    }

}

 

 public <T> void swap(T [] array, int i,int j){
  //<T>声明了一个任意类型的变量
  T temp= array[i];
  array[i]=array[j];
  array[j]=temp;
 }

写一个泛型方法，自动将Object类型的对象转换成其他类型：
public <T> T autoConvert(Object obj){
 return (T) obj;
}

 

交通管理系统

 异步随机生成按照各个路线行驶的车辆。

像 从南行驶到北的车辆 

   从西向西南的车辆

   从东向东南行驶的车辆

 

   分化为： 直行车辆

                右转车辆

                左转车辆

     一共需要12条路线

 

代码类： 

 

 

 

 

    类1：

                    ExecutorService pool = Executors.newScheduledThreadPool(1);

                    // 用实现接口 Runnable

                    pool.execute(new Runnable(){

 

                            public void run() {

                                      for(int i=1;i<1000;i++){

                                                try {

                                                         //用随机数控制

                                                        Thread.sleep((new Random().nextInt(10)+1) * 1000);

                                               } catch (InterruptedException e) {

                                                        e.printStackTrace();

                                               }

 

                                                list.add(Road.this.name + "_" +i);

                                      }

                            }

                    });

                   //定时器 

                    ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);

                   timer.scheduleAtFixedRate(

                                     new Runnable(){

 

                                               public void run() {

                                                        if(list.size()>0){

                                                                 boolean lighted =

                                                                           lamp.valueOf(Road.this.name).isLighted();

                                                                 if(lighted){

                                                                           System.out.println(list.remove(0)+"过马路了");

                                                                 }

                                                        }

                                               }

 

                                     },

                                     1,

                                     1,

                                     TimeUnit.SECONDS);

 

          }

 

     类2：

 

灯：12个灯，用枚举。

 

S2N("N2S","S2W",false),S2W("N2E","E2W",false),E2W("W2E","E2S",false),E2S("W2N","S2N",false),

 N2S(null,null,false),N2E(null,null,false),W2E(null,null,false),W2N(null,null,false),

S2E(null,null,true),E2N(null,null,true),N2W(null,null,true),W2S(null,null,true);

 

 private lamp(String opposite,String next,boolean lighted){

  this.opposite = opposite;

   this.next = next;

   this.lighted = lighted;

         }

 

         private lamp(){

 

         }

 

         //灯的状态

         private boolean lighted;

 

         private String opposite;

 

         private String next;

 

         public boolean isLighted(){

                   return lighted;

         }

         //灯变绿

         public void light(){

                   this.lighted = true;

                   if(opposite != null ){

                            //枚举有一个静态方法你给他的字符串返回一个枚举的对象

                            lamp.valueOf(opposite).light();

                   }

                   System.out.println(name()+"lamp is green 下面总共应该有6个方向能看到汽车");

         }

         //灯变红

         public lamp blackOut(){

                   this.lighted = false;

                   if(opposite != null)

                            lamp.valueOf(opposite).blackOut();

 

                   lamp nextLamp= null;

 

                   if(next != null){

                            nextLamp = lamp.valueOf(next);

                            System.out.println("绿灯从"+name()+"--------切换为"+next);

                            lamp.valueOf(next).light();

 

                   }

                   return nextLamp;

         }

 

 

灯控制器：进行灯的红绿切换。控制4租灯的切换

有个变量：当前绿的灯是哪一个  有个定时器，时间一到把当前等变红 当这个变红的同时返回下一个绿灯

 

灯控制器代码：

private lamp dangQianDeng;

 

         public lampKongZhi(){

                   dangQianDeng = lamp.S2N;

                   dangQianDeng.light();

 

                   //定时器

                   ScheduledExecutorService time = Executors.newScheduledThreadPool(1);

                   time.scheduleWithFixedDelay(

                                     new Runnable(){

                                               //这个方法很有意思！把灯变成红的同时返回下一个绿灯

                                               public void run() {

                                                        dangQianDeng = dangQianDeng.blackOut();

                                               }

 

                                     },

                                     10,

                                     10,

                                     TimeUnit.SECONDS);

         }

小结

使用主要知识点是： 线程和枚举的使用

 

银行业务调度系统

银行业务调度系统需求分析：

 客户种类“
     1：VIP客户（大客户）

     2：普通客户

     3：快速客户（电话费，水电费等等）

     实现方式： 异步随机生成各种类型的客户，各类型客户在其对应窗口按顺序依次办理业务 。
     

    有取号机统一生成随即号码，生成各类用户个概率比例是

    VIP：普通：快速：1.6.3

主要实现类如下： 

 

类1：NumberManager类 

 

  package cn.itcast.bankqueue

 

import java.util.ArrayList;  

import java.util.List;  

 

public class NumberManager {  

    private int lastNumber = 0;  

    @SuppressWarnings("unchecked")  

    private List queueNumbers = new ArrayList();  

 

    @SuppressWarnings("unchecked")  

    public synchronized Integer generateNewNumber(){  

        queueNumbers.add(++lastNumber);  

        return lastNumber;  

    }  

 

    public synchronized Integer fetchNumber(){  

        if(queueNumbers.size()>0){  

            return (Integer)queueNumbers.remove(0);  

        }else{  

            return null;  

        }  

    }  

}  

 

 

类2: NumberMachine类 

 package cn.itcast.bankqueue

 

public class NumberMachine {  

 

    private NumberMachine(){}  

    private static NumberMachine instance = new NumberMachine();  

    public static NumberMachine getInstance(){  

        return instance;  

    }  

 

    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;  

    }  

 

}  

 

 

类3：CustomerType枚举类 

 

Java代码  

package cn.itcast.bankqueue;  

 

public enum CustomerType {  

    COMMON,EXPRESS,VIP;  

    public String toString(){  

        String name = null;  

        switch(this){  

        case COMMON:  

            name = "普通";  

            break;  

        case EXPRESS:  

            name = "快速";  

            break;  

        case VIP:  

            name = name();  

            break;  

        }  

        return name;  

    }  

}  

 

 

类4：ServiceWindow类 

:

 

package cn.itcast.bankqueue;  

 

import java.util.Random;  

import java.util.concurrent.Executors;  

import java.util.logging.Logger;  

 

/** 

 * 没有把VIP窗口和快速窗口做成子类，是因为实际业务中的普通窗口可以随时被设置为VIP窗口和快速窗口。 

 * */  

public class ServiceWindow {  

    @SuppressWarnings("unused")  

    private static Logger logger = Logger.getLogger("cn.itcast.bankqueue");  

    private CustomerType type = CustomerType.COMMON;  

    private int number = 1;  

 

    public CustomerType getType() {  

        return type;  

    }  

 

    public void setType(CustomerType type) {  

        this.type = type;  

    }  

 

    public void setNumber(int number){  

        this.number = number;  

    }  

 

    public void start(){  

        Executors.newSingleThreadExecutor().execute(  

                new Runnable(){  

                    public void run(){  

                        //下面这种写法的运行效率低，最好是把while放在case下面  

                        while(true){  

                            switch(type){  

                                case COMMON:  

                                    commonService();  

                                    break;  

                                case EXPRESS:  

                                    expressService();  

                                    break;  

                                case VIP:  

                                    vipService();  

                                    break;  

                            }  

                        }  

                    }  

                }  

        );  

    }  

 

    private void commonService(){  

        String windowName = "第" + number + "号" + type + "窗口";         

        System.out.println(windowName + "开始获取普通任务!");  

        Integer serviceNumber = NumberMachine.getInstance().getCommonManager().fetchNumber();         

        if(serviceNumber != null ){  

            System.out.println(windowName + "开始为第" + serviceNumber + "号普通客户服务");          

            int maxRandom = Constants.MAX_SERVICE_TIME - Constants.MIN_SERVICE_TIME;  

            int serviceTime = new Random().nextInt(maxRandom)+1 + Constants.MIN_SERVICE_TIME;  

 

            try {  

                Thread.sleep(serviceTime);  

            } catch (InterruptedException e) {  

                e.printStackTrace();  

            }     

            System.out.println(windowName + "完成为第" + serviceNumber + "号普通客户服务，总共耗时" + serviceTime/1000 + "秒");        

        }else{  

            System.out.println(windowName + "没有取到普通任务，正在空闲一秒");       

            try {  

                Thread.sleep(1000);  

            } catch (InterruptedException e) {  

                e.printStackTrace();  

            }                 

        }  

    }  

 

    private void expressService(){  

        Integer serviceNumber = NumberMachine.getInstance().getExpressManager().fetchNumber();  

        String windowName = "第" + number + "号" + type + "窗口";     

        System.out.println(windowName + "开始获取快速任务!");         

        if(serviceNumber !=null){  

            System.out.println(windowName + "开始为第" + serviceNumber + "号快速客户服务");              

            int serviceTime = Constants.MIN_SERVICE_TIME;  

            try {  

                Thread.sleep(serviceTime);  

            } catch (InterruptedException e) {  

                e.printStackTrace();  

            }         

            System.out.println(windowName + "完成为第" + serviceNumber + "号快速客户服务，总共耗时" + serviceTime/1000 + "秒");        

        }else{  

            System.out.println(windowName + "没有取到快速任务！");                 

            commonService();  

        }  

    }  

 

    private void vipService(){  

 

        Integer serviceNumber = NumberMachine.getInstance().getVipManager().fetchNumber();  

        String windowName = "第" + number + "号" + type + "窗口";     

        System.out.println(windowName + "开始获取VIP任务!");            

        if(serviceNumber !=null){  

            System.out.println(windowName + "开始为第" + serviceNumber + "号VIP客户服务");             

            int maxRandom = Constants.MAX_SERVICE_TIME - Constants.MIN_SERVICE_TIME;  

            int serviceTime = new Random().nextInt(maxRandom)+1 + Constants.MIN_SERVICE_TIME;  

            try {  

                Thread.sleep(serviceTime);  

            } catch (InterruptedException e) {  

                e.printStackTrace();  

            }         

            System.out.println(windowName + "完成为第" + serviceNumber + "号VIP客户服务，总共耗时" + serviceTime/1000 + "秒");       

        }else{  

            System.out.println(windowName + "没有取到VIP任务！");                

            commonService();  

        }     

    }  

}  

 

 

类5：MainClass类 

 

package cn.itcast.bankqueue;  

 

import java.util.concurrent.Executors;  

import java.util.concurrent.TimeUnit;  

import java.util.logging.Logger;  

 

public class MainClass {  

 

    @SuppressWarnings("unused")  

    private static Logger logger = Logger.getLogger("cn.itcast.bankqueue");  

 

 

    public static void main(String[] args) {  

        //产生4个普通窗口  

        for(int i=1;i<5;i++){  

            ServiceWindow window =  new ServiceWindow();  

            window.setNumber(i);  

            window.start();  

        }  

 

        //产生1个快速窗口  

        ServiceWindow expressWindow =  new ServiceWindow();  

        expressWindow.setType(CustomerType.EXPRESS);  

        expressWindow.start();  

 

        //产生1个VIP窗口       

        ServiceWindow vipWindow =  new ServiceWindow();  

        vipWindow.setType(CustomerType.VIP);  

        vipWindow.start();        

 

        //普通客户拿号  

        Executors.newScheduledThreadPool(1).scheduleAtFixedRate(  

                new Runnable(){  

                    public void run(){  

                        Integer serviceNumber = NumberMachine.getInstance().getCommonManager().generateNewNumber();  

                        /** 

                         * 采用logger方式，无法看到直观的运行效果，因为logger.log方法内部并不是直接把内容打印出出来， 

                         * 而是交给内部的一个线程去处理，所以，打印出来的结果在时间顺序上看起来很混乱。 

                         */  

                        //logger.info("第" + serviceNumber + "号普通客户正在等待服务！");  

                        System.out.println("第" + serviceNumber + "号普通客户正在等待服务！");                         

                    }  

                },  

                0,  

                Constants.COMMON_CUSTOMER_INTERVAL_TIME,   

                TimeUnit.SECONDS);  

 

        //快速客户拿号  

        Executors.newScheduledThreadPool(1).scheduleAtFixedRate(  

                new Runnable(){  

                    public void run(){  

                        Integer serviceNumber = NumberMachine.getInstance().getExpressManager().generateNewNumber();  

                        System.out.println("第" + serviceNumber + "号快速客户正在等待服务！");  

                    }  

                },  

                0,  

                Constants.COMMON_CUSTOMER_INTERVAL_TIME * 2,   

                TimeUnit.SECONDS);  

 

        //VIP客户拿号  

        Executors.newScheduledThreadPool(1).scheduleAtFixedRate(  

                new Runnable(){  

                    public void run(){  

                        Integer serviceNumber = NumberMachine.getInstance().getVipManager().generateNewNumber();  

                        System.out.println("第" + serviceNumber + "号VIP客户正在等待服务！");  

                    }  

                },  

                0,  

                Constants.COMMON_CUSTOMER_INTERVAL_TIME * 6,   

                TimeUnit.SECONDS);  

    }  

 

 

}  

 

 

类6：Constants类 

  1.定义三个常量：MAX_SERVICE_TIME、MIN_SERVICE_TIME、COMMON_CUSTOMER_INTERVAL_TIME。 

源码如下： 

Java代码  

package cn.itcast.bankqueue;  

 

/*每个普通窗口服务一个客户的平均时间为5秒，一共有4个这样的窗口，也就是说银行的所有普通窗口合起来 

 * 平均1.25秒内可以服务完一个普通客户，再加上快速窗口和VIP窗口也可以服务普通客户，所以， 

 * 1秒钟产生一个普通客户比较合理，*/  

 

public class Constants {  

    public static int MAX_SERVICE_TIME = 10000; //10秒！  

    public static int MIN_SERVICE_TIME = 1000; //1秒！  

 

    public static int COMMON_CUSTOMER_INTERVAL_TIME = 1;      

}