五、今日内容介绍

1、方法基础知识

2、方法高级内容

3、方法案例

01方法的概述

  1. * A: 为什么要有方法
  2. 	* 提高代码的复用性
  3. * B: 什么是方法
  4. 	* 完成特定功能的代码块。

02方法的定义格式

  1. * A: 方法的格式
  2. *
  3. 		修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
  4. 			方法体语句;
  5. 			return 返回值;
  6. 		}
  7. * B: 方法的格式说明
  8. 	* 修饰符：目前就用 public static。后面我们再详细的讲解其他的修饰符。
  9. 	* 返回值类型：就是功能结果的数据类型。
  10. 	* 方法名：符合命名规则即可。方便我们的调用。
  11. 	* 参数：
  12. 		* 实际参数：就是实际参与运算的。
  13. 		* 形式参数；就是方法定义上的，用于接收实际参数的。
  14. 	* 参数类型：就是参数的数据类型
  15. 	* 参数名：就是变量名
  16. 	* 方法体语句：就是完成功能的代码。
  17. 	* return：结束方法的。
  18. 	* 返回值：就是功能的结果，由return带给调用者。

03定义方法计算面积

  1. * A: 定义方法计算面积
  2. 	public class MethodDemo{
  4. 		public static void main(String[] args){
  5. 			 //调用方法, 方法执行起来
  6. 			 // 在方法main中,调用方法 getArea
  8. 			 int area = getArea(5,6);
  9. 			 System.out.println("面积是: "+area);
  11. 		}
  12. 		/*
  13. 		   要求: 计算一个长方形的面积
  14. 		   定义方法解决这个要求
  15. 		   分析方法定义过程:
  16. 		      1.明确方法计算后的结果的数据类型 int  定义格式对应的就是返回值类型
  17. 			  2.方法计算过程中,有没有未知的数据, 宽和长, 未知数据的数据类型 int
  18. 			      未知数的变量,定义在方法的小括号内
  19. 		*/
  20. 		public static int  getArea(int w, int h){
  21. 			//实现方法的功能主体
  22. 			//int area = w * h;
  23. 			return w * h;
  24. 		}
  25. 	}

04调用方法

  1. * A: 调用方法
  2. 	* a: 在main函数中调用方法，让方法执行起来
  3. 	* b: 方法的形参
  4. 		* 方法要什么参数我们就给什么类型的参数。
  5. 	* c: 方法的返回值
  6. 		* 方法返回什么类型的值我们就用对应的数据类型的变量来接收

05调用方法执行流程

  1. * A: 调用方法执行流程
  2. 	* a: 方法的定义是没有顺序的，写在main函数的上边或者下边都可以。
  3. 	* b: 方法的执行，是把实参传递给形参，从而来执行的。
  4. 	* c: 方法只有被调用才会执行。

06方法调用的内存图

  1. * A: 方法调用的内存图
  2. 	* a: 参见\day05\day05(Java基础语法)\day05_source\方法内存图.JPG

07方法调用的练习

  1. * A: 案例代码
  2. 	/*
  3. 	   方法的定义练习
  4. 	*/
  5. 	import java.util.Scanner;
  6. 	public class MethodDemo_1{
  7. 		public static void main(String[] args){
  8. 			//printRect();
  9. 			//int number = getNumber();
  10. 			//System.out.println(getNumber());
  11. 			//printRect2(3,5);
  12. 			double avg = getAvg(2,2,3);
  13. 			System.out.println(avg);
  14. 		}
  16. 		/*
  17. 		   定义有返回值有参数方法，如求三个数的平均值
  18. 		   明确方法计算后的数据类型, 返回值类型 double
  19. 		   明确方法未知数, 三个未知的整数
  20. 		*/
  21. 		public static double getAvg(double a, double b,double c){
  22. 			 return (a+b+c)/3;
  23. 		}
  25. 		/*
  26. 		    定义无返回值有参数方法，如打印指定M行，每行N个*号的矩形
  27. 			明确方法计算后结果,控制台输出图形,没有返回值的
  28. 			方法中有没有未知数,图形行数,和列数,是未知的, 数据类型整数int
  29. 		*/
  30. 		public static void printRect2(int m,int n){
  31. 			for(int i = 0 ; i < m ; i++){
  32. 				for(int j = 0 ; j < n ;  j++){
  33. 					System.out.print("*");
  34. 				}
  35. 				System.out.println();
  36. 			}
  37. 		}
  39. 		/*
  40. 		   定义有返回值无参数方法，如键盘录入得到一个整数
  41. 		   明确方法计算后结果的数据类型 int
  42. 		   明确有没有未知数,没
  43. 		*/
  44. 		public static int getNumber(){
  45. 			Scanner sc = new Scanner(System.in);
  46. 			//int number = sc.nextInt();
  47. 			return sc.nextInt();
  48. 		}
  50. 		/*
  51. 		   定义无返回值无参数方法，如打印3行，每行3个*号的矩形
  52. 		   为什么没有返回值:
  53. 		       打印矩形 ,输出效果,不需要将结果返回
  54. 			   明确未知数: 不需要未知数
  55. 		*/
  56. 		public static void printRect(){
  57. 			for(int i = 0 ; i < 3 ; i++){
  58. 				for(int j = 0 ; j < 3 ;j++){
  59. 					System.out.print("*");
  60. 				}
  61. 				System.out.println();
  62. 			}
  63. 		}
  64. 	}

08方法的定义和使用的注意事项

  1. * A: 方法的定义和使用的注意事项
  2. 	* a: 方法不能定义在另一个方法的里面
  3.  	* b: 写错方法名字
  4. 	* c: 写错了参数列表
  5. 	* d: 方法返回值是void,方法中可以省略return 不写
  6. 	     return 下面不能有代码
  7. 	* e 方法返回值类型,和return 后面数据类型必须匹配
  8. 	* f: 方法重复定义问题
  9. 	* g: 调用方法的时候,返回值是void, 不能写在输出语句中

09方法的重载

  1. * A: 方法的重载
  2. 	* 在同一个类中，方法名相同，参数列表不同。与返回值类型无关。
  4. 	* 参数列表不同：
  5. 		* A:参数个数不同
  6. 		* B:参数类型不同
  7. 		* C:参数的顺序不同(算重载,但是在开发中不用)
  9. * B: 案例代码
  10. 	public static int getSum(int a,int b){
  11. 		System.out.println("两个int参数");
  12. 		return a+b;
  13. 	}
  14. 	public static int getSum(int a,int b,int c){
  15. 		System.out.println("三个int参数");
  16. 		return a+b+c;
  17. 	}
  18. 	public static double getSum(double a,double b){
  19. 		System.out.println("两个double参数");
  20. 		return a+b;
  21. 	}

​

10方法重载注意事项

​ * A: 方法重载注意事项

​ * a: 参数列表必须不同

​ * b: 重载和参数变量名无关

​ * c: 重载和返回值类型无关

​ * d: 重载和修饰符无关

​ * e: 技巧: 重载看方法名和参数列表

​

​

11方法参数是基本数据类型

​ * A: 方法参数是基本数据类型

​ * a: 方法参数是基本类型时，传递的是值。

12方法参数是引用数据类型

  1. * A: 方法参数是引用数据类型
  2. 	* a: 方法参数是引用类型时，传递的是内存地址值。

​

13随机点名器

​ * A: 案例代码

​ /*

​ 实现随机点名器

​ 1.存储所有学生姓名

​ 2.预览所有学生姓名,遍历数组

​ 3.随机数作为索引,到数组中找元素

​

  1. 		将功能独立出来, 作成方法,调用方法即可
  3. 		定义三个功能, 用到同一个姓名数据
  4. 		姓名存储到数组中,三个方法,使用一个数组中的数据, 方法传递参数
  5. 	*/
  6. 	import java.util.Random;
  7. 	public class CallName{
  8. 		public static void main(String[] args){
  9. 			//定义数组,存储学生姓名
  10. 			String[] names = new String[8];
  11. 			//调用添加姓名方法
  12. 			addStudent(names);
  13. 			//调用遍历数组方法
  14. 			printStudentName(names);
  15. 			//调用随机姓名的方法
  16. 			String name = randomStudentName(names);
  17. 			System.out.println(name);
  18. 		}
  19. 		/*
  20. 		  定义方法,随机数,做索引,数组中找到学生姓名
  21. 		  返回值?  学生姓名
  22. 		  参数?  数组
  23. 		*/
  24. 		public static String randomStudentName(String[] names){
  25. 			Random ran = new Random();
  26. 			int index = ran.nextInt(names.length);
  27. 			return names[index];
  28. 		}
  30. 		/*
  31. 		   定义方法,遍历数组
  32. 		   返回值? 没有
  33. 		   参数? 数组
  34. 		*/
  35. 		public static void printStudentName(String[] names){
  36. 			for(int i = 0 ; i < names.length ;i++){
  37. 				System.out.println(names[i]);
  38. 			}
  39. 		}
  41. 		/*
  42. 		   定义方法,实现向数组中添加学生姓名
  43. 		   返回值? 没有,
  44. 		   参数?  参数就是数组
  45. 		*/
  46. 		public static void addStudent(String[] names){
  47. 			names[0] = "张三";
  48. 			names[1] = "李四";
  49. 			names[2] = "王五";
  50. 			names[3] = "李蕾";
  51. 			names[4] = "韩梅梅";
  52. 			names[5] = "小名";
  53. 			names[6] = "老王";
  54. 			names[7] = "小华";
  55. 		}
  56. 	}

14库存案例代码实现_1

  1. * A: 案例代码
  2. 	/*
  3. 	   实现商品的库存管理
  4. 	     功能:
  5. 		    1.展示用户选择功能清单
  6. 			2.根据选择的功能编号,进行不同的操作
  7. 			   A. 展示所有库存
  8. 			   B. 修改库存数量
  10. 		  分析:
  11. 		    1.展示用户清单:
  12. 			   输出语句, 用户输入, 选择功能序号
  13. 			2.根据选择,调用不同的方法
  14. 			    switch语句
  15. 				  case 1 2 3
  17. 			   A  展示库存
  18. 			     将存储商品的数组,遍历
  19. 			   B  修改库存
  21. 				  修改所有的库存数量
  22. 	*/
  23. 	import java.util.Scanner;
  24. 	public class Shopp{
  25. 		public static void main(String[] args){
  27. 		}
  29. 		/*
  30. 		   定义方法,展示所有的库存清单,遍历
  31. 		   返回值,没有
  32. 		   参数, 数组
  33. 		*/
  34. 		public static void printStore(String[] brand,double[] size,double[] price,int[] count){
  35. 			System.out.println("----------商场库存清单----------");
  36. 			System.out.println("品牌型号     尺寸    价格    库存数");
  37. 			//定义变量,计算总库存数,和总价格
  38. 			int totalCount = 0;
  39. 			int totalMoney = 0;
  40. 			//遍历数组,将数组中所有的商品信息打印出来
  41. 			for(int i = 0 ; i < brand.length ; i++){
  42. 				System.out.println(brand[i]+"   "+size[i]+"    "+price[i]+"   "+count[i]);
  43. 				totalCount += count[i];
  44. 				totalMoney += count[i]*price[i];
  45. 			}
  46. 			System.out.println("总库存数: "+totalCount);
  47. 			System.out.println("商品库存总金额: "+totalMoney);
  48. 		}
  50. 		/*
  51. 		  定义方法,实现用户的选择功能,功能的需要返回来
  52. 		  返回值, int
  53. 		  参数, 没有
  54. 		*/
  55. 		public static int chooseFunction(){
  56. 			System.out.println("-------------库存管理------------");
  57. 			System.out.println("1.查看库存清单");
  58. 			System.out.println("2.修改商品库存数量");
  59. 			System.out.println("3.退出");
  60. 			System.out.println("请输入要执行的操作序号：");
  61. 			//接受键盘输入
  62. 			Scanner sc = new Scanner(System.in);
  63. 			int chooseNumber = sc.nextInt();
  64. 			return chooseNumber;
  65. 		}
  66. 	}

15库存案例代码实现_2

  1. * A: 案例代码
  2. 	/*
  3. 	  定义方法,修改所有商品的库存
  4. 	    用户输入1个,修改1个
  5. 		返回值,没有
  6. 		参数, 库存数的数组, 品名数组
  7. 	*/
  8. 	public static void update(String[] brand, int[] count){
  9. 		//遍历数组,遍历到一个,修改一个
  10. 		//接受键盘输入
  11. 		Scanner sc = new Scanner(System.in);
  12. 		//遍历数组
  13. 		for(int i = 0; i < brand.length ; i++){
  14. 			System.out.println("请输入"+brand[i]+"的库存数");
  15. 			//键盘输入,录入库存, 存储到库存的数组中
  16. 			int newCount = sc.nextInt();
  17. 			count[i] = newCount;
  18. 		}
  19. 		//int chooseNumber = sc.nextInt();
  20. 	}

