黑马程序员-银行模拟

最新推荐文章于 2013-09-12 21:27:08 发布
最新推荐文章于 2013-09-12 21:27:08 发布
阅读量500 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yumengli168/article/details/9074381
版权

 

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

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

本系统一共要产生三个号码管理器对象，各自管理一类用户的排队号码。这三个号码管理器对象统一由一个号码机器进行管理，这个号码机器在整个系统中始终只能有一个，所以，它要被设计成单例。

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

 

NumberManager类
定义一个用于存储上一个客户号码的成员变量和用于存储所有等待服务的客户号码的队列集合

 

 

Java代码 复制代码  收藏代码
  1. public class NumberManager {   
  2.     private int lastNumber=1;   
  3.     private List<Integer> queueNumber=new ArrayList<Integer>();   
  4.     public synchronized Integer generateNewManager(){   
  5.         queueNumber.add(lastNumber);   
  6.         return lastNumber++;   
  7.     }   
  8.     public synchronized Integer fetchServiceNumber(){   
  9.         Integer number=null;   
  10.         if(queueNumber.size()>0){   
  11.         number= queueNumber.remove(0);    
  12.         }   
  13.         return number;   
  14.     }   
  15. }  
public class NumberManager {
	private int lastNumber=1;
	private List<Integer> queueNumber=new ArrayList<Integer>();
	public synchronized Integer generateNewManager(){
		queueNumber.add(lastNumber);
		return lastNumber++;
	}
	public synchronized Integer fetchServiceNumber(){
		Integer number=null;
		if(queueNumber.size()>0){
		number= queueNumber.remove(0); 
		}
		return number;
	}
}

 

 

 

 

NumberMachine类
定义三个成员变量分别指向三个NumberManager对象，分别表示普通、快速和VIP客户的号码管理器，定义三个对应的方法来返回这三个NumberManager对象。

 

Java代码 复制代码  收藏代码
  1. public class NumberMachine {   
  2.     private NumberManager commonManager=new NumberManager();   
  3.     private NumberManager vipManager=new NumberManager();   
  4.     private NumberManager expressManager=new NumberManager();   
  5.        
  6.     public NumberManager getCommonManager() {   
  7.         return commonManager;   
  8.     }   
  9.     public NumberManager getVipManager() {   
  10.         return vipManager;   
  11.     }   
  12.     public NumberManager getExpressManager() {   
  13.         return expressManager;   
  14.     }   
  15.     private NumberMachine(){}   
  16.     private static NumberMachine instance=new NumberMachine();   
  17.     public static NumberMachine getInstance(){   
  18.         return instance;   
  19.     }   
  20.        
  21. }  
public class NumberMachine {
	private NumberManager commonManager=new NumberManager();
	private NumberManager vipManager=new NumberManager();
	private NumberManager expressManager=new NumberManager();
	
	public NumberManager getCommonManager() {
		return commonManager;
	}
	public NumberManager getVipManager() {
		return vipManager;
	}
	public NumberManager getExpressManager() {
		return expressManager;
	}
	private NumberMachine(){}
	private static NumberMachine instance=new NumberMachine();
	public static NumberMachine getInstance(){
		return instance;
	}
	
}

 

 

 

CustomerType枚举类
系统中有三种类型的客户，所以用定义一个枚举类，其中定义三个成员分别表示三种类型的客户

 

Java代码 复制代码  收藏代码
  1. public enum CustomerType {   
  2.     COMMON,EXPRESS,VIP;   
  3.        
  4.     public String toString(){   
  5.         switch(this){   
  6.         case COMMON:   
  7.             return "普通";   
  8.         case EXPRESS:   
  9.             return "快速";   
  10.         case VIP:   
  11.             return "VIP";   
  12.         }   
  13.         return null;   
  14.     }   
  15. }  
public enum CustomerType {
	COMMON,EXPRESS,VIP;
	