16库存案例代码测试

  1. * A: 案例
  2. 	/*
  3. 	   实现商品的库存管理
  4. 	     功能:
  5. 		    1.展示用户选择功能清单
  6. 			2.根据选择的功能编号,进行不同的操作
  7. 			   A. 展示所有库存
  8. 			   B. 修改库存数量
  10. 		  分析:
  11. 		    1.展示用户清单:
  12. 			   输出语句, 用户输入, 选择功能序号
  13. 			2.根据选择,调用不同的方法
  14. 			    switch语句
  15. 				  case 1 2 3
  17. 			   A  展示库存
  18. 			     将存储商品的数组,遍历
  19. 			   B  修改库存
  21. 				  修改所有的库存数量
  22. 	*/
  23. 	import java.util.Scanner;
  24. 	public class Shopp{
  25. 		public static void main(String[] args){
  26. 			//使用数组,保存商品的信息
  27. 			//品名,尺寸,价格,库存数, 定义5个数组
  28. 			String[] brand = {"MacBookAir","ThinkpadT450"};
  29. 			double[] size = {13.3,15.6};
  30. 			double[] price = {9998.97,6789.56};
  31. 			int[] count = {0,0};
  32. 			while(true){
  33. 				int choose = chooseFunction();
  34. 				switch(choose){
  35. 					case 1:
  36. 					  //调用查看库存清单方法
  37. 					  printStore(brand,size,price,count);
  38. 					break;
  40. 					case 2:
  41. 					  //调用修改库存的方法
  42. 					  update(brand,count);
  43. 					break;
  45. 					case 3:
  46. 					 return ;
  47. 					default:
  48. 					  System.out.println("没有这个功能");
  49. 					break;
  50. 				}
  51. 			}
  52. 		}
  53. 		/*
  54. 		  定义方法,修改所有商品的库存
  55. 		    用户输入1个,修改1个
  56. 			返回值,没有
  57. 			参数, 库存数的数组, 品名数组
  58. 		*/
  59. 		public static void update(String[] brand, int[] count){
  60. 			//遍历数组,遍历到一个,修改一个
  61. 			//接受键盘输入
  62. 			Scanner sc = new Scanner(System.in);
  63. 			//遍历数组
  64. 			for(int i = 0; i < brand.length ; i++){
  65. 				System.out.println("请输入"+brand[i]+"的库存数");
  66. 				//键盘输入,录入库存, 存储到库存的数组中
  67. 				int newCount = sc.nextInt();
  68. 				count[i] = newCount;
  69. 			}
  70. 			//int chooseNumber = sc.nextInt();
  71. 		}
  73. 		/*
  74. 		   定义方法,展示所有的库存清单,遍历
  75. 		   返回值,没有
  76. 		   参数, 数组
  77. 		*/
  78. 		public static void printStore(String[] brand,double[] size,double[] price,int[] count){
  79. 			System.out.println("----------商场库存清单----------");
  80. 			System.out.println("品牌型号     尺寸    价格    库存数");
  81. 			//定义变量,计算总库存数,和总价格
  82. 			int totalCount = 0;
  83. 			int totalMoney = 0;
  84. 			//遍历数组,将数组中所有的商品信息打印出来
  85. 			for(int i = 0 ; i < brand.length ; i++){
  86. 				System.out.println(brand[i]+"   "+size[i]+"    "+price[i]+"   "+count[i]);
  87. 				totalCount += count[i];
  88. 				totalMoney += count[i]*price[i];
  89. 			}
  90. 			System.out.println("总库存数: "+totalCount);
  91. 			System.out.println("商品库存总金额: "+totalMoney);
  92. 		}
  94. 		/*
  95. 		  定义方法,实现用户的选择功能,功能的需要返回来
  96. 		  返回值, int
  97. 		  参数, 没有
  98. 		*/
  99. 		public static int chooseFunction(){
  100. 			System.out.println("-------------库存管理------------");
  101. 			System.out.println("1.查看库存清单");
  102. 			System.out.println("2.修改商品库存数量");
  103. 			System.out.println("3.退出");
  104. 			System.out.println("请输入要执行的操作序号：");
  105. 			//接受键盘输入
  106. 			Scanner sc = new Scanner(System.in);
  107. 			int chooseNumber = sc.nextInt();
  108. 			return chooseNumber;
  109. 		}
  110. 	}

六、今日内容介绍

1、自定义类型的定义及使用

2、自定义类的内存图

3、ArrayList集合的基本功能

4、随机点名器案例及库存案例代码优化

01引用数据类型_类

  1. * A: 数据类型
  2. 	* a: java中的数据类型分为：基本类型和引用类型
  3. * B: 引用类型的分类
  4. 	* a: Java为我们提供好的类，比如说：Scanner,Random等。
  5. 	* b: 我们自己创建的类，按照类的定义标准，可以在类中包含多个方法与属性，来供我们使用。

02自定义类的概述

  1. * A: 自定义类的概述
  2. 	* java代码映射成现实事物的过程就是定义类的过程。
  3. 	* 举例：
  4. 		我们就拿一部手机进行分析，它能用来做什么呢？它可以打电话，上网，聊微信等，这些就是手机所提供的功能，也就是方法；手机也有它的特征，如颜色、尺寸大小、品牌型号等，这些就是手机的特征，也就是属性
  5. 	* 目前，我们只关注类中的属性，类中的方法在面向对象部分再进行学习。

03自定义类的格式

  1. * A: 自定义类的格式
  2. 	* a: 使用类的形式,对现实中的事物进行描述。
  3. 	* b: 事物由方法和属性两部分组成。
  4. 		* 方法: 这个事物具备的功能。
  5. 		* 属性: 这个事物具备的特征。
  6. 	* c: 格式
  7. 		public class 类名{
  8. 			属性定义
  9. 			  修饰符 数据类型 变量名 = 值
  11. 			方法定义
  12. 			  修饰符 返回值类型  方法名(参数列表){
  14. 			  }
  15. 		}

04自定义的手机类

  1. * A: 自定义的手机类
  2. 	* a: 案例代码
  3. 		public class Phone{
  4. 			/*
  5. 			    定义手机的属性
  6. 			*/
  7. 			String color ;
  8. 			String brand ;
  9. 			double size ;
  10. 		}

05测试手机类

  1. * A: 调用方法执行流程
  2. 	* a: 实现引用类型的步骤
  3. 		* 1: 导入包 , 类都是在同一个文件夹,不需要导入包
  4. 		* 2: 创建引用类型的变量
  5. 		* 3: 变量.类型中的功能
  6. 	* b: 案例代码
  7. 		public class TestPhone{
  8. 			public static void main(String[] args){
  9. 				// 2: 创建引用类型的变量
  10. 				Phone p = new Phone();
  11. 				//System.out.println(p);  //输出内存的地址
  13. 		     	//3: 变量.类型中的功能
  14. 				//变量 p.的方式,调用类中的属性
  15. 				//属性就是变量 , 赋值和获取值
  16. 				p.color = "土豪金";
  17. 				p.brand = "爱立信";
  18. 				p.size = 5.0;
  20. 				//获取属性值
  21. 				System.out.println(p.color+"  "+p.brand+"  "+p.size);
  22. 			}
  23. 		}

06自定义类的内存图_1

  1. * A: 自定义类的内存图_1
  2. 	* a: 参见\day06\day06(面向对象\day06_source\对象内存图.JPG

07自定义类的内存图_2

  1. * A: 自定义类的内存图_1
  2. 	* a: 参见\day06\day06(面向对象\day06_source\对象内存图.JPG

08两个引用类型变量内存图

  1. * A: 自定义类的内存图_1
  2. 	* a: 参见\day06\day06(面向对象\day06_source\两个引用变量内存图.JPG

09自定义类的练习

  1. * A: 实体类的代码
  2. 	/*
  3. 	    电饭锅，包含属性（品牌、容量大小、颜色等）
  4. 		定义类,描述事物,电饭锅
  5. 		  属性: 品牌,大小 ,颜色
  7. 		定义类,类名字,电饭锅
  8. 		类的范围,定义三个属性
  9. 	*/
  10. 	public class DianFanGuo{
  11. 		//定义三个属性
  12. 		String brand ;
  13. 	    double size ;
  14. 		String color ;
  15. 	}
  17. 	/*
  18. 	   汽车，包含属性（品牌、排量、类型等）
  19. 	   定义类,类名 Car
  20. 	     属性 品牌 排量 类型
  21. 	 */
  22. 	public class Car{
  23. 		//定义汽车三个属性
  24. 		String brand ;
  25. 		double paiLiang ;
  26. 		String type;
  27. 	}
  29. 	 /*
  30. 	   学生，包含属性（姓名，年龄，性别等）
  31. 	   定义类,类名Student
  32. 	     三个属性: 姓名,年龄,性别 (char)
  33. 	*/
  34. 	public class Student{
  35. 		String name;
  36. 		int age ;
  37. 		char sex ;
  38. 	}
  40. * B: 测试类的代码
  41. 	/*
  42. 	   定义的测试类
  43. 	   同时测试,电饭锅,汽车,学生
  44. 	*/
  45. 	public class Test{
  46. 		public static void main(String[] args){
  47. 			//创建电饭锅引用类型
  48. 			DianFanGuo dfg = new DianFanGuo();
  50. 			dfg.brand = "特斯拉";
  51. 			dfg.color = "红色";
  52. 			dfg.size = 30;
  54. 			System.out.println(dfg.brand+"  "+dfg.color+"  "+dfg.size);
  56. 			//创建汽车引用类型
  57. 			Car c = new Car();
  58. 			c.brand = "巨力";
  59. 			c.type = "拖拉机";
  60. 			c.paiLiang = 0.5;
  62. 			System.out.println(c.brand+"  "+c.type+"  "+c.paiLiang);
  64. 			//创建学生引用类型
  65. 			Student stu = new Student();
  66. 			stu.name = "张三";
  67. 			stu.age = 20;
  68. 			stu.sex = '男';
  69. 			System.out.println(stu.name+"  "+stu.age+"  "+stu.sex);
  71. 		}
  72. 	}

​

10ArrayList创建变量的步骤

​ * A: ArrayList创建变量的步骤

​ * a: 导入包 java.util包中

​ * b: 创建引用类型的变量

​ 数据类型< 集合存储的数据类型> 变量名 = new 数据类型<集合存储的数据类型>();

​ 集合存储的数据类型: 要将数据存储到集合的容器中

​ 创建集合引用变量的时候,必须要指定好,存储的类型是什么

​ * c: 变量名.方法

​ 注意: 集合存储的数据,8个基本类型对应8个引用类型

​ 存储引用类型,不存储基本类型

​

11ArrayList创建变量举例

​ * A: ArrayList创建变量的示例代码

​ import java.util.ArrayList;

​ public class ArrayListDemo{

​ public static void main(String[] args){

​ //创建集合容器,指定存储的数据类型

​ //存储字符串

​ ArrayList array = new ArrayList();

​

  1. 			//创建集合容器,存储整数
  2. 			ArrayList<Integer> array2 = new ArrayList<Integer>();
  4. 			//创建集合容器,存储手机类型
  5. 			ArrayList<Phone> array3 = new ArrayList<Phone>();
  6. 		}
  7. 	}

12ArrayList的常见方法

  1. * A: ArrayList的常见方法
  2. 	* a: add(参数) 向集合中添加元素
  3. 	* b: get(int index) 取出集合中的元素,get方法的参数,写入索引
  4. 	* c: size() 返回集合的长度, 集合存储元素的个数
  5. * B: 案例代码
  6. 	import java.util.ArrayList;
  7. 	public class ArrayListDemo_1{
  8. 		public static void main(String[] args){
  9. 			//定义集合,存储字符串元素
  10. 			ArrayList<String> array = new ArrayList<String>();
  11. 			//调用集合方法add存储元素
  12. 			array.add("abc");
  13. 			array.add("itcast");
  14. 		    array.add("love");
  15. 			array.add("java");
  16. 			//输出集合的长度,调用集合方法size, size方法的返回值类型 int
  17. 			int size = array.size();
  18. 			System.out.println(size);
  20. 			//获取出集合中的一个元素,获取1索引的元素
  21. 			//集合的方法get, 获取元素后结果数据类型
  22. 			String s = array.get(1);
  23. 			System.out.println(s);

​

  1. 			System.out.println(array.get(0));
  2. 			System.out.println(array.get(1));
  3. 			System.out.println(array.get(2));
  4. 			System.out.println(array.get(3));
  5. 		}
  6. 	}

13ArrayList集合的遍历

  1. * A: 案例代码
  2. 	/*
  3. 	   集合的遍历
  4. 	   实现思想也是索引思想
  5. 	   集合的索引从0开始,到 size()-1
  6. 	   方法get(int index)
  7. 	*/
  8. 	import java.util.ArrayList;
  9. 	public class ArrayListDemo_2{
  10. 		public static void main(String[] args){
  11. 			ArrayList<Integer> array = new ArrayList<Integer>();
  12. 			array.add(121);
  13. 			array.add(125);
  14. 			array.add(123);
  15. 			array.add(120);
  16. 			array.add(128);
  18. 			//对集合进行遍历
  19. 			//使用方法 size+get组合进行遍历
  20. 			for(int i = 0 ; i < array.size(); i++){
  21. 				System.out.println( array.get(i) );
  22. 			}
  23. 		}
  24. 	}

14ArrayList补充方法

  1. * A: ArrayList补充方法
  2. 	* a: add(int 索引,存储的元素) 	将元素添加到指定的索引上
  3. 	* b: set(int 索引,修改后的元素) 	将指定索引的元素,进行修改
  4. 	* c: remove(int 索引) 			删除指定索引上的元素
  5. 	* d: clear() 					清空集合中的所有元素
  6. * B: 案例代码
  7. 	import java.util.ArrayList;
  8. 	public class ArrayListDemo_3{
  9. 		public static void main(String[] args){
  11. 			ArrayList<Integer> array = new ArrayList<Integer>();
  12. 			array.add(1);
  13. 			array.add(2);
  14. 			array.add(3);
  15. 			array.add(4);
  17. 			//在索引2上,添加元素7
  18. 			array.add(2,7);
  20. 			//将0索引上的元素,修改成10
  21. 			array.set(0,10);
  23. 			//将4索引上的元素,删除
  24. 			array.remove(4);
  26. 			array.clear();
  28. 			//使用方法 size+get组合进行遍历
  29. 			for(int i = 0 ; i < array.size(); i++){
  30. 				System.out.println( array.get(i) );
  31. 			}
  32. 		}
  33. 	}

15随机点名器案例分析

  1. * A: 随机点名器案例分析
  2. 	全班同学中随机的找出一名同学，打印这名同学的个人信息。
  3. 	我们对本案例进行分析，得出如下分析结果：
  4. 		1.存储全班同学信息（姓名、年龄）
  5. 			将容器换成集合，集合中存的是Student类型
  6. 		2.打印全班同学每一个人的信息（姓名、年龄）
  7. 			 遍历集合
  8. 		3.在班级总人数范围内，随机产生一个随机数，查找该随机数所对应的同学信息（姓名、年龄）
  9. 		随机点名器明确地分为了三个功能。如果将多个独立功能的代码写到一起，则代码相对冗长，我们可以针对不同的功能可以将其封装到一个方法中，将完整独立的功能分离出来。
  10. 		而在存储同学姓名时，如果对每一个同学都定义一个变量进行姓名存储，则会出现过多孤立的变量，很难一次性将全部数据持有。此时，我们采用ArrayList集合来解决多个学生信息的存储问题

16随机点名器代码实现

  1. * A: 随机点名器案例代码
  2. 	/*
  3. 	   随机点名器,集合改进 (学生的姓名和年龄)
  4. 	   现实中有学生这个事物,使用定义类的形式,描述学生事物
  5. 	   属性: 姓名,年龄
  7. 	   姓名存储了数组, 将容器换成是集合
  8. 	   String[] s = {"",""};
  9. 	   集合中,存储的是学生的姓名吗?  应该存储Student类型
  11. 	   存储学生:
  12. 	      学生类型,存储到集合中
  13. 	   总览: 遍历集合
  14. 	   随机: 随机数,作为索引,到集合中找到元素
  15. 	   三个功能,共享的数据,集合容器,
  16. 	   定义三个方法,必须参数传递集合
  17. 	*/
  18. 	import java.util.ArrayList;
  19. 	import java.util.Random;
  20. 	public class CallName{
  21. 		public static void main(String[] args){
  22. 			//定义集合,存储的是StudentName类型变量
  23. 			ArrayList <StudentName> array = new ArrayList<StudentName>();
  24. 			//调用添加方法
  25. 			add (array);
  26. 			//调用遍历集合
  27. 			printArrayList(array);
  29. 			randomStudentName(array);
  30. 		}
  31. 		/*
  32. 		  随机数,当作集合的索引,到集合中找到元素
  33. 		*/
  34. 		public static void randomStudentName(ArrayList<StudentName> array ){
  35. 			Random r = new Random();
  36. 			int number = r.nextInt( array.size());
  37. 			//随机数,索引,到集合中get
  38. 			StudentName s = array.get(number);
  39. 			System.out.println( s.name +"  "+s.age);
  40. 		}
  42. 		/*
  43. 		    总览学生的信息,遍历集合
  44. 		*/
  45. 		public static void printArrayList(ArrayList<StudentName> array){
  46. 			for(int i = 0 ; i < array.size();i++){
  47. 				//存储集合的时候, 集合.add(sn1)  sn1 是StudentName类型变量
  48. 				//获取的时候,集合.get方法,获取出来的是什么, 还是StudentName类型变量
  49. 				StudentName s = array.get(i);
  50. 				System.out.println(s.name+"  "+s.age);
  51. 			}
  52. 		}
  54. 		/*
  55. 		   定义方法,实现存储学生的姓名和年龄
  56. 		   创建StudentName类型变量,存储到集合中
  57. 		*/
  58. 		public static void add (ArrayList<StudentName> array){
  59. 			//创建StudentName类型变量
  60. 			StudentName sn1 = new StudentName();
  61. 			StudentName sn2 = new StudentName();
  62. 			StudentName sn3 = new StudentName();
  63. 			StudentName sn4 = new StudentName();
  64. 			StudentName sn5 = new StudentName();
  66. 			sn1.name = "张三1";
  67. 			sn1.age = 201;
  69. 			sn2.name = "张三2";
  70. 			sn2.age = 202;
  72. 			sn3.name = "张三3";
  73. 			sn3.age = 203;
  75. 			sn4.name = "张三4";
  76. 			sn4.age = 204;
  78. 			sn5.name = "张三5";
  79. 			sn5.age = 205;
  81. 			//将StudentName变量,存储到集合中
  82. 			array.add(sn1);
  83. 			array.add(sn2);
  84. 			array.add(sn3);
  85. 			array.add(sn4);
  86. 			array.add(sn5);
  87. 		}
  88. 	}

17库存案例分析加入集合

  1. * A: 库存案例分析加入集合
  2. 	* a: 参见\day06\day06(面向对象\day06_source\对象内存图.JPG

18库存案例添加商品信息

  1. * A: 案例代码
  2. 	/*
  3. 	   定义,.描述商品的类
  4. 	   商品 4个属性
  5. 	     商品名字  大小     价格    库存
  6. 		  String    double   double  int
  8. 		定义类,类名Goods
  9. 		这个类型的变量,存储到集合中
  10. 	*/
  11. 	public class Goods{
  12. 		//定义商品名字
  13. 		String brand ;
  14. 		//大小属性
  15. 		double size ;
  16. 		// 价格属性
  17. 		double price ;
  18. 		//库存属性
  19. 		int count ;
  20. 	}
  22. 	/*
  23. 	    实现库存管理案例:
  24. 		  1.存储商品信息
  25. 		    存储商品类型变量
  26. 			将商品类型的变量,存储到集合中
  27. 	*/
  28. 	//import java.util.ArrayList;
  29. 	import java.util.*;
  30. 	public class Shopp{
  31. 		public static void main(String[] args){
  32. 			//创建ArrayList集合,存储Goods类型
  33. 			ArrayList<Goods> array = new ArrayList<Goods>();
  34. 			//调用添加商品信息的方法
  35. 			addGoods(array);
  36. 		}
  38. 		/*
  39. 		   定义方法,将商品的信息存储到集合中
  40. 		   集合是所有方法的共享数据,参数传递
  41. 		*/
  42. 		public static void addGoods (ArrayList<Goods> array){
  43. 			//创建商品类型变量 Goods类型的变量
  44. 			Goods g1 = new Goods();
  45. 			Goods g2 = new Goods();
  46. 			g1.brand = "MacBook";
  47. 			g1.size = 13.3;
  48. 			g1.price = 9999.99;
  49. 			g1.count = 3;
  51. 			g2.brand = "Thinkpad";
  52. 			g2.size = 15.6;
  53. 			g2.price = 7999.99;
  54. 			g2.count = 1;
  56. 			//Goods类型的变量,存储到集合中
  57. 			array.add(g1);
  58. 			array.add(g2);
  59. 		}
  60. 	}

19库存案例查看库存清单

  1. * A: 案例代码
  2. 	/*
  3. 	    实现库存管理案例:
  4. 		  1.存储商品信息
  5. 		    存储商品类型变量
  6. 			将商品类型的变量,存储到集合中
  8. 	      2.查看库存清单
  9. 		    将集合进行遍历, 获取出集合中存储的Goods类型变量
  10. 			输出每一个Goods类型的属性
  11. 			计算求和: 总库存,总金额
  12. 	*/
  13. 	//import java.util.ArrayList;
  14. 	import java.util.*;
  15. 	public class Shopp{
  16. 		public static void main(String[] args){
  17. 			//创建ArrayList集合,存储Goods类型
  18. 			ArrayList<Goods> array = new ArrayList<Goods>();
  19. 			//调用添加商品信息的方法
  20. 			addGoods(array);
  21. 		}
  23. 		/*
  24. 		   定义方法,查看库存清单,遍历集合
  25. 		*/
  26. 		public static void printStore(ArrayList<Goods> array){
  27. 			//输出表头
  28. 			System.out.println("----------商场库存清单----------");
  29. 			System.out.println("品牌型号     尺寸    价格    库存数");
  30. 			//定义变量,保存总库存数,和总金额
  31. 			int totalCount = 0 ;
  32. 			double totalMoney = 0;
  33. 			//遍历集合
  34. 			for(int i = 0 ; i < array.size(); i++){
  35. 				//get(索引)获取出集合中的元素,存储的是Goods类,获取的也是Goods类型
  36. 				//使用Goods类型变量,接受get方法结果
  37. 				Goods g = array.get(i);
  38. 				System.out.println(g.brand+"   "+g.size+"    "+g.price+"    "+g.count);
  39. 				totalCount = totalCount+g.count;
  40. 				totalMoney = totalMoney + g.count*g.price;
  41. 			}
  42. 			System.out.println("总库存数: "+totalCount);
  43. 			System.out.println("商品库存总金额: "+totalMoney);
  44. 		}
  46. 		/*
  47. 		   定义方法,将商品的信息存储到集合中
  48. 		   集合是所有方法的共享数据,参数传递
  49. 		*/
  50. 		public static void addGoods (ArrayList<Goods> array){
  51. 			//创建商品类型变量 Goods类型的变量
  52. 			Goods g1 = new Goods();
  53. 			Goods g2 = new Goods();
  54. 			g1.brand = "MacBook";
  55. 			g1.size = 13.3;
  56. 			g1.price = 9999.99;
  57. 			g1.count = 3;
  59. 			g2.brand = "Thinkpad";
  60. 			g2.size = 15.6;
  61. 			g2.price = 7999.99;
  62. 			g2.count = 1;
  64. 			//Goods类型的变量,存储到集合中
  65. 			array.add(g1);
  66. 			array.add(g2);
  67. 		}
  68. 	}

20库存案例修改库存清单及测试代码的实现

  1. * A: 案例代码
  2. 	/*
  3. 	    实现库存管理案例:
  4. 		  1.存储商品信息
  5. 		    存储商品类型变量
  6. 			将商品类型的变量,存储到集合中
  8. 	      2.查看库存清单
  9. 		    将集合进行遍历, 获取出集合中存储的Goods类型变量
  10. 			输出每一个Goods类型的属性
  11. 			计算求和: 总库存,总金额
  13. 	     3.修改商品的库存
  14. 		    集合遍历 ,获取出集合中存储的Goods类型变量
  15. 			变量调用Goods类的属性count,值进行修改 (键盘输入)
  16. 	*/
  17. 	//import java.util.ArrayList;
  18. 	import java.util.*;
  19. 	public class Shopp{
  20. 		public static void main(String[] args){
  21. 			//创建ArrayList集合,存储Goods类型
  22. 			ArrayList<Goods> array = new ArrayList<Goods>();
  23. 			//调用添加商品信息的方法
  24. 			addGoods(array);
  25. 			//进入死循环中
  26. 			while(true){
  27. 				//调用选择功能的方法,获取到用户输入的功能序号
  28. 				int number = chooseFunction();
  29. 				//对序号判断,如果=1 进入查看库存功能  = 2 进入修改库存功能  =3 结束
  30. 				switch(number){
  31. 					case 1:
  32. 					//进入查看库存,调用查看库存的方法,传递存储商品信息的集合
  33. 					printStore(array);
  34. 					break;
  36. 					case 2:
  37. 					//进入修改库存功能,调用修改库存的方法,传递集合
  38. 					update(array);
  39. 					break;
  41. 					case 3:
  42. 					return ;
  44. 					default:
  45. 					 System.out.println("无此功能");
  46. 					 break;
  47. 				}
  48. 			}
  49. 		}
  50. 		/*
  51. 		  方法定义,修改库存
  52. 		  键盘的输入,将Goods中的属性值,修改
  53. 		*/
  54. 		public static void update(ArrayList<Goods> array){
  55. 			Scanner sc = new Scanner(System.in);
  56. 			//遍历集合,获取集合中的每个元素
  57. 			for(int i = 0 ;  i < array.size(); i++){
  58. 				//集合方法get获取的是集合的元素,元素类型Goods
  59. 				Goods g = array.get(i);
  60. 				System.out.println("请输入"+g.brand+"的库存数");
  61. 				//Goods属性,count进行修改
  62. 				g.count = sc.nextInt();
  63. 			}
  64. 		}
  65. 		/*
  66. 		   定义方法,实现选择菜单,用户根据功能选择菜单
  67. 		*/
  68. 		public static int chooseFunction(){
  69. 			System.out.println("-------------库存管理------------");
  70. 			System.out.println("1.查看库存清单");
  71. 			System.out.println("2.修改商品库存数量");
  72. 			System.out.println("3.退出");
  73. 			System.out.println("请输入要执行的操作序号：");
  74. 			Scanner sc = new Scanner(System.in);
  75. 			int number = sc.nextInt();
  76. 			return number;
  77. 		}
  79. 		/*
  80. 		   定义方法,查看库存清单,遍历集合
  81. 		*/
  82. 		public static void printStore(ArrayList<Goods> array){
  83. 			//输出表头
  84. 			System.out.println("----------商场库存清单----------");
  85. 			System.out.println("品牌型号     尺寸    价格    库存数");
  86. 			//定义变量,保存总库存数,和总金额
  87. 			int totalCount = 0 ;
  88. 			double totalMoney = 0;
  89. 			//遍历集合
  90. 			for(int i = 0 ; i < array.size(); i++){
  91. 				//get(索引)获取出集合中的元素,存储的是Goods类,获取的也是Goods类型
  92. 				//使用Goods类型变量,接受get方法结果
  93. 				Goods g = array.get(i);
  94. 				System.out.println(g.brand+"   "+g.size+"    "+g.price+"    "+g.count);
  95. 				totalCount = totalCount+g.count;
  96. 				totalMoney = totalMoney + g.count*g.price;
  97. 			}
  98. 			System.out.println("总库存数: "+totalCount);
  99. 			System.out.println("商品库存总金额: "+totalMoney);
  100. 		}
  102. 		/*
  103. 		   定义方法,将商品的信息存储到集合中
  104. 		   集合是所有方法的共享数据,参数传递
  105. 		*/
  106. 		public static void addGoods (ArrayList<Goods> array){
  107. 			//创建商品类型变量 Goods类型的变量
  108. 			Goods g1 = new Goods();
  109. 			Goods g2 = new Goods();
  110. 			g1.brand = "MacBook";
  111. 			g1.size = 13.3;
  112. 			g1.price = 9999.99;
  113. 			g1.count = 3;
  115. 			g2.brand = "Thinkpad";
  116. 			g2.size = 15.6;
  117. 			g2.price = 7999.99;
  118. 			g2.count = 1;
  120. 			//Goods类型的变量,存储到集合中
  121. 			array.add(g1);
  122. 			array.add(g2);
  123. 		}
  124. 	}

七、今日内容介绍

1、循环练习

2、数组方法练习

01奇数求和练习

  1. * A: 奇数求和练习
  2. 	* a: 题目分析
  3. 		* 为了记录累加和的值，我们需要定义一个存储累加和的变量
  4. 		* 我们要获取到1-100范围内的数
  5. 		* 判断当前数是否为奇数，是奇数，完成累加和操作
  6. 		* 累加完毕后，最终显示下累加和的值
  8. 	* b: 解题步骤
  9. 		* 定义一个用来记录累加和的变量
  10. 		* 使用for循环语句，完成1-100之间每个数的获取
  11. 		* 使用if条件语句，判断当前数是否是奇数，是奇数，进行累加和操作
  12. 		* 使用输出语句，打印累加和变量的值
  14. 	* c: 案例代码
  15. 		public class Test01 {
  16. 			public static void main(String[] args) {
  17. 				int sum = 0;
  18. 				for (int i = 0; i < 100; i++) {
  19. 					if (i%2==1) {
  20. 						sum += i;
  21. 					}
  22. 				}
  23. 				System.out.println("累加和的值 " + sum);
  24. 			}
  25. 		}

02水仙花练习功能实现

  1. * A: 水仙花练习功能实现
  2. 	* a: 题目分析
  3. 		* 明确什么样的数就是水仙花数。水仙花数是指一个3位数（100-999之间），其每位数字立方之和等于该3位数本身。
  4. 			如153 = 1*1*1 + 3*3*3 + 5*5*5，即 3位数本身 = 百位数立方 + 十位数立方 + 个位数立方;
  5. 		* 获取水仙花范围内的所有3位数（100-999之间的每个3位数）
  6. 		* 判断该3位数是否满足水仙花数，满足，打印该3位数
  8. 	* b: 解题步骤
  9. 		* 使用for循环，得到100-999之间的每个3位数
  10. 		* 获取3位数中百位数字、十位数字、个位数字
  11. 		* 使用if条件语句，判断该3位数是否满足水仙花数，满足，使用输出语句，打印该3位数
  13. 	* c: 案例代码
  14. 		public class Test02 {
  15. 			public static void main(String[] args) {
  16. 				for (int i = 100; i < 1000; i++) {
  17. 					int bai = i/100%10;
  18. 					int shi = i/10%10;
  19. 					int ge = i%10;
  21. 					if (i == bai*bai*bai + shi*shi*shi + ge*ge*ge) {
  22. 						System.out.println(i);
  23. 					}
  24. 				}
  25. 			}
  26. 		}

03ASCII编码表

  1. * A: ASCII编码表
  2. 	* a: 英文全称
  3. 		* American Standard Code for Information Interchange，美国标准信息交换代码
  4. 	* b: ASCII编码表由来
  5. 		* 计算机中，所有的数据在存储和运算时都要使用二进制数表示
  6. 		* a、b、c、d这样的52个字母（包括大写）、以及0、1等数字还有一些常用的符号, 在计算机中存储时也要使用二进制数来表示
  7. 		* 具体用哪些二进制数字表示哪个符号，当然每个人都可以约定自己的一套（这就叫编码）
  8. 		* 大家如果要想互相通信而不造成混乱，那么大家就必须使用相同的编码规则，于是美国有关的标准化组织就出台了ASCII编码，
  9. 			统一规定了上述常用符号用哪些二进制数来表示。
  10. 	* c: 中文编码表
  11. 		* GB2312
  12. 		* UNICODE
  13. 	* d: 字符中重要的ASCII码对应关系
  14. 		* a : 97
  15. 		* A : 65
  16. 		* 0 : 48

04char类型的存储

  1. * A: char类型的存储
  2. 	* a: 取值范围
  3. 		* short:占两个字节,是有符号数据,取值范围-32768-32767
  4. 		* char: 占两个字节,是无符号数据,取值范围0-65536
  6. 	* b: 类型转换
  7. 		* char类型的数据参加运算时要线程程int数据类型
  9. 	* c: 案例代码
  10. 		/*
  11. 			ASCII编码表演示
  12. 			字符Java 数据类型,char
  13. 			整数Java 数据类型,int
  15. 			int 类型和 char 数据类型转换
  16. 			char  两个字节, int 四个字节
  18. 			char转成int类型的时候,类型自动提示,char数据类型,会查询编码表,得到整数
  19. 			int转成char类型的时候,强制转换,会查询编码表
  21. 			char存储汉字,查询Unicode编码表
  23. 			char可以和int计算,提示为int类型, 内存中两个字节
  24. 			char取值范围是0-65535, 无符号的数据类型
  25. 		*/
  26. 		public class ASCIIDemo{
  27. 			public static void main(String[] args){
  28. 				char c = 'a';
  29. 				int i = c + 1;
  30. 				System.out.println(i);
  32. 				int j = 90;
  33. 				char h = (char)j;
  34. 				System.out.println(h);
  36. 				System.out.println( (char)6 );
  38. 				char k = '你';
  39. 				System.out.println(k);

​

  1. 				char m = -1;
  2. 			}
  3. 		}

05输出所有英文字母

  1. * A: 输出所有英文字母
  2. 	* a: 题目分析
  3. 		* 一共26个大小写字母，那么，可以考虑循环26次。在每次循环中，完成指定字母的大小写打印
  4. 		* 找出ABCDEFG…XYZ这些字母之间的变化规律
  5. 			通过ASCII表发现，后面的字母比它前面的字母，ASCII值大1
  6. 			下一个字母 = 上一个字母 + 1
  7. 			如： A	B	C	D
  8. 				65	66	67	68
  9. 		* 在每次循环中打印上一个字母大小写，并指定下一个字母
  11. 	* b: 解题步骤
  12. 		* 定义初始化大写变量，值为’A’； 初始化小写变量，值为’a’
  13. 		* 使用for循环，进行26次循环
  14. 		* 在每次循环中，打印大写字母、小写字母。
  15. 			每次打印完成后，更新大写字母值、小写字母值
  17. 	* c: 案例代码
  18. 		public class Test04 {
  19. 			public static void main(String[] args) {
  20. 				char da = 'A';
  21. 				char xiao = 'a';
  22. 				for (int i = 0; i < 26; i++) {
  23. 					System.out.println("大写字母 "+da+" ,小写字母 "+xiao);
  24. 					da++; //更新大写字母值
  25. 					xiao++; //更新小写字母值
  26. 				}
  27. 			}
  28. 		}

0699乘法表的分析

  1. * A: 99乘法表的分析
  2. 	* a: 打印格式
  3. 		1*1=1
  4. 		1*2=2  2*2=4
  5. 		1*3=3  2*3=6  3*3=9
  6. 	* b: 题目分析
  7. 		通过观察发现，如果把1*1=1这样的内容 看做一颗*的话，那么打印结果就成了如下效果：
  8. 		*
  9. 		**
  10. 		***
  11. 		****
  12. 		…
  13. 		这样，就是打印9行星，每行打印星的个数与当前行数相等。
  14. 		再观察“1*3=3 2*3=6 3*3=9”得出它们如下的变化规律：
  15. 				每行第n次 +"*"+ 行号 +"="+ 每行第n次 * 行号
  16. 			如:	1	+"*"+  2    +"="+   1*2; // 相当于1*2=2
  17. 				2	+"*"+  2    +"="+   2*2; // 相当于2*2=4	
  19. 	* c: 解题步骤
  20. 		* 定义一个外层for循环，初始值从1开始，循环9次。用来控制打印的行数
  21. 		* 在外层for循环内部，定义一个for循环，初始值从1开始，循环次数与当前行数相等。用来完成每行打印指定次数的乘法公式 如1*1=1
  22. 		* 在内层for循环中，完成每行指定次数的乘法公式打印 如1*1=1
  23. 			System.out.print(k +"*"+ j +"="+ j*k +"\t");
  24. 			// 变量k代表：每行中的第n次
  25. 			// 变量j代表：行号
  26. 		* 在外循环中，当每行指定次数的乘法公式打印完毕后，通过System.out.println()切换到下一行。
  27. 			这样，再次打印乘法公式时，就在下一行输出打印了

0799乘法表的功能实现

  1. * A: 99乘法表的功能实现
  2. 	* a: 案例代码
  3. 		/*
  4. 			利用嵌套for循环,实现99乘法表示
  5. 			实现步骤:
  6. 			  1. 定义外循环控制行数
  7. 			  2. 内循环控制个数,个数,每次都在递增
  8. 			  3. 循环中输出,乘法表的格式   1*3=3
  9. 		*/
  11. 		public class Test05 {
  12. 			public static void main(String[] args) {
  13. 				for (int j = 1; j < 10; j++) {
  14. 					for (int k = 1; k <= j; k++) {
  15. 						System.out.print(k +"*"+ j +"="+ j*k +"\t");
  16. 					}
  17. 					System.out.println();
  18. 				}
  19. 			}
  20. 		}

​

day07_08(基础语法)实现数组的遍历.avi(14:18)

day07_09(基础语法)数组逆序原理.avi(17:55)

day07_10(基础语法)数组逆序功能实现.avi(9:45)

day07_11(基础语法)选择排序原理.avi(14:01)

day07_12(基础语法)选择排序功能实现.avi(09:07)

day07_13(基础语法)冒泡排序功能实现.avi(16:00)

day07_14(基础语法)数组的折半查找原理.avi(13:15)

day07_15(基础语法)数组的折半查找代码实现.avi(8:23)

08实现数组的遍历

  1. * A: 实现数组的遍历
  2. 	* a: 题目分析
  3. 		* 通过循环，我们可以完成数组中元素的获取，数组名[索引]
  4. 		* 观察发现，每个数组元素之间加入了一个逗号”,”进行分隔；并且，整个数组的前后有一对中括号”[]”包裹数组所有元素。
  6. 	* b: 解题步骤
  7. 		* 使用输出语句完成打印 左边的中括号”[”
  8. 		* 使用循环，输出数组元素值。输出元素值分为两种情况，如下：
  9. 			* 最后一个数组元素，加上一个右边的中括号”]”
  10. 			* 非最后一个数组元素，加上一个逗号”,”
  12. 	* c: 案例代码
  13. 		/*
  14. 			定义方法,实现数组的遍历
  15. 			遍历中,输出结果  [11,33,565,66,78,89]
  16. 			int[] arr = {3,4,45,7};
  17. 			结果包含字符串, [  ]  ,
  18. 			实现步骤:
  19. 			  1. 定义方法实现数组的遍历
  20. 			  2. 先打印[ 中括号
  21. 			  3. 遍历数组
  22. 				输出数组的元素和逗号
  23. 				判断是否遍历到了数组的最后一个元素,如果是最后一个元素,输出]中括号
  24. 		*/
  25. 		public class ArrayMethodTest{
  26. 			public static void main(String[] args){
  27. 				int[] arr = {11,44,55,33,66};
  28. 				printArray(arr);
  30. 				int[] arr2 = {22,88,99,33,66};
  31. 				printArray(arr2);
  33. 			}
  34. 			/*
  35. 			   定义方法,实现功能
  36. 			   返回值: void
  37. 			   方法参数: 数组
  38. 			*/
  39. 			public static void printArray(int[] arr){
  40. 				//输出一半中括号,不要换行打印
  41. 				System.out.print("[");
  42. 				//数组进行遍历
  43. 				for(int i = 0 ; i < arr.length ; i++){
  44. 					//判断遍历到的元素,是不是数组的最后一个元素
  45. 					//如何判断 循环变量 到达 length-1
  46. 					if( i == arr.length-1 ){
  47. 						//输出数组的元素和]
  48. 						System.out.print(arr[i]+"]");
  49. 					}else{
  50. 					//不是数组的最后一个元素,输出数组元素和逗号
  51. 						System.out.print(arr[i]+",");
  52. 					}
  53. 				}
  54. 				System.out.println();
  55. 			}
  56. 		}

09数组逆序原理

  1. * A: 数组逆序原理
  2. 	* a: 题目分析(图解见day07_source/数组的逆序原理.JPG)
  3. 		* 通过观察发现，本题目要实现原数组元素倒序存放操作。即原数组存储元素为{11,22,33,44}，
  4. 			逆序后为原数组存储元素变为{44,33,22,11}。
  5. 		* 通过图解发现，想完成数组元素逆序，其实就是把数组中索引为start与end的元素进行互换。
  6. 		* 每次互换后，start索引位置后移，end索引位置前移，再进行互换
  7. 		* 直到start位置超越了end位置，互换结束，此时，数组元素逆序完成。
  9. 	* b: 解题步骤
  10. 		* 定义两个索引变量start值为0，变量end值为数组长度减去1（即数组最后一个元素索引）
  11. 		* 使用循环，完成数组索引start位置元素与end位置元素值互换。
  12. 		* 在循环换过程中，每次互换结束后，start位置后移1，end位置前移1
  13. 		* 在循环换过程中，最先判断start位置是否超越了end位置，若已超越，则跳出循环

​

10数组逆序功能实现

​ * A：案例代码

​ /*

​ 数组的逆序:

​ 数组中的元素,进行位置上的交换

​ 逆序 不等于 反向遍历

​ 就是数组中最远的两个索引,进行位置交换,实现数组的逆序

​ 使用的是数组的指针思想,就是变量,思想,可以随时变换索引

​ 反转 reverse

​ 实现步骤:

​ 1. 定义方法,实现数组的逆序

​ 2. 遍历数组

​ 实现数组的最远索引换位置

​ 使用临时的第三方变量

​ */

​ public class ArrayMethodTest_1{

​ public static void main(String[] args){

​ int[] arr = {3,5,7,1,0,9,-2};

​ //调用数组的逆序方法

​ reverse(arr);

​ //看到数组的元素,遍历

​ printArray(arr);

​ }

​

  1. 		/*
  2. 		   定义方法,实现数组的逆序
  3. 		   返回值: 没有返回值
  4. 		   参数:   数组就是参数
  5. 		*/
  6. 		public static void reverse(int[] arr){
  7. 			//利用循环,实现数组遍历,遍历过程中,最远端换位
  8. 			//for的第一项,定义2个变量, 最后,两个变量++ --
  9. 			for( int min = 0 , max = arr.length-1 ; min < max  ; min++,max--){
  10. 				//对数组中的元素,进行位置交换
  11. 				//min索引和max索引的元素交换
  12. 				//定义变量,保存min索引
  13. 				int temp = arr[min];
  14. 				//max索引上的元素,赋值给min索引
  15. 				arr[min] =  arr[max];
  16. 				//临时变量,保存的数据,赋值到max索引上
  17. 				arr[max] = temp;
  18. 			}
  19. 		}
  20. 	}

11选择排序原理

  1. * A: 选择排序原理
  2. 	* a: 题目分析(图解见day07_source/选择排序原理.JPG)
  3. 		* 通过观察发现，本题目要实现把数组元素{13,46,22,65,3}进行排序
  4. 		* 提到数组排序，就要进行元素值大小的比较，通过上图发现，我们想完成排序要经过若干次的比较才能够完成。
  5. 		* 上图中用每圈要比较的第一个元素与该元素后面的数组元素依次比较到数组的最后一个元素，把小的值放在第一个数组元素中，数组循环一圈后，则把最小元素值互换到了第一个元素中。
  6. 		* 数组再循环一圈后，把第二小的元素值互换到了第二个元素中。按照这种方式，数组循环多圈以后，就完成了数组元素的排序。这种排序方式我们称为选择排序。
  8. 	* b: 解题步骤
  9. 		* 使用for循环（外层循环），指定数组要循环的圈数（通过图解可知，数组循环的圈数为数组长度 - 1）
  10. 		* 在每一圈中，通过for循环（内层循环）完成数组要比较的第一个元素与该元素后面的数组元素依次比较到数组的最后一个元素，把小的值放在第一个数组元素中
  11. 		* 在每一圈中，要参与比较的第一个元素由第几圈循环来决定。如上图所示
  12. 			* 进行第一圈元素比较时，要比较的第一个元素为数组第一个元素，即索引为0的元素
  13. 			* 进行第二圈元素比较时，要比较的第一个元素为数组第二个元素，即索引为1的元素
  14. 			* 依次类推，得出结论：进行第n圈元素比较时，要比较的第一个元素为数组第n个元素，即数组索引为n-1的元素

12选择排序功能实现

  1. * A: 案例代码
  2. 	/*
  3. 	  数组的排序: 一般都是升序排列,元素,小到大的排列
  5. 	  两种排序的方式
  6. 		 选择排序: 数组的每个元素都进行比较
  7. 		 冒泡排序: 数组中相邻元素进行比较
  8. 		 规则: 比较大小,位置交换
  9. 	*/
  10. 	public class ArrayMethodTest_2{
  11. 		public static void main(String[] args){
  12. 			int[] arr  = {3,1,4,2,56,7,0};
  13. 			//调用选择排序方法
  14. 			//selectSort(arr);
  15. 			printArray(arr);
  16. 		}
  17. 		/*
  18. 			定义方法,实现数组的选择排序
  19. 			返回值: 没有
  20. 			参数:  数组
  21. 			实现步骤:
  22. 			  1.嵌套循环实现排序
  23. 				外循环,控制的是一共比较了多少次
  24. 				内循环,控制的是每次比较了多少个元素
  25. 			  2. 判断元素的大小值
  26. 				小值,存储到小的索引
  27. 		*/
  28. 		public static void selectSort(int[] arr){
  29. 			for(int i = 0 ; i < arr.length - 1; i++){
  30. 				//内循环,是每次都在减少,修改变量的定义
  31. 				for(int j = i+1 ; j < arr.length ; j++){
  32. 					//数组的元素进行判断
  33. 					if(arr[i] > arr[j]){
  34. 						//数组的换位
  35. 						int temp = arr[i];
  36. 						arr[i] = arr[j];
  37. 						arr[j] = temp;
  38. 					}
  39. 				}
  40. 			}
  41. 		}
  43. 		/*
  44. 		   定义方法,实现功能
  45. 		   返回值: void
  46. 		   方法参数: 数组
  47. 		*/
  48. 		public static void printArray(int[] arr){
  49. 			//输出一半中括号,不要换行打印
  50. 			System.out.print("[");
  51. 			//数组进行遍历
  52. 			for(int i = 0 ; i < arr.length ; i++){
  53. 				//判断遍历到的元素,是不是数组的最后一个元素
  54. 				//如何判断 循环变量 到达 length-1
  55. 				if( i == arr.length-1 ){
  56. 					//输出数组的元素和]
  57. 					System.out.print(arr[i]+"]");
  58. 				}else{
  59. 				//不是数组的最后一个元素,输出数组元素和逗号
  60. 					System.out.print(arr[i]+",");
  61. 				}
  62. 			}
  63. 			System.out.println();
  64. 		}
  65. 	}

13冒泡排序功能实现

  1. * A: 冒泡排序功能实现
  2. 		* a: 题目分析
  3. 			* 通过观察发现，本题目要实现把数组元素{13,46,22,65,3}进行排序
  4. 			* 提到数组排序，就要进行元素值大小的比较，通过上图发现，我们想完成排序要经过若干次的比较才能够完成。
  5. 			* 上图中相邻的元素值依次比较，把大的值放后面的元素中，数组循环一圈后，则把最大元素值互换到了最后一个元素中。
  6. 				数组再循环一圈后，把第二大的元素值互换到了倒数第二个元素中。按照这种方式，数组循环多圈以后，
  7. 				就完成了数组元素的排序。这种排序方式我们称为冒泡排序。
  9. 		* b: 解题步骤
  10. 			* 使用for循环（外层循环），指定数组要循环的圈数（通过图解可知，数组循环的圈数为数组长度 - 1）
  11. 			* 在每一圈中，通过for循环（内层循环）完成相邻的元素值依次比较，把大的值放后面的元素中
  12. 			* 每圈内层循环的次数，由第几圈循环来决定。如上图所示
  13. 				* 进行第一圈元素比较时，内层循环次数为数组长度 - 1
  14. 				* 进行第二圈元素比较时，内层循环次数为数组长度 - 2
  15. 				* 依次类推，得出结论：进行第n圈元素比较时，内层循环次数为数组长度 - n
  17. 		* c: 案例代码
  18. 			/*
  19. 			  数组的排序: 一般都是升序排列,元素,小到大的排列
  21. 			  两种排序的方式
  22. 				 选择排序: 数组的每个元素都进行比较
  23. 				 冒泡排序: 数组中相邻元素进行比较
  24. 				 规则: 比较大小,位置交换
  25. 			*/
  26. 			public class ArrayMethodTest_2{
  27. 				public static void main(String[] args){
  28. 					int[] arr  = {3,1,4,2,56,7,0};
  29. 					//调用选择排序方法
  30. 					//selectSort(arr);
  32. 					//调用冒泡排序方法
  33. 					bubbleSort(arr);
  34. 					printArray(arr);
  35. 				}
  36. 				/*
  37. 				   定义方法,实现数组的冒泡排序
  38. 				   返回值: 没有
  39. 					参数:  数组
  40. 				*/
  41. 				public static void bubbleSort(int[] arr){
  42. 					for(int i = 0 ; i < arr.length - 1; i++){
  43. 						//每次内循环的比较,从0索引开始, 每次都在递减
  44. 						for(int j = 0 ; j < arr.length-i-1; j++){
  45. 							//比较的索引,是j和j+1
  46. 							if(arr[j] > arr[j+1]){
  47. 								int temp = arr[j];
  48. 								arr[j] = arr[j+1];
  49. 								arr[j+1] = temp;
  50. 							}
  51. 						}
  52. 					}
  53. 				}
  55. 				/*
  56. 				   定义方法,实现功能
  57. 				   返回值: void
  58. 				   方法参数: 数组
  59. 				*/
  60. 				public static void printArray(int[] arr){
  61. 					//输出一半中括号,不要换行打印
  62. 					System.out.print("[");
  63. 					//数组进行遍历
  64. 					for(int i = 0 ; i < arr.length ; i++){
  65. 						//判断遍历到的元素,是不是数组的最后一个元素
  66. 						//如何判断 循环变量 到达 length-1
  67. 						if( i == arr.length-1 ){
  68. 							//输出数组的元素和]
  69. 							System.out.print(arr[i]+"]");
  70. 						}else{
  71. 						//不是数组的最后一个元素,输出数组元素和逗号
  72. 							System.out.print(arr[i]+",");
  73. 						}
  74. 					}
  75. 					System.out.println();
  76. 				}
  77. 			}

14数组的折半查找原理

  1. * A: 数组的折半查找原理(图解见day07_source/折半查找原理.JPG)
  2. 		* a: 题目分析
  3. 			* 通过观察发现，本题目要实现查找指定数值在元素有序的数组中存储的位置（索引），返回该位置（索引）。
  4. 			* 我们使用数组最中间位置的元素值与要查找的指定数值进行比较，若相等，返回中间元素值的索引
  5. 			* 最中间位置的元素值与要查找的指定数值进行比较，若不相等，则根据比较的结果，缩小查询范围为上次数组查询范围的一半；
  6. 				再根据新的查询范围，更新最中间元素位置，然后使用中间元素值与要查找的指定数值进行比较
  7. 					比较结果相等，返回中间元素值的索引
  8. 					比较结果不相等，继续缩小查询范围为上次数组查询范围的一半，更新最中间元素位置，继续比较，依次类推。
  9. 			* 当查询范围缩小到小于0个元素时，则指定数值没有查询到，返回索引值-1。
  11. 		* b: 解题步骤
  12. 			* 定义3个用来记录索引值的变量，变量min记录当前范围最小索引值，初始值为0；变量max记录当前范围最大索引值，初始值为数组长度-1；变量mid记录当前当前范围最中间元素的索引值，初始值为(min+max) / 2
  13. 			* 使用循环，判断当前范围下，最中间元素值与指定查找的数值是否相等
  14. 				若相等，结束循环，返回当前范围最中间元素的索引值mid
  15. 				若不相等，根据比较结果，缩小查询范围为上一次查询范围的一般
  16. 				中间元素值 比 要查询的数值大，说明要查询的数值在当前范围的最小索引位置与中间索引位置之间，此时，更新查询范围为:
  17. 					范围最大索引值 = 上一次中间索引位置 -1；
  18. 				中间元素值 比 要查询的数值小，说明要查询的数值在当前范围的最大索引位置与中间索引位置之间，此时，更新查询范围为:
  19. 					范围最小索引值 = 上一次中间索引位置 +1；
  20. 				在新的查询范围中，更新中间元素值的位置，再次使用最中间元素值与指定查找的数值是否相等。
  21. 					中间索引值 = (范围最小索引值 +范围最大索引值) / 2;
  22. 			* 每次查询范围缩小一半后，使用if语句判断，查询范围是否小于0个元素，若小于0个元素，则说明指定数值没有查询到，返回索引值-1。

15数组的折半查找代码实现

  1. * A: 案例代码
  2. 	/*
  3. 	   数组的查找功能
  4. 		 在一个数组中,找一个元素,是否存在于数组中,如果存在,就返回索引
  6. 		 普通查询:
  7. 		   找到元素在数组中出现的索引,如果没有这个 元素,结果就是负数
  9. 	*/
  10. 	public class ArrayMethodTest_3{
  11. 		 public static void main(String[] args){
  12. 			 int[] arr = {1,3,5,7,9,11,15};
  13. 			 int index = binarySearch(arr,10);
  14. 			 System.out.println(index);
  16. 		 }
  18. 		 /*
  19. 			 定义方法,实现,折半查找
  20. 			 返回值: 索引
  21. 			 参数: 数组,被找的元素
  22. 			 实现步骤:
  23. 			   1. 需要的变量定义
  24. 				  三个,三个指针
  26. 			   2. 进行循环折半
  27. 				  可以折半的条件  min <= max
  29. 			   3. 让被找元素,和中间索引元素进行比较
  30. 				   元素 > 中间索引  小指针= 中间+1
  31. 				   元素 < 中间索引  大指针= 中间-1
  32. 				   元素 == 中间索引  找到了,结束了,返回中间索引
  34. 				4. 循环结束,无法折半
  35. 				  元素没有找到 ,返回-1
  36. 		 */
  37. 		 public static int binarySearch(int[] arr, int key){
  38. 			 //定义三个指针变量
  39. 			 int min = 0 ;
  40. 			 int max = arr.length -1 ;
  41. 			 int mid = 0;
  42. 			 //循环折半,条件 min<=max
  43. 			 while( min <= max){
  44. 				 //公式,计算中间索引
  45. 				 mid = (min+max)/2;
  46. 				 //让被找元素,和中间索引元素进行比较
  47. 				 if(key > arr[mid]){
  48. 					 min = mid + 1;
  49. 				 }else if (key < arr[mid]){
  50. 					 max = mid - 1;
  51. 				 }else{
  52. 					 //找到元素,返回元素索引
  53. 					 return mid;
  54. 				 }
  55. 			 }
  56. 			 return -1;
  57. 		 }
  59. 		/*
  60. 		   定义方法,实现数组的普通查询
  61. 		   返回值: 索引
  62. 		   参数:   数组, 被找的元素
  64. 		   实现步骤:
  65. 			 1. 遍历数组
  66. 			 2. 遍历过程中,使用元素和数组中的元素进行比较
  67. 				如果相同,返回元素在数组中的索引
  68. 				如果不同,返回负数
  69. 		*/
  70. 		public static int search(int[] arr, int key){
  71. 			//遍历数组
  72. 			for(int i = 0 ; i < arr.length ; i++){
  73. 				//数组元素,被查找的元素比较
  74. 				if(arr[i] == key){
  75. 					//返回索引
  76. 					return i;
  77. 				}
  78. 			}
  79. 			return -1;
  80. 		}
  81. 	}

16总结

  • 把今天的知识点总结一遍。

八、今日内容介绍

1、Eclipse开发工具

2、超市库存管理系统

01Eclipse的下载安装

  1. * A: Eclipse的下载安装		
  2. 	* a: 下载
  3. 		* http://www.eclipse.org
  4. 	* b: 安装
  5. 		* 只需要解压后就能使用
  6. 	* c: 卸载
  7. 		* 只需要将文件夹删除就可以了
  8. 	* d: 注意
  9. 		* 开发软件的安装目录中，尽量不要出现空格与中文
  10. * B: Eclipse的特点
  11. 	* a: 免费
  12. 	* b: 纯Java语言编写
  13. 	* c: 免安装
  14. 	* d: 扩展性强

02Eclipse的工作空间和新建工程

  1. * A: Eclipse的工作空间和新建工程
  2. 	* a: 工作空间
  3. 		*  其实就是我们写的源代码所在的目录
  4. 	* b: 创建工程(项目)
  5. 		* 右键/Package Explore 空白区/new /Java Project/输入项目名称如day08/
  6. 	* c: 创建包(后面讲包的概念)
  7. 		*　打开上面建立的day08项目/右键/new/package/在弹出的对话框的name中输入报名如"com.itheima.tests"/finish
  8. 	* d: 创建类
  9. 		* 创建一个java类:右击包名/new/class/在对话框的name中输入类名/finish
  10. * B: 编译与执行
  11. 	* a: 编译
  12. 		* 自动编译，当java代码保存的时候，自动 编译class文件
  13. 	* b: 运行
  14. 		* 方式1：点击菜单工具栏中的 绿色带有三角形的 run按钮 运行
  15. 		* 方式2：点击菜单栏中Run， 点击Run 运行  快捷键是 ctrl+F11
  16. 		* 方式3：选中要运行的java文件，或者在编写代码的空白区域，右键选择 Run As --> 运行java程序

03Eclipse的HelloWorld编写

  1. * A:HelloWorld编写
  2. 	* a: 编写过程(参照上个知识点)
  3. 		* 建立day08项目
  4. 		* 建立包结构(包的概念还没有学到,不建立包的话,使用默认包结构default)
  5. 		* 创建HelloWorld类(自动生成main方法)
  6. 	* b: 案例代码
  7. 		public class HelloWorld {
  8. 			public static void main(String[] args) {
  9. 				System.out.println("Hello World");
  10. 			}
  11. 		}

04Eclipse的字体设置

  1. * A: Eclipse的字体设置
  2. 	* a: 修改编译环境和运行环境
  3. 		* 编译环境：Window -- Preferences – Java - Compiler
  4. 		* 运行环境：Window -- Preferences – Java - Installed JREs
  6. 	* b: 显示行号与隐藏行号
  7. 		* 显示：在代码区域的左边空白区域，右键 -- Show Line Numbers
  8. 		* 隐藏：将上面的操作再做一遍
  10. 	* c: 更改字体大小与颜色
  11. 		* Java代码区域的字体大小和颜色：
  12. 			* window -- Preferences -- General -- Appearance -- Colors And Fonts --Java修改 -- Java Edit Text Font--edit进行修改
  13. 		* 控制台
  14. 			* window -- Preferences -- General -- Appearance -- Colors And Fonts -- Debug -- Console font
  15. 		* 其他文件
  16. 			* window -- Preferences -- General -- Appearance -- Colors And Fonts -- Basic -- Text Font

05Eclipse的窗口设置

  1. * A: 窗口设置
  2. 	* a: 显示的窗口乱了，还原默认显示模式
  3. 		* Window – Perspective -- Reset Prespective
  4. 	* b: 显示控制台
  5. 		* Window--Show View—Console

06Eclipse的去掉多余的注释

  1. * A: Eclipse的去掉多余的注释
  2. 	* a:如何去掉默认注释
  3. 		* Window -- Preferences -- Java -- Code Style -- Code Templates -- Comments – Methods，点击Edit ，将注释部分删除 (不建议删除)
  4. 		* Window -- Preferences -- Java -- Code Style -- Code Templates -- Code -- Method body，点击Edit ，将注释部分删除
  5. 	* b: 切换工作空间
  6. 		* File – Switch Workspace – 指定工作空间 – ok

07Eclipse的快捷键

  1. * A: Eclipse的快捷键
  2. 	* a: 内容辅助键  Alt+/
  3. 		* 自动补齐main方法  main 然后 Alt+/

 * 自动补齐输出语句 syso 然后 Alt+/

* b: 格式化代码

* Ctrl+Shift+f

* 代码区域右键 -- Source – Format

* c: 自动导包

* Ctrl+Shift+o

* 如果当前类在多个包中都存在，这时候，使用Ctrl+shift+o,进行选择一个包导入即可。

* d: 注释

* 单行注释

 * 加注释： 先选中需要注释的内容，然后 Ctrl+/

 * 取消注释：先选中需要取消注释的内容， 然后 Ctrl+/

 * 多行注释

 * 加注释： 先选中需要注释的内容，然后 Ctrl+Shift+/

 * 取消注释：先选中需要取消注释的内容， 然后 Ctrl+Shift+

* e: 补充

* 代码上下移动

* 选中代码alt+上/下箭头

* 查看源码

* 选中类名(F3或者Ctrl+鼠标点击)

* 查找具体的类

* ctrl + shift + t，输入要查找的类的名称-->确定

* 查找具体类的具体方法

* ctrl + o

* 给建议

* ctrl+1,根据右边生成左边的数据类型,生成方法

* 删除代码

* ctrl + d

* 抽取方法

* alt + shift + m

* 改名

* alt + shift + r（类名，方法名，变量名）

08Eclipse的断点调试

  1. * A:断点调试(又称为Debug调试)的作用
  2. 	* 调试程序
  3. 	* 查看程序执行流程
  4. * B:如何查看程序执行流程
  5. 	* 什么是断点：
  6. 		* 就是一个标记，从哪里开始。
  8. 	* 如何设置断点：
  9. 		* 你想看哪里的程序，你就在那个有效程序的左边双击即可。
  11. 	* 在哪里设置断点：
  12. 		* 哪里不会点哪里。
  13. 		* 目前：我们就在每个方法的第一条有效语句上都加。
  15. 	* 如何运行设置断点后的程序：
  16. 		* 右键 -- Debug as -- Java Application
  18. 	* 看哪些地方：
  19. 		* Debug：断点测试的地方
  20. 			* 在这个地方，记住F6，或者点击也可以。一次看一行的执行过程。
  21. 		* Variables：查看程序的变量变化
  22. 		* ForDemo：被查看的源文件
  23. 		* Console：控制台
  25. 	* 如何去断点：
  26. 		* a:再次双击即可
  27. 		* b:找到Debug视图，Variables界面，找到Breakpoints，并点击，然后看到所有的断点，最后点击那个双叉

09Eclipse的工程删除和导入

  1. * A:删除项目
  2. 	* 选中项目 – 右键 – 删除
  3. 		* 从项目区域中删除
  4. 		* 从硬盘上删除
  5. * B:导入项目
  6. 	* 在项目区域右键找到import
  7. 	* 找到General，展开，并找到
  8. 	* Existing Projects into Workspace
  9. 	* 点击next,然后选择你要导入的项目
  10. 	* 注意：这里选择的是项目名称

10超市管理系统功能介绍

  1. * A：超市管理系统功能介绍
  2. 	* a: 显示主菜单
  4. 		============欢迎光临ItCast超市============
  5. 		1: 货物 清单   2: 添加货物   3: 删除货物   4: 修改货物  5: 退出
  6. 		请您输入要操作的功能序号
  8. 	* b: 货物清单
  10. 		输入1:货物清单
  11. 		================商品库存清单================
  12. 		商品编号         商品名称                商品单价
  13. 		9527   			少林寺酥饼核桃        	   12.7
  14. 		9008   			尚康杂粮牡丹饼       	   5.6
  15. 		9879   			新疆原产哈密瓜             599.6
  17. 	* c: 添加新货物
  19. 		输入2:添加新货物	
  21. 		请输入新商品的编号:9523
  22. 		请输入新商品的名字:斯柯达苹果醋
  23. 		请输入新商品的单价:19.9
  24. 		商品添加成功
  26. 	* d: 删除货物
  28. 		输入3:删除货物
  30. 		选择的是删除功能
  31. 		请输入商品的编号:9523
  32. 		货物信息删除完毕
  34. 	* e: 修改货物
  36. 		输入4:修改货物
  38. 		选择的是修改功能
  39. 		请输入您要修改的商品的编号:9527
  40. 		输入新的商品编号:100
  41. 		输入新的商品名字:味道好凤梨干
  42. 		输入新的商品价格:6.5
  43. 		商品修改成功
  44. 	* f: 输入5:退出系统

11超市管理系统案例分析

  1. * A: 超市管理系统案例分析
  2. 	* 完成超市商品初始化。创建商品，将商品添加到集合
  3. 	* 显示来到超市能做的操作，也就是显示主菜单
  4. 	* 根据接收到的功能选项，执行对应的功能
  5. 	* 库存货物查询
  6. 	* 添加新货物
  7. 	* 删除货物
  8. 	* 修改货物
  9. 	* 退出系统,结束main方法的运行
  10. 	* 循环，回到 2.显示主菜单

12自定义商品类

  1. * A: 自定义商品类
  2. 	* a: 目的
  3. 		* 每种库存商品都拥有多项商品信息，为了方便管理每种商品的信息，我们对商品信息进行封装，编写FruitItem.java文件
  4. 	* b：案例代码
  5. 		public class FruitItem {
  6. 			int  ID;			//商品编号
  7. 			String  name;		//商品名称
  8. 			double  price;		//商品单价
  9. 			double  number;		//商品数量
  10. 			double  money;		//商品金额
  11. 		}
  12. 	* 补充
  13. 		* 上述代码中，对商品信息（编号、名称、单价、数量、金额）进行了封装。这样做的好处在于以后只要找到这个商品，就能够知道该商品的每项信息了。

13初始化商品属性

  1. * A: 初始化商品属性
  2. 	* a: 案例代码
  3. 		import java.util.ArrayList;
  4. 		import java.util.Scanner;
  6. 		/*
  7. 		 *   超市管理系统主
  8. 		 *   实现:
  9. 		 *     1. 商品数据的初始化
  10. 		 *     2. 用户的菜单选择
  11. 		 *     3. 根据选择执行不同的功能
  12. 		 *       3.1 Read    查看商品
  13. 		 *       3.2 Create  添加商品
  14. 		 *       3.3 Delete  删除商品
  15. 		 *       3.4 Update  修改商品
  16. 		 *
  17. 		 *
  18. 		 *   所有功能 ,必须定义方法实现
  19. 		 *   主方法main  调用作用
  20. 		 */
  21. 		public class Shopp {
  23. 			public static void main(String[] args) {
  24. 				//创建ArrayList集合,存储商品类型,存储数据类型FruitItem类型
  25. 				ArrayList<FruitItem> array = new ArrayList<FruitItem>();
  26. 				//调用商品初始化方法,传递集合
  27. 				init(array);
  29. 				}
  30. 			}
  31. 			/*
  32. 			 * 定义方法,实现商品数据的初始化
  33. 			 * 先将一部分数据,存储集合中
  34. 			 * 返回值: 无
  35. 			 * 参数 : 集合
  36. 			 * 方法名: init
  37. 			 */
  38. 			public static void init(ArrayList<FruitItem> array){
  39. 				//创建出多个FruitItem类型,并且属性赋值
  40. 				FruitItem f1 = new FruitItem();
  41. 				f1.ID = 9527;
  42. 				f1.name = "少林寺酥饼核桃";
  43. 				f1.price = 12.7;
  45. 				FruitItem f2 = new FruitItem();
  46. 				f2.ID = 9008;
  47. 				f2.name = "尚康杂粮牡丹饼";
  48. 				f2.price = 5.6;
  50. 				FruitItem f3 = new FruitItem();
  51. 				f3.ID = 9879;
  52. 				f3.name = "新疆原产哈密瓜";
  53. 				f3.price = 599.6;
  55. 				//创建的3个FruitItem类型变量,存储到集合中
  56. 				array.add(f1);
  57. 				array.add(f2);
  58. 				array.add(f3);
  59. 			}
  61. 		}

14主菜单功能

  1. * A: 主菜单功能
  2. 	* a: 案例代码
  4. 		import java.util.ArrayList;
  5. 		import java.util.Scanner;
  6. 		/*
  7. 		 *   超市管理系统主
  8. 		 *   实现:
  9. 		 *     1. 商品数据的初始化
  10. 		 *     2. 用户的菜单选择
  11. 		 *     3. 根据选择执行不同的功能
  12. 		 *       3.1 Read    查看商品
  13. 		 *       3.2 Create  添加商品
  14. 		 *       3.3 Delete  删除商品
  15. 		 *       3.4 Update  修改商品
  16. 		 *
  17. 		 *
  18. 		 *   所有功能 ,必须定义方法实现
  19. 		 *   主方法main  调用作用
  20. 		 */
  21. 		public class Shopp {
  23. 			public static void main(String[] args) {
  24. 				//创建ArrayList集合,存储商品类型,存储数据类型FruitItem类型
  25. 				ArrayList<FruitItem> array = new ArrayList<FruitItem>();
  26. 				//调用商品初始化方法,传递集合
  27. 				init(array);
  28. 				while(true){
  29. 					//调用菜单方法
  30. 					mainMenu();
  31. 				}
  32. 			}
  33. 			/*
  34. 			 * 定义方法,实现主菜单
  35. 			 * 提示用户哪些选择 让选择序号
  36. 			 * 返回值: 无
  37. 			 * 参数: 无
  38. 			 */
  39. 			public static void mainMenu(){
  40. 				System.out.println();
  41. 				System.out.println("============欢迎光临ItCast超市============");
  42. 				System.out.println("1: 货物 清单   2: 添加货物   3: 删除货物   4: 修改货物  5: 退出");
  43. 				System.out.println("请您输入要操作的功能序号");
  44. 			}
  46. 			/*
  47. 			 * 定义方法,实现商品数据的初始化
  48. 			 * 先将一部分数据,存储集合中
  49. 			 * 返回值: 无
  50. 			 * 参数 : 集合
  51. 			 * 方法名: init
  52. 			 */
  53. 			public static void init(ArrayList<FruitItem> array){
  54. 				//创建出多个FruitItem类型,并且属性赋值
  55. 				FruitItem f1 = new FruitItem();
  56. 				f1.ID = 9527;
  57. 				f1.name = "少林寺酥饼核桃";
  58. 				f1.price = 12.7;
  60. 				FruitItem f2 = new FruitItem();
  61. 				f2.ID = 9008;
  62. 				f2.name = "尚康杂粮牡丹饼";
  63. 				f2.price = 5.6;
  65. 				FruitItem f3 = new FruitItem();
  66. 				f3.ID = 9879;
  67. 				f3.name = "新疆原产哈密瓜";
  68. 				f3.price = 599.6;
  70. 				//创建的3个FruitItem类型变量,存储到集合中
  71. 				array.add(f1);
  72. 				array.add(f2);
  73. 				array.add(f3);
  74. 			}
  76. 		}

15用户选择功能

  1. * A: 用户选择功能
  2. 	* a: 案例代码
  3. 		import java.util.ArrayList;
  4. 		import java.util.Scanner;
  6. 		/*
  7. 		 *   超市管理系统主
  8. 		 *   实现:
  9. 		 *     1. 商品数据的初始化
  10. 		 *     2. 用户的菜单选择
  11. 		 *     3. 根据选择执行不同的功能
  12. 		 *       3.1 Read    查看商品
  13. 		 *       3.2 Create  添加商品
  14. 		 *       3.3 Delete  删除商品
  15. 		 *       3.4 Update  修改商品
  16. 		 *
  17. 		 *
  18. 		 *   所有功能 ,必须定义方法实现
  19. 		 *   主方法main  调用作用
  20. 		 */
  21. 		public class Shopp {
  23. 			public static void main(String[] args) {
  24. 				//创建ArrayList集合,存储商品类型,存储数据类型FruitItem类型
  25. 				ArrayList<FruitItem> array = new ArrayList<FruitItem>();
  26. 				//调用商品初始化方法,传递集合
  27. 				init(array);
  28. 				while(true){
  29. 					//调用菜单方法
  30. 					mainMenu();
  31. 					//调用用户选择序号方法
  32. 					int choose = chooseFunction();
  33. 					switch (choose) {
  34. 					case 1:
  35. 						//调用1: 货物 清单
  36. 						showFruitList(array);
  37. 					break;
  39. 					case 2:
  40. 						//2: 添加货物
  41. 						addFruit(array);
  42. 					break;
  44. 					case 3:
  45. 						//3: 删除货物
  46. 						deleteFruit(array);
  47. 					break;
  49. 					case 4:
  50. 						//4: 修改货物
  51. 						updateFruit(array);
  52. 					break;
  54. 					case 5:
  55. 						return ;
  57. 					default:
  58. 						System.out.println("输入的序号没有");
  59. 						break;
  60. 					}
  61. 				}
  62. 			}
  63. 			/*
  64. 			 *  定义方法,实现接受用户的键盘输入
  65. 			 *  返回编号
  66. 			 */
  67. 			public static int chooseFunction(){
  68. 				Scanner sc = new Scanner(System.in);
  69. 				return sc.nextInt();
  70. 			}
  72. 			/*
  73. 			 * 定义方法,实现主菜单
  74. 			 * 提示用户哪些选择 让选择序号
  75. 			 * 返回值: 无
  76. 			 * 参数: 无
  77. 			 */
  78. 			public static void mainMenu(){
  79. 				System.out.println();
  80. 				System.out.println("============欢迎光临ItCast超市============");
  81. 				System.out.println("1: 货物 清单   2: 添加货物   3: 删除货物   4: 修改货物  5: 退出");
  82. 				System.out.println("请您输入要操作的功能序号");
  83. 			}
  85. 			/*
  86. 			 * 定义方法,实现商品数据的初始化
  87. 			 * 先将一部分数据,存储集合中
  88. 			 * 返回值: 无
  89. 			 * 参数 : 集合
  90. 			 * 方法名: init
  91. 			 */
  92. 			public static void init(ArrayList<FruitItem> array){
  93. 				//创建出多个FruitItem类型,并且属性赋值
  94. 				FruitItem f1 = new FruitItem();
  95. 				f1.ID = 9527;
  96. 				f1.name = "少林寺酥饼核桃";
  97. 				f1.price = 12.7;
  99. 				FruitItem f2 = new FruitItem();
  100. 				f2.ID = 9008;
  101. 				f2.name = "尚康杂粮牡丹饼";
  102. 				f2.price = 5.6;
  104. 				FruitItem f3 = new FruitItem();
  105. 				f3.ID = 9879;
  106. 				f3.name = "新疆原产哈密瓜";
  107. 				f3.price = 599.6;
  109. 				//创建的3个FruitItem类型变量,存储到集合中
  110. 				array.add(f1);
  111. 				array.add(f2);
  112. 				array.add(f3);
  113. 			}
  115. 		}

16商品的清单功能

  1. * A: 商品的清单功能
  2. 	* a: 案例代码(显示商品清单的showFruitList(ArrayList<FruitItem>)方法的代码如下)
  3. 		/*
  4. 		 *  定义方法,实现显示货物清单功能
  5. 		 *  返回值: 无
  6. 		 *  参数: 集合
  7. 		 *  遍历集合,获取集合中的每个FruitItem变量,变量,调用属性
  8. 		 */
  9. 		public static void showFruitList(ArrayList<FruitItem> array){
  10. 			System.out.println();
  11. 			System.out.println("================商品库存清单================");
  12. 			System.out.println("商品编号         商品名称                商品单价");
  13. 			//遍历集合
  14. 			for(int i = 0 ; i < array.size(); i++){
  15. 				//集合get方法,获取出每个FruitItem变量,可以使用FruitItem接受get结果
  16. 				FruitItem item = array.get(i);
  17. 				//变量item调用类中属性
  18. 				System.out.println(item.ID+"   "+item.name+"        "+item.price);
  19. 			}
  20. 		}

17商品的添加功能

  1. * A: 商品的添加功能
  2. 	* a: 案例代码(商品添加功能的addFruit(ArrayList<FruitItem>)方法的代码如下)
  3. 		/*
  4. 		 * 定义方法,实现商品的添加功能
  5. 		 * 返回值:无
  6. 		 * 参数: 集合
  7. 		 * 提示用户选择的是添加商品的功能
  8. 		 *
  9. 		 * 提示用户输入的是什么
  10. 		 *
  11. 		 * 创建FruitItem变量,变量调用的属性
  12. 		 * 将输入的每个商品属性进行赋值
  13. 		 */
  14. 		public static void addFruit(ArrayList<FruitItem> array){
  15. 			System.out.println("选择的是添加商品功能");
  16. 			//创建Scanner变量
  17. 			Scanner sc = new Scanner(System.in);
  18. 			System.out.print("请输入新商品的编号:");
  19. 			//输入商品的编号
  20. 			int ID = sc.nextInt();
  21. 			//输入商品的名字
  22. 			System.out.print("请输入新商品的名字:");
  23. 			String name = sc.next();
  24. 			//输入商品的单价
  25. 			System.out.print("请输入新商品的单价:");
  26. 			double price = sc.nextDouble();
  27. 			//创建FruitItem变量
  28. 			FruitItem item = new FruitItem();
  29. 			//item.属性赋值
  30. 			item.ID = ID;
  31. 			item.name = name;
  32. 			item.price = price;
  33. 			array.add(item);
  34. 			System.out.println("商品添加成功");
  35. 		}

18商品的删除功能

  1. * A: 商品的删除功能(删除商品deleteFruit(ArrayList<FruitItem>)方法的代码如下)
  2. 	* a: 案例代码
  3. 		/*
  4. 		 *  定义方法,实现商品的删除功能
  5. 		 *  返回值:　无
  6. 		 *  参数：　集合
  7. 		 *
  8. 		 *  删除依靠的是商品的编号
  9. 		 *  提示用户选择的是删除功能
  10. 		 *  键盘输入商品的编号
  11. 		 *  遍历集合，获取集合中的每个FruitItem变量
  12. 		 *  变量调用属性　ID， 和用户的输入的编号,对比,相同就删除
  13. 		 */
  14. 		public static void deleteFruit(ArrayList<FruitItem> array){
  15. 			System.out.println("选择的是删除功能");
  16. 			System.out.print("请输入商品的编号:");
  17. 			Scanner sc = new Scanner(System.in);
  19. 			int ID = sc.nextInt();
  20. 			//遍历集合
  21. 			for(int i = 0 ; i < array.size(); i++){
  22. 				//获取到每个FruitItem变量
  23. 				FruitItem item = array.get(i);
  24. 				//变量,调用属性ID,和用户输入的编号比较
  25. 				if( item.ID == ID){
  26. 					//移除集合中的元素
  27. 					//集合的方法remove实现
  28. 					array.remove(i);
  29. 					System.out.println("删除成功");
  30. 					return;
  31. 				}
  32. 			}
  33. 			System.out.println("你输入的编号不存在");
  34. 		}

19商品的修改功能

  1. * A: 商品的修改功能
  2. 	* a: 案例代码(修改商品updateFruit(ArrayList<FruitItem>)方法的代码如下)
  3. 		/*
  4. 		 *  定义方法,实现商品的修改功能
  5. 		 *  返回值:　无
  6. 		 *  参数：　集合
  7. 		 *
  8. 		 *  提示用户选择的是修改功能
  9. 		 *  提示用户输入需要修改的商品编号
  10. 		 *  遍历集合,获取每个FruitItem变量
  11. 		 *  变量调用ID属性,属性和用户输入的编号比较
  12. 		 *  如果相同:
  13. 		 *    修改调FruitItem中的属性值
  14. 		 *    键盘输入
  15. 		 */
  16. 		public static void updateFruit(ArrayList<FruitItem> array){
  17. 			System.out.println("选择的是修改功能");
  18. 			System.out.print("请输入您要修改的商品的编号:");
  20. 			Scanner sc = new Scanner(System.in);
  21. 			int ID = sc.nextInt();
  22. 			//遍历集合,获取每个FruitItem变量
  23. 			for(int i = 0 ; i < array.size(); i++){
  24. 				FruitItem item = array.get(i);
  25. 				//获取FruitItem的属性ID,和用户输入的ID比较
  26. 				if(item.ID == ID){
  27. 					System.out.print("输入新的商品编号:");
  28. 					item.ID = sc.nextInt();
  30. 					System.out.print("输入新的商品名字:");
  31. 					item.name = sc.next();
  33. 					System.out.print("输入新的商品价格:");
  34. 					item.price = sc.nextDouble();
  35. 					System.out.println("商品修改成功");
  36. 					return ;
  37. 				}
  38. 			}
  39. 			System.out.println("输入的编号不存在");
  40. 		}

20总结

  • 把今天的知识点总结一遍。

Java基础笔记05-06-07-08的更多相关文章

  1. 046 01 Android 零基础入门 01 Java基础语法 05 Java流程控制之循环结构 08 for循环的注意事项

    046 01 Android 零基础入门 01 Java基础语法 05 Java流程控制之循环结构 08 for循环的注意事项 本文知识点:for循环的注意事项 for循环的注意事项 for循环有3个 ...

  2. 045 01 Android 零基础入门 01 Java基础语法 05 Java流程控制之循环结构 07 for循环应用及局部变量作用范围

    045 01 Android 零基础入门 01 Java基础语法 05 Java流程控制之循环结构 07 for循环应用及局部变量作用范围 本文知识点:for循环应用及局部变量作用范围 for循环 w ...

  3. 044 01 Android 零基础入门 01 Java基础语法 05 Java流程控制之循环结构 06 使用do-while循环实现猜字游戏

    044 01 Android 零基础入门 01 Java基础语法 05 Java流程控制之循环结构 06 使用do-while循环实现猜字游戏 本文知识点:do-while循环深入运用 案例练习 案例 ...

  4. Java基础笔记 – Annotation注解的介绍和使用 自定义注解

    Java基础笔记 – Annotation注解的介绍和使用 自定义注解 本文由arthinking发表于5年前 | Java基础 | 评论数 7 |  被围观 25,969 views+ 1.Anno ...

  5. 【转】Java基础笔记 – 枚举类型的使用介绍和静态导入--不错

    原文网址:http://www.itzhai.com/java-based-notes-introduction-and-use-of-an-enumeration-type-static-impor ...

  6. JAVA自学笔记05

    JAVA自学笔记05 1.方法 1)方法就是完成特定功能的代码块,类似C语言中的函数. 2)格式: 修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2,-){ 函数体; return ...

  7. 053 01 Android 零基础入门 01 Java基础语法 05 Java流程控制之循环结构 15 流程控制知识总结

    053 01 Android 零基础入门 01 Java基础语法 05 Java流程控制之循环结构 15 流程控制知识总结 本文知识点: 流程控制知识总结 流程控制知识总结 选择结构语句 循环结构语句 ...

  8. 052 01 Android 零基础入门 01 Java基础语法 05 Java流程控制之循环结构 14 Eclipse下程序调试——debug2 多断点调试程序

    052 01 Android 零基础入门 01 Java基础语法 05 Java流程控制之循环结构 14 Eclipse下程序调试--debug2 多断点调试程序 本文知识点: Eclipse下程序调 ...

  9. 051 01 Android 零基础入门 01 Java基础语法 05 Java流程控制之循环结构 13 Eclipse下程序调试——debug入门1

    051 01 Android 零基础入门 01 Java基础语法 05 Java流程控制之循环结构 13 Eclipse下程序调试--debug入门1 本文知识点: 程序调试--debug入门1 程序 ...

  10. 050 01 Android 零基础入门 01 Java基础语法 05 Java流程控制之循环结构 12 continue语句

    050 01 Android 零基础入门 01 Java基础语法 05 Java流程控制之循环结构 12 continue语句 本文知识点:continue语句 continue语句 continue ...

随机推荐

  1. iOS－pthread && NSThread && iOS9网络适配

    几个概念: 进程:"正在运行"应用程序(app)就是一个进程,它至少包含一个线程:            进程的作用:为应用程序开辟内存空间: 线程:CPU调度的最小单元:     ...

  2. Android中Widget开发步骤

    一.创建一个类,继承自 AppWidgetProvider 生命周期介绍: onEnabled():创建第一个widget时调用 onDisabled():删除最后一个widget时调用 二.在清单文 ...

  3. Spring Cloud 系列之 Alibaba Nacos 注册中心（一）

    前言 从本章节开始,我们学习 Spring Cloud Alibaba 相关微服务组件. Spring Cloud Alibaba 介绍 Spring Cloud Alibaba 致力于提供微服务开发 ...

  4. @atcoder - AGC026F@ Manju Game

    目录 @description@ @solution@ @accepted code@ @details@ @description@ 给定一个含 N 个数的序列,Alice 与 Bob 在博弈.Al ...

  5. Hexo博客框架攻略

    前言 前天无意在b站看到up主CodeSheep上传的博客搭建教程,引起了我这个有需求但苦于没学过什么博客框架的小白的兴趣.于是花了两天时间终于终于把自己的博客搭建好了,踩了无数的坑,走偏了无数的路, ...

  6. python+selenium上传本地文件

    迅雷号自媒体视频文件自动上传,贴标签发布 难点 本地文件上传,通过send_keys(‘文件路径’)的方式实现上传的目的 文件名通过正则匹配的方式进行处理,主要匹配出中文标题名称 处理过程中文件名称中 ...

  7. [计网笔记] 传输层---TCP 传输层思维导图

    传输层思维导图 TCP笔记 为什么是三次握手和四次挥手 https://blog.csdn.net/baixiaoshi/article/details/67712853 [问题1]为什么连接的时候是 ...

  8. Scrapy学习1：安装

    Install Scrapy 熟悉PyPI的话,直接一句 pip install Scrapy 但是有时候需要处理安装依赖,不能直接一句命令就安装结束,这个和系统有关. 我用的Ubuntu,这里仅介绍 ...

  9. 微服务配置中心 Apollo 源码解析——Admin 发送发布消息

    内容参考:https://www.toutiao.com/a6643383570985386509/ 摘要: 原创出处http://www.iocoder.cn/Apollo/admin-server ...

  10. TCP实战二(半连接队列、全连接队列)

    TCP实验一我们利用了tcpdump以及Wireshark对TCP三次握手.四次挥手.流量控制做了深入的分析,今天就让我们一同深入理解TCP三次握手中两个重要的结构:半连接队列.全连接队列. 参考文献 ...