	public String toString(){
		switch(this){
		case COMMON:
			return "普通";
		case EXPRESS:
			return "快速";
		case VIP:
			return "VIP";
		}
		return null;
	}
}

 

 

 

ServiceWindow类
定义一个start方法，内部启动一个线程，根据服务窗口的类别分别循环调用三个不同的方法。

 

Java代码 复制代码  收藏代码
  1. public class ServiceWindow {   
  2.     private CustomerType type=CustomerType.COMMON;   
  3.     private int windowId=1;   
  4.        
  5.     public void setType(CustomerType type) {   
  6.         this.type = type;   
  7.     }   
  8.     public void setWindowId(int windowId) {   
  9.         this.windowId = windowId;   
  10.     }   
  11.        
  12.     public void start(){   
  13.         Executors.newSingleThreadExecutor().execute(   
  14.                 new Runnable(){   
  15.                     public void run(){   
  16.                         while(true){   
  17.                             //NumberMachine.getInstance().getCommonManager();  
  18.                         switch(type){   
  19.                         case COMMON:   
  20.                             commonService();   
  21.                         case EXPRESS:   
  22.                             expressService();   
  23.                         case VIP:   
  24.                             vipService();   
  25.                         }   
  26.                         }   
  27.                     }   
  28.                 }   
  29.         );   
  30.     }   
  31.        
  32.     private void commonService(){   
  33.         String windowName="第"+windowId+"号"+type+"窗口";   
  34.         System.out.println(windowName+"正在取号");   
  35.         Integer number=NumberMachine.getInstance().getCommonManager().fetchServiceNumber();   
  36.         if(number!=null){   
  37.             System.out.println(windowName+"为第"+number+"个普通客户服务");   
  38.             long beginTime=System.currentTimeMillis();   
  39.             int maxRandom=Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;   
  40.             long serverTime=new Random().nextInt(maxRandom) +1+Constants.MIN_SERVICE_TIME;   
  41.             try {   
  42.                 Thread.sleep(serverTime);   
  43.             } catch (InterruptedException e) {   
  44.                 e.printStackTrace();   
  45.             }   
  46.             long costTime=System.currentTimeMillis()-beginTime;   
  47.             System.out.println(windowName+"为第"+number+"个普通客户完成服务，耗时"+costTime/1000+"秒");   
  48.                
  49.         }else{   
  50.             System.out.println("没有取到任务，先休息一秒钟!");   
  51.             try {   
  52.                 Thread.sleep(1000);   
  53.             } catch (InterruptedException e) {   
  54.                 e.printStackTrace();   
  55.             }   
  56.         }   
  57.     }   
  58.        
  59.     private void expressService(){   
  60.             String windowName="第"+windowId+"号"+type+"窗口";   
  61.             System.out.println(windowName+"正在取号");   
  62.             Integer number=NumberMachine.getInstance().getExpressManager().fetchServiceNumber();   
  63.             if(number!=null){   
  64.                 System.out.println(windowName+"为第"+number+"个"+type+"客户服务");   
  65.                 long beginTime=System.currentTimeMillis();   
  66.                 //int maxRandom=Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;  
  67.                 //long serverTime=new Random().nextInt(maxRandom) +1+Constants.MIN_SERVICE_TIME;  
  68.                    
  69.                 try {   
  70.                     Thread.sleep(Constants.MIN_SERVICE_TIME);   
  71.                 } catch (InterruptedException e) {   
  72.                     e.printStackTrace();   
  73.                 }   
  74.                 long costTime=System.currentTimeMillis()-beginTime;   
  75.                 System.out.println(windowName+"为第"+number+"个"+type+"客户完成服务，耗时"+costTime/1000+"秒");   
  76.                    
  77.             }else{   
  78.                 System.out.println(windowName+"没有取到任务!");   
  79.                 commonService();   
  80.             }   
  81.     }   
  82.        
  83.     private void vipService(){   
  84.         String windowName="第"+windowId+"号"+type+"窗口";   
  85.         System.out.println(windowName+"正在取号");   
  86.         Integer number=NumberMachine.getInstance().getVipManager().fetchServiceNumber();   
  87.         if(number!=null){   
  88.             System.out.println(windowName+"为第"+number+"个"+type+"客户服务");   
  89.             long beginTime=System.currentTimeMillis();   
  90.             int maxRandom=Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;   
  91.             long serverTime=new Random().nextInt(maxRandom) +1+Constants.MIN_SERVICE_TIME;   
  92.             try {   
  93.                 Thread.sleep(serverTime);   
  94.             } catch (InterruptedException e) {   
  95.                 e.printStackTrace();   
  96.             }   
  97.             long costTime=System.currentTimeMillis()-beginTime;   
  98.             System.out.println(windowName+"为第"+number+"个"+type+"客户完成服务，耗时"+costTime/1000+"秒");   
  99.                
  100.         }else{   
  101.             System.out.println(windowName+"没有取到任务!");   
  102.             commonService();   
  103.         }   
  104.     }   
  105. }  
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){
							//NumberMachine.getInstance().getCommonManager();
						switch(type){
						case COMMON:
							commonService();
						case EXPRESS:
							expressService();
						case VIP:
							vipService();
						}
						}
					}
				}
		);
	}
	
	private void commonService(){
		String windowName="第"+windowId+"号"+type+"窗口";
		System.out.println(windowName+"正在取号");
		Integer number=NumberMachine.getInstance().getCommonManager().fetchServiceNumber();
		if(number!=null){
			System.out.println(windowName+"为第"+number+"个普通客户服务");
			long beginTime=System.currentTimeMillis();
			int maxRandom=Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;
			long serverTime=new Random().nextInt(maxRandom) +1+Constants.MIN_SERVICE_TIME;
			try {
				Thread.sleep(serverTime);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			long costTime=System.currentTimeMillis()-beginTime;
			System.out.println(windowName+"为第"+number+"个普通客户完成服务，耗时"+costTime/1000+"秒");
			
		}else{
			System.out.println("没有取到任务，先休息一秒钟!");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	private void expressService(){
			String windowName="第"+windowId+"号"+type+"窗口";
			System.out.println(windowName+"正在取号");
			Integer number=NumberMachine.getInstance().getExpressManager().fetchServiceNumber();
			if(number!=null){
				System.out.println(windowName+"为第"+number+"个"+type+"客户服务");
				long beginTime=System.currentTimeMillis();
				//int maxRandom=Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;
				//long serverTime=new Random().nextInt(maxRandom) +1+Constants.MIN_SERVICE_TIME;
				
				try {
					Thread.sleep(Constants.MIN_SERVICE_TIME);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				long costTime=System.currentTimeMillis()-beginTime;
				System.out.println(windowName+"为第"+number+"个"+type+"客户完成服务，耗时"+costTime/1000+"秒");
				
			}else{
				System.out.println(windowName+"没有取到任务!");
				commonService();
			}
	}
	
	private void vipService(){
		String windowName="第"+windowId+"号"+type+"窗口";
		System.out.println(windowName+"正在取号");
		Integer number=NumberMachine.getInstance().getVipManager().fetchServiceNumber();
		if(number!=null){
			System.out.println(windowName+"为第"+number+"个"+type+"客户服务");
			long beginTime=System.currentTimeMillis();
			int maxRandom=Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;
			long serverTime=new Random().nextInt(maxRandom) +1+Constants.MIN_SERVICE_TIME;
			try {
				Thread.sleep(serverTime);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			long costTime=System.currentTimeMillis()-beginTime;
			System.out.println(windowName+"为第"+number+"个"+type+"客户完成服务，耗时"+costTime/1000+"秒");
			
		}else{
			System.out.println(windowName+"没有取到任务!");
			commonService();
		}
	}
}

 

Constants类
定义三个常量：MAX_SERVICE_TIME、MIN_SERVICE_TIME、COMMON_CUSTOMER_INTERVAL_TIME

 

 

Java代码 复制代码  收藏代码
  1. public class Constants {   
  2.     public static int MAX_SERVICE_TIME=10000;   
  3.     public static int MIN_SERVICE_TIME=1000;   
  4.     public static int COMMON_CUSTOMER_INTERVAL_TIME=1;   
  5. }  
public class Constants {
	public static int MAX_SERVICE_TIME=10000;
	public static int MIN_SERVICE_TIME=1000;
	public static int COMMON_CUSTOMER_INTERVAL_TIME=1;
}

 

MainClass类
用for循环创建出4个普通窗口，再创建出1个快速窗口和一个VIP窗口。
接着再创建三个定时器，分别定时去创建新的普通客户号码、新的快速客户号码、新的VIP客户号码。

 

 

Java代码 复制代码  收藏代码
  1. public class MainClass {   
  2.     public static void main(String[] args) {   
  3.            
  4.         for(int i=1;i<5;i++){   
  5.         ServiceWindow commonWindow=new ServiceWindow();   
  6.         commonWindow.setWindowId(i);   
  7.         commonWindow.start();   
  8.         }   
  9.            
  10.         ServiceWindow expressWindow=new ServiceWindow();   
  11.         expressWindow.setType(CustomerType.EXPRESS);   
  12.         expressWindow.start();   
  13.            
  14.         ServiceWindow vipWindow=new ServiceWindow();   
  15.         vipWindow.setType(CustomerType.VIP);   
  16.         vipWindow.start();   
  17.            
  18.         Executors.newScheduledThreadPool(1).scheduleAtFixedRate(   
  19.                 new Runnable(){   
  20.                     public void run(){   
  21.                         Integer number=NumberMachine.getInstance().getCommonManager().generateNewManager();   
  22.                         System.out.println(number+"号普通客户等待服务！");   
  23.                     }   
  24.                 },    
  25.                 0,    
  26.                 Constants.COMMON_CUSTOMER_INTERVAL_TIME,    
  27.                 TimeUnit.SECONDS);   
  28.         Executors.newScheduledThreadPool(1).scheduleAtFixedRate(   
  29.                 new Runnable(){   
  30.                     public void run(){   
  31.                         Integer number=NumberMachine.getInstance().getExpressManager().generateNewManager();   
  32.                         System.out.println(number+"号快速客户等待服务！");   
  33.                     }   
  34.                 },    
  35.                 0,    
  36.                 Constants.COMMON_CUSTOMER_INTERVAL_TIME *2,    
  37.                 TimeUnit.SECONDS);   
  38.            
  39.         Executors.newScheduledThreadPool(1).scheduleAtFixedRate(   
  40.                 new Runnable(){   
  41.                     public void run(){   
  42.                         Integer number=NumberMachine.getInstance().getVipManager().generateNewManager();   
  43.                         System.out.println(number+"号VIP客户等待服务！");   
  44.                     }   
  45.                 },    
  46.                 0,    
  47.                 Constants.COMMON_CUSTOMER_INTERVAL_TIME *6,    
  48.                 TimeUnit.SECONDS);   
  49.            
  50.     }   
  51. }  
public class MainClass {
	public static void main(String[] args) {
		
		for(int i=1;i<5;i++){
		ServiceWindow commonWindow=new ServiceWindow();
		commonWindow.setWindowId(i);
		commonWindow.start();
		}
		
		ServiceWindow expressWindow=new ServiceWindow();
		expressWindow.setType(CustomerType.EXPRESS);
		expressWindow.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().generateNewManager();
						System.out.println(number+"号普通客户等待服务！");
					}
				}, 
				0, 
				Constants.COMMON_CUSTOMER_INTERVAL_TIME, 
				TimeUnit.SECONDS);
		Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
				new Runnable(){
					public void run(){
						Integer number=NumberMachine.getInstance().getExpressManager().generateNewManager();
						System.out.println(number+"号快速客户等待服务！");
					}
				}, 
				0, 
				Constants.COMMON_CUSTOMER_INTERVAL_TIME *2, 
				TimeUnit.SECONDS);
		
		Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
				new Runnable(){
					public void run(){
						Integer number=NumberMachine.getInstance().getVipManager().generateNewManager();
						System.out.println(number+"号VIP客户等待服务！");
					}
				}, 
				0, 
				Constants.COMMON_CUSTOMER_INTERVAL_TIME *6, 
				TimeUnit.SECONDS);
		
	}
}

 

serf
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
黑马程序员-Qt讲义.pdf
06-05
Qt是一个跨平台的C++图形用户界面应用程序框架，由挪威的奇趣科技开发，最早于1991年发布。它的主要优点是能够开发出具有良好用户体验的图形界面，并且支持多种平台，包括Windows、Linux、Mac OS X以及嵌入式系统等...
黑马程序员-Java语言进阶-源码、教程笔记.zip
12-16
day01_Object类、常用API day02_Collection、泛型 day03_List、Set、数据结构、Collections day04_Map，斗地主案例 day05_异常，线程 day06_线程、同步 day07_等待与唤醒案例、线程池、Lambda表达式 ...
黑马程序员--银行管理系统
11-25
模拟实现银行业务调度系统逻辑，具体需求如下： 1.银行内有6个业务窗口，1 - 4号窗口为普通窗口，5号窗口为快速窗口，6号窗口为VIP窗口。 2.有三种对应类型的客户：VIP客户，普通客户，快速客户（办理如交水电费、...
黑马程序员-SpringCloud-学习笔记01-认识微服务
06-18
黑马程序员-SpringCloud-学习笔记01-认识微服务
黑马程序员-SpringCloud-学习笔记-03-Eureka注册中心
06-18
黑马程序员-SpringCloud-学习笔记-03-Eureka注册中心
java中静态的代码块，静态变量，静态方法
yumengli168的专栏
08-04 6274
简单了解一下java虚拟机--jvm几个内存区域： 方法区：在java的虚拟机中有一块专门用来存放已经加载的类信息、常量、静态变量以及方法代码的内存区域， 常量池：常量池是方法区的一部分，主要用来存放常量和类中的符号引用等信息。 堆区：用于存放类的对象实例。 栈区：也叫java虚拟机栈，是由一个一个的栈帧组成的后进先出的栈式结构，栈桢中存放方法运行时产生的局部变量、方法出口等信息。
题目
yumengli168的专栏
06-14 2439
1、 一个ArrayList对象aList中存有若干个字符串元素，现欲遍历该ArrayList对象，删除其中所有值为"abc"的字符串元素，请用代码实现。 2、 自定义枚举 Week 用于表示星期，Mon,Tue，Wed...要求每个枚举值都有toLocaleString 方法，用于获得枚举所表示的星期的中文格式 星期一、星期二、星期三... 3、 方法中的内部
面试题-10
yumengli168的专栏
06-15 2062
题目： 10、 28人买可乐喝，3个可乐瓶盖可以换一瓶可乐，那么要买多少瓶可乐，够28人喝？假如是50人，又需要买多少瓶可乐？（需写出分析思路）   题目：   package com.itheima; import org.junit.Test; /**  * date :  Jun 14, 2013  *  * time :  8:32:51 PM  *  * auth
面试题-09
yumengli168的专栏
06-15 1956
题目： 9、 在一个类中编写一个方法，这个方法搜索一个字符数组中是否存在某个字符，如果存在，则返回这个字符在字符数组中第一次出现的位置（序号从0开始计算），否则，返回-1。要搜索的字符数组和字符都以参数形式传递传递给该方法，如果传入的数组为null，应抛出IllegalArgumentException异常。在类的main方法中以各种可能出现的情况测试验证该方法编写得是否正确，例如，字符不存在，
面试题-08
yumengli168的专栏
06-15 1236
题目： 8、 编写一个类，增加一个实例方法用于打印一条字符串。并使用反射手段创建该类的对象， 并调用该对象中的方法。   代码：   package com.itheima; import java.lang.reflect.Constructor; import java.lang.reflect.Method; import org.junit.Test; /**  * d
面试题-06
yumengli168的专栏
06-15 1174
题目： 6、 定义一个文件输入流，调用read(byte[] b)方法将exercise.txt文件中的所有内容打印出来(byte数组的大小限制为5，不考虑中文编码问题)。   代码： package com.itheima; import java.io.File; import java.io.FileInputStream; import java.io.IOException
面试题-05
yumengli168的专栏
06-15 1091
题目： 5、 定义一个标准的JavaBean，名叫Person，包含属性name、age。使用反射的方式创建一个实例、调用构造函数初始化name、age，使用反射方式调用setName方法对名称进行设置，不使用setAge方法直接使用反射方式对age赋值。   代码：   package com.itheima; /**  * date :  Jun 14, 2013  *  *
面试题_01
yumengli168的专栏
06-15 1087
题目： 1、 一个ArrayList对象aList中存有若干个字符串元素，现欲遍历该ArrayList对象，删除其中所有值为"abc"的字符串元素，请用代码实现。 代码： import java.util.ArrayList; import org.junit.Test; /**  * date :  Jun 14, 2013  *  * time :  7:25:34 PM
面试题-07
yumengli168的专栏
06-15 1008
题目： 7、 已知文件a.txt文件中的内容为“bcdeadferwplkou”，请编写程序读取该文件内容，并按照自然顺序排序后输出到b.txt文件中。即b.txt中的文件内容应为“abcd…………..”这样的顺序。   代码：   package com.itheima; import java.io.*; import java.util.Arrays; import org.
面试题-04
yumengli168的专栏
06-15 976
题目： 4、 假如我们在开发一个系统时需要对员工进行建模，员工包含 3 个属性：姓名、工号以及工资。经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。   代码：   /**  * date :  Jun 14, 2013  *  * time :  7:42:49 PM  *  * author
面试题-02
yumengli168的专栏
06-15 896
import org.junit.Test; /**  * date :  Jun 14, 2013  *  * time :  7:32:21 PM  *  * author : Spole  *  */ /**  * 题目：  * 2、 自定义枚举 Week 用于表示星期，  * Mon,Tue，Wed...  * 要求每个枚举值都有toLocaleString 方法
一个面试题。。。
yumengli168的专栏
09-12 847
面试题。。。
黑马程序员-java基础_枚举和反射
yumengli168的专栏
06-11 786
------- android培训、java培训、期待与您交流！ ---------- 反射： Class 这个类代表内存中的一份字节码， 得到类的字节码有三种方式： 如：类名.class——Class c1=Date.class 对象.getClass()——new Date().getClass();       反射Class.forName("类名")—— 用Clas
面试题-03
yumengli168的专栏
06-15 752
题目： 方法中的内部类能不能访问方法中的局部变量，  为什么？ 答：   内部类的生命周期和方法中的局部变量是不一样的，   内部类是也是一个类，是存储在堆中，   也只有当对该类的引用消失时，内部类才会消亡。   而方法的局部变量是存储在堆栈中的，当调用结束时就会退栈，   即在内存中这个属性就消失了。   也就是说，内部类的生命周期超过了方法中局部变量的生命周期，   内部
黑马程序员讲义-C++核心编程pdf
最新发布
09-07
黑马程序员讲义-C核心编程的PDF是程序员讲义的第三阶段的讲义，它包含了关于C语言的内容。你可以通过引用来获取这个PDF的具体内容。<span class="em">1</span><span class="em">2</span><span class="em">3</span>...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值