Java语法的学习笔记
下面放复习的文档链接，如果有需要可以前往下载获取，这个仓库还有关于mysql、hadoop、python等的复习部分，并且每个文档有着对应的代码部分，链接如下:
https://gitee.com/zhang-huile/LearnForJob/tree/master/java/javasepro
目录
Java语法的学习笔记
一、java 流程控制
二、java 分支结构
1.if 分支是什么？
2.if分支写法有几种？
3.注：
4.switch分支
5.if 、switch 的比较 ，以及各自适合什么场景。
6.目标：搞清楚 switch 使用时的几点注意事项
7.switch穿透性能解决什么问题？
三、java 循环结构
1.for循环在开发中的常见场景
2.for循环的语法和执行流程
3.while循环的语法和执行流程
for 与 while 相同点：
for 与 while 不同点：
5.什么时候使用for循环，什么时候使用while循环？
6.案例：纸张折叠成珠穆朗玛峰的高度。
7.do-while循环格式 和执行流程
8.三种循环的小结：
9.死循环
10.循环嵌套
11.跳转关键字
四、案例技术：生成随机数
1.random的使用
2.random生成随机数需要几步？
3.如何生成 65- 91 之间的随机字数？
4.猜数字的游戏
五、数组
1.数组是什么？
2.数组的定义
3.如何访问数组的元素？
4.访问数组的长度如何获取？
5.数组的最大索引是多少？
6.如果访问数组时，使用的索引超过了数组的最大索引会出什么问题？
7.数组的遍历
8.如何遍历数组？
9.案例：
10.动态初始化数组：
11.两种数组定义的方式各自适合什么场景？
12.案例：
13.java内存分配介绍
14.一个Java程序，主要看JVM中包含的哪几部分内存区域？
15.简单说说 int a = 20; int[] arr = new int[3]; 这两行代码的执行原理？
16.多个数组变量，指向同一个数组对象的原因是什么？需要注意什么？
17.如果某个数组变量存储的是null，会发生什么情况？
六、专项训练
1.数组求最值
2.数组反转
3.随机排名
七、DeBug的使用
1.DeBug的作用
八、方法
1.方法是什么？
2.方法定义时几个注意点：
3.方法的好处
4.方法要执行必须怎么办？
5.方法的其他形式
6.方法使用时常见的问题
8.案例：
(1)求 1-n的和。
(2)判断一个整数时奇数还是偶数。
9.方法在计算机中的执行原理
九、java的参数传递机制 (重要)
1.java的传递机制都是值传递
2.引用类型的传递
3.基本类型和引用类型的参数在值传递的时候有什么不同？
4.案例：
十、方法的重载
1.方法的重载
2.注意事项：
3.案例：
4.补充：return关键字在方法中单独使用
5. return ; 跳出并立即结束所在方法的执行
一、java 流程控制
1. 顺序结构：程序从上到下依次执行各个语句，只有前一个语句执行完毕后，才会执行下一个语句。
2. 选择结构：程序根据判断条件来执行不同的语句，只有满足条件的语句才会执行，否则会跳过该语句。
3. 循环结构：程序根据循环条件重复执行语句，直到满足循环条件为止。
二、java 分支结构
1.if 分支是什么？
可以根据条件，选择执行某段程序执行
2.if分支写法有几种？
一般有三种写法：
1.ifif(条件表达式){//执行的代码
}2.if...elseif(条件表达式){//执行的代码
}else{//执行的代码
}3.if...elseif(条件表达式){//执行的代码
}else if(条件表达式){//执行的代码
}else{
//执行的代码
}3.注：
if(条件){},()后不能跟; , 否则{}中的代码不受if控制
如果if语句的{}中只有一行代码的情况，{}可以省略不写 (但是不推荐省略)
4.switch分支
通过比较值来决定执行哪条分支。
switch分支的执行流程。
(1)先执行表达式的值，再拿着这个值去与case后的值进行匹配。
(2)与哪一个case匹配，就执行哪一个case中的代码，遇到break就退出switch分支。
(3)如果没有匹配到任何一个case，就执行default中的代码。
注意：switch分支只能匹配int、char、byte、short、String类型的值。
语法：
switch(表达式){case 值1://执行的代码break;case 值2://执行的代码break;default://执行的代码}5.if 、switch 的比较 ，以及各自适合什么场景。
if适合于条件判断，switch适合于多分支条件判断。
当前条件是区间时，应该使用if；当前条件是单个值时，应该使用switch。
6.目标：搞清楚 switch 使用时的几点注意事项
表达式类型只能是 byte、short、int、char、JDK5开始支持枚举类型 ，JDK7开始支持字符串类型，不支持double、float、long类型。
case给出的值不允许重复，且只能是字面量，不能是变量。
正常使用switch的时候，不要忘记写brake , 否则会发生穿透现象。
7.switch穿透性能解决什么问题？
当存在多个case分支的代码相同时，可以把相同的代码放到一个case块中，其他case块都通过穿透性穿透到该case块执行代码即可，简化代码
三、java 循环结构
1.for循环在开发中的常见场景
减少代码的重复编写、灵活的 控制程序的执行流程。
2.for循环的语法和执行流程
for(初始化表达式; 循环条件表达式; 迭代表达式){//循环体}执行流程：
1.首先执行初始化表达式，初始化循环控制变量。
2.然后判断循环条件表达式是否成立，如果成立，则执行循环体，否则退出循环。
3.在每次循环体执行完毕后，执行迭代表达式，并重新判断循环条件表达式是否成立，如果成立，则继续执行循环体，否则退出循环。
4.直到循环条件表达式不成立，循环结束。
3.while循环的语法和执行流程
while(循环条件表达式){//循环体}执行流程：
1.首先判断循环条件表达式是否成立，如果成立，则执行循环体，否则退出循环。
2.在每次循环体执行完毕后，再判断循环条件表达式是否成立，如果成立，则继续执行循环体，否则退出循环。
3.直到循环条件表达式不成立，循环结束。
4.while循环和for循环的区别
for 与 while 相同点：
1.都可以实现循环功能。
2.都可以设置循环条件。
3.都可以设置循环次数。
for 与 while 不同点：
1.for循环可以简化循环代码，可以设置循环变量，可以提前退出循环。
2.while循环可以灵活控制循环次数，可以提前退出循环。
3.for循环可以提前退出循环，而while循环只能在循环体中判断是否退出循环。
5.什么时候使用for循环，什么时候使用while循环？
一般情况下，for循环比while循环更加简洁，更加适合控制循环次数的场景。
但是，在一些特殊的场景下，while循环更加适合，比如：
1.循环次数不确定，需要一直循环。
2.循环次数比较多，使用while循环可以节省代码。
3.循环次数比较少，使用for循环可以提高代码的可读性。
即：知道循环次数，使用for循环；循环次数不确定，使用while循环。
6.案例：纸张折叠成珠穆朗玛峰的高度。
需求：世界最高峰珠穆朗玛峰的高度是：8848.86米=88488860毫米，假如我有一张足够大的纸，它的厚度时0.1毫米。
问：纸张折叠多少次，可以折成珠穆朗玛峰的高度。答案如下（两个方法）：
public class WhileTest4 {public static void main(String[] args) {double high = 8848860;int count = 0;double paperThickness = 0.1;//定义while循环，控制纸张进行折叠。while (paperThickness <= high) {paperThickness += paperThickness;count++;}System.out.println("需要折叠的次数是 " + count);System.out.println("最终纸张的厚度是 " + paperThickness);System.out.println("___________________________-");int count1 = 0;double paperThickness1 = 0.1;for (;paperThickness1 <=8848860;count1 ++){paperThickness1 += paperThickness1;}System.out.println("需要折叠的次数是 " + count1);System.out.println("最终纸张的厚度是 " + paperThickness1);}
}7.do-while循环格式 和执行流程
格式：
do{//循环体}while(循环条件表达式);执行流程：
1.首先执行循环体。
2.在每次循环体执行完毕后，再判断循环条件表达式是否成立，如果成立，则继续执行循环体，否则退出循环。
3.直到循环条件表达式不成立，循环结束。
特点：
先执行后判断，直到满足循环条件才执行循环体。
8.三种循环的小结：
for 循环 和 while 循环 (先判断后执行) do-while 循环 (先执行后判断)
for和while循环的执行流程是一样的，功能上并无区别，for能做的while也能做。
区别：在for循环中，控制循环的变量只能在循环中使用，而在while和do-while循环中，控制循环的变量可以在循环外使用。
9.死循环
可以一直执行下去的一种循环，如果没有干预不会停下来。
死循环的三种写法：
(1) for ( ; ; ) {// 循环体 ，将一直执行}(2) while (true) {// 循环体 ，将一直执行 //经典写法}(3) do {// 循环体 ，将一直执行}while (true);死循环的作用：
1. 死循环可以用来做一些特殊的功能，比如死循环等待用户输入，死循环等待服务器响应。
2. 死循环可以用来做一些死循环检测，比如死循环检测网络是否正常。
10.循环嵌套
循环中又包含循环的结构，称为循环嵌套。
特点：外层循环一次，内层会循环完成指定次数。
11.跳转关键字
break：跳出当前循环。
continue：跳过当前循环，直接进入下一次循环。
注意：
1.break只能用于结束所在循环，或者结束switch分支的执行。
2.continue只能在循环中进行使用。
四、案例技术：生成随机数
1.random的使用
随机数的生成是java中非常常用的功能，java.util.Random类提供了生成随机数的方法。
语法：
Random random = new Random();int num = random.nextInt(100); //生成0-99之间的随机整数注意：
1.nextInt()方法可以生成指定范围内的随机整数，包括最小值和最大值。
2.nextInt(n)方法的作用是生成0-n-1之间的随机整数。
3.nextInt()方法的返回值是int类型，范围是0-2147483647。
因为：random生成的随机数是 0 ~ n-1 , 而需要 1 ~ n 的随机数，所以需要加1。
即：num = random.nextInt(100) + 1;
2.random生成随机数需要几步？
随机数的生成过程：
1.创建Random对象。
2.调用nextInt()方法，传入最大值。
3.获取随机数。
3.如何生成 65- 91 之间的随机字数？
65 - 91 => -65 => (0 - 26) +65
即：num = random.nextInt(27) + 65;
4.猜数字的游戏
随机生成一个1-100之间的数字，玩家需要猜测这个数字，每猜一次，系统会提示玩家猜的数字是大了还是小了，
直到猜对为止。
代码见 RandomTest2.java 和 如下
package com.zhl.random;import java.util.Random;
import java.util.Scanner;public class RandomTest2 {public static void main(String[] args) {//猜数字 1-100Random r = new Random();Scanner sc = new Scanner(System.in);int RightNum = r.nextInt(100)+1;do {System.out.print("请输入你猜测的数字：");int guess = sc.nextInt();if (guess == RightNum){System.out.println("恭喜你猜对了！");break; //退出循环,结束游戏}else if(guess > RightNum){System.out.println("猜大了！");}else{System.out.println("猜小了！");}}while(true);}
}五、数组
1.数组是什么？
数组就是一个容器，用来存储一批同样类型的数据。
2.数组的定义
有两种方式定义数组：静态初始化和动态初始化。
1.静态初始化：
静态初始化就是在定义数组的时候，就初始化了数组中的元素。
语法格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...,元素n};
简化格式：数据类型[] 数组名 = {元素1,元素2,...,元素n};
例如：int[] arr = {1,2,3,4,5};之后，可以使用数组名[下标]的方式，访问数组元素。下标从0开始，到数组长度-1结束。
注：数组变量名中存储的是数组在内存中的地址信息，数组是一种引用数据类型。
什么类型的数组必须存放什么类型的数据。
3.如何访问数组的元素？
数组的元素可以通过下标访问，下标从0开始，到数组长度-1结束。
语法格式：数组名[索引]
4.访问数组的长度如何获取？
数组的长度可以通过数组名.length来获取。
arr.length;5.数组的最大索引是多少？
数组的最大索引是数组长度-1。前提是数组的元素个数大于0。
数组名.length-1;
6.如果访问数组时，使用的索引超过了数组的最大索引会出什么问题？
执行程序会出Bug , 出现一个索引越界的异常提示。
7.数组的遍历
遍历：就是一个一个访问一遍容器中的元素。
8.如何遍历数组？
for (int i = 0; i < age.length; i++) {System.out.println(age[i]);}9.案例：
某个部门的5个员工的销售额分别是 16 、 20 、 25 、 3 、 100 ,请计算出他们部门的总销售额。
静态初始化：
double[] sales = {16,20,25,3,100};double sum = 0;for (int i = 0;i < asles.length; i++){sum += sales[i];}System.out.println("总销售额：" + sum);10.动态初始化数组：
动态初始化就是在运行时，根据需要，动态地分配内存给数组，并初始化数组中的元素。
语法格式：数据类型[] 数组名 = new 数据类型[数组长度];
例如：int[] arr = new int[5];之后，可以使用数组名[索引] = 值; 的方式，对数组元素进行赋值。
11.两种数组定义的方式各自适合什么场景？
静态初始化适合数组的元素值个数和值已知的场景，例如：考试成绩、班级学生人数等。
动态初始化适合数组的元素个数已知，值未知的场景，例如：学生信息、商品信息等。
12.案例：
需求：某唱歌比赛，需要开发一个系统：可以录入6名评委的打分，录入完毕后，立即输入平均分作为选手得分。
分析：1.因为开始不知道评委打的分数，所以需要用动态初始化的方式定义数组。double[] scores = new double[6];2.通过Scanner 录入评委的打分 。Scanner sc = new Scanner(System.in);3.因为六个评委，需要采用循环for (int i =0 ; i < scores.length; i++){System.out.print("请输入第" + (i+1) + "名评委的打分：");scores[i] = sc.nextDouble("");}
4.计算平均分double sum = 0;for (int i = 0; i < scores.length; i++){sum += scores[i];}double average = sum / scores.length;System.out.println("平均分：" + average);13.java内存分配介绍
主要先看下面三个：
方法区：存储类信息、常量、静态变量、编译器编译后的代码等。字节码文件先加载到这里。
堆：存储对象实例，包括数组。new出来的东西会在这块内存中开辟空间并产生地址。
栈：存储局部变量、方法调用、返回地址等。方法运行时所进入的内存，变量也是在这
14.一个Java程序，主要看JVM中包含的哪几部分内存区域？
方法区
栈内存
堆内存
15.简单说说 int a = 20; int[] arr = new int[3]; 这两行代码的执行原理？
a是变量，直接放在栈中，a变量中存储的数据就是20这个值。
new int[3]是创建一个数组对象，会在堆内存中开辟区域存储3个整数。
arr是变量，在栈中，arr存储的是数组对象在堆内存中的地址值。
注：基本类型变量存储的是具体的值，而引用类型变量存储的是引用地址值。
16.多个数组变量，指向同一个数组对象的原因是什么？需要注意什么？
多个数组变量指向同一个数组对象，是因为数组在堆内存中开辟的区域是唯一的，所以多个数组变量指向同一个数组对象，可以节省内存。
多个变量修改的都是同一个数组对象，会影响到其他变量的值，所以需要注意。
17.如果某个数组变量存储的是null，会发生什么情况？
如果某个数组变量存储的是null，说明这个数组还没有被初始化，不能直接访问数组元素。
可以输出这个变量，但是不能用这个数组去访问数据或访问长度。否则会报空指针错误。
六、专项训练
1.数组求最值
在循环中用一个变量记录当前的最大值或最小值，然后在循环中不断比较更新，最后输出这个值。
建议变量的值定为数组中的第一个。
package com.zhl.Demo;public class Test1 {public static void main(String[] args) {//求最值int[] sales = {16,20,25,3,53,63,61,21,78,89,35,19};int max = sales[0];for(int i = 0; i < sales.length; i++){if(sales[i] > max){max = sales[i];}}System.out.println("最大值为："+ max);}
}2.数组反转
见Demo中的Test2
(1) 前后交换进行反转
(2)通过另外一个数组存储反转后的结果，然后进行赋值达到目的。
package com.zhl.Demo;public class Test2 {public static void main(String[] args) {//数组反转int[] sales = {16,20,25,3,53,63,61,21,78,89,35,29};int l = sales.length;int[] tem = new int[l];for (int i = 0; i < l;i++){//数组最后一位的索引是-1tem[i] = sales[l-i-1];}//将tem数组的值赋给sales数组sales = tem;//打印查看是否反转成功for (int i = 0; i < l;i++){System.out.print(sales[i] + " ");}System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");//方法二 通过中间变量 进行前后交换int[] arr = {1,2,3,4,5};for (int i = 0,j = arr.length-1; i < j; i++,j--){//arr[i] arr[j] 进行交换//定义一个中间变量 tempint temp = arr[i];arr[i] = arr[j];arr[j] = temp;}//打印查看是否反转成功for (int i = 0; i < arr.length;i++){System.out.print(arr[i] + " ");}}
}
3.随机排名
有五名人员进行汇报演讲，现采取随机排名的方式进行汇报。请依次录入五名员工的工号，然后展示一组随机的排名。
36 、27 、 18 、 45 、 32
思路：遍历索引，每遍历一个，然后随机生成一个位置的索引与当前遍历的索引交换顺序，达到随机的效果。
package com.zhl.Demo;import java.util.Random;
import java.util.Scanner;public class Test3 {public static void main(String[] args) {/*随机排名有五名人员进行汇报演讲，现采取随机排名的方式进行汇报。请依次录入五名员工的工号，然后展示一组随机的排名。36 、27 、 18 、 45 、 32思路：遍历索引，每遍历一个，然后随机生成一个位置的索引与当前遍历的索引交换顺序，达到随机的效果。*///1.定义一个动态初始化数组用于存储工号。int[] arr = new int[5];Scanner sc = new Scanner(System.in);//2.输入五名员工的工号for(int i=0;i<arr.length;i++){System.out.println("请输入第"+(i+1)+"名员工的工号：");int code = sc.nextInt();arr[i] = code;}//3.遍历索引，每遍历一个，然后随机生成一个位置的索引与当前遍历的索引交换顺序，达到随机的效果。Random r = new Random();for(int i=0;i<arr.length;i++){int j = r.nextInt(arr.length); // 生成一个随机位置的索引//交换int temp = arr[i]; // 临时变量先记录当前遍历的元素arr[i] = arr[j]; // 当前遍历的元素与随机位置的元素交换arr[j] = temp; // 随机位置的元素与临时变量交换}//4.展示随机的排名System.out.println("随机排名：");for(int i=0;i<arr.length;i++){System.out.println((i+1)+"名："+arr[i]);}}
}
七、DeBug的使用
1.DeBug的作用
调试是程序开发过程中必不可少的环节，通过调试可以找出程序中的错误，提高程序的质量。
基本使用。
断点调试：在程序运行到某一行代码时，暂停程序，查看变量的值，并可以修改变量的值，以便于查看程序运行的情况。
八、方法
1.方法是什么？
方法是一种语法结构，它可以把一段代码封装成一个功能，以便重复使用。
语法格式：修饰符 返回类型 方法名(参数列表){方法体;return 返回值;}2.方法定义时几个注意点：
方法的修饰符：暂时都使用 public static 修饰。
如果方法申明了具体 的返回值类型，内部必须使用return语句返回对应类型的数据。
形参列表可以有多个，甚至可以没有；如果有多个形参，多个形参必须用","隔开，且不能给初始值。
3.方法的好处
代码复用：可以将一些相同的功能封装成一个方法，在不同的地方调用，减少代码的重复。
隐藏细节：方法可以隐藏实现细节，使代码更加简洁，提高代码的可读性。
提高效率：方法可以提高代码的效率，减少重复代码的编写，提高代码的可维护性。
4.方法要执行必须怎么办？
方法要执行，必须先调用，调用的方法体才会执行。
调用方法的语法格式：方法名(参数列表);5.方法的其他形式
方法定义时：需要按照方法解决的实际业务需求，来设计合理的方法形式解决问题。
(1)如果方法不需要接收数据？不需要返回数据？应该怎么办，要注意什么？
方法不接收数据，则形参列表可以不写；方法不需要返回数据，则申明返回值为void。
方法没有申明返回值类型，则内部不能使用return语句，否则编译报错。
方法没有形参列表，则调用时不能传入参数值，否则会报错。
6.方法使用时常见的问题
1.方法在类中的位置放前方后无所谓，但一个方法不能定义在另一个方法里
2.方法的返回值类型写void(无返回申明)时，方法内不能使用return语句，否则编译报错，若写了返回值类型，则方法内必须有return语句
3.return语句的下面，不能编写代码，属于无效的代码，执行不到这，会报错，无意义。
4.方法不调用不会执行，调用时，传给方法的参数必须严格匹配方法的参数情况。
5.调用有返回值的方法，有三种方式：
1、可以定义变量的接收结果
2、或者直接输出调用
3、甚至直接调用。
6.调用无返回值的方法只有一种方式：直接调用。
7.设计方法的技巧，主要关注三方面：
1.方法是否需要接收数据进行处理？
2.方法是否需要返回数据？
3.方法主要处理的业务(编程能力)。
8.案例：
(1)求 1-n的和。
分析：
需要接收n的数据，需要返回计算结果。 结果和下一个在一起
(2)判断一个整数时奇数还是偶数。
分析：
需要接收一个整数，需要返回一个布尔值。 布尔值代表是否为奇数。（包含上一个的代码）
package com.zhl.method;public class MethodTes4 {public static void main(String[] args) {//目的：掌握方法设计的技巧System.out.println("1到5的和为："+add_1_n_sum(5));System.out.println("6是否是奇数："+judge(6));System.out.println("7是否是奇数："+judge(7));judge1(6);judge1(7);}public static int add_1_n_sum(int n){return (n * (n + 1)) / 2;}public static boolean judge(int n) {boolean flag;if (n % 2 ==0){flag = false;}else{flag = true;}return flag;}//或者可以这样写public static void judge1(int n){if (n % 2 ==0){System.out.println(n+"是偶数");}else{System.out.println(n+"是奇数");}}
}
9.方法在计算机中的执行原理
方法在调用的时候，是进入到栈内存中运行的。
栈：是先进后出的内存结构，存储局部变量、方法调用、返回地址等。
九、java的参数传递机制 (重要)
1.java的传递机制都是值传递
所谓值传递：指的是在传输实参给方法的形参的时候：传递的都是实参变量中存储的值的副本，而不是引用。
举例：
int a = 10;int b = a;a = 20;System.out.println(b); // 输出结果：10说明：
传递的是a的副本，而不是a的引用。
传递的是值，而不是地址。
注意：
对于基本数据类型，传递的是值，对于引用数据类型，传递的是引用，即数据的地址。
实参：方法定义内部的变量
形参：以方法为例，就是方法定义时的变量。
2.引用类型的传递
引用类型的传递：指的是在传递实参给方法的形参的时候：传递的都是实参变量中存储的地址的副本，而不是引用。
3.基本类型和引用类型的参数在值传递的时候有什么不同？
基本类型：传递的是值，实参变量中存储的值的副本。
引用类型：传递的是引用，实参变量中存储的地址的副本。
4.案例：
(1)输出一个int类型的数组，要求输出格式为：
[1,2,3,4,5]
分析：
需要一个接收一个Int类型的数组，然后输出，不需要返回值。
package com.zhl.memory;public class ArrayDemo1 {public static void main(String[] args) {// 目标 ：掌握普通变量、数组在计算机中的执行原理 ，java程序在计算机中的执行过程int a = 20;System.out.println(a);int[] arr = new int[]{13,25,67};System.out.println(arr);}
}
(2)比较两个数组是否一样？
int[] arr1 = {1,2,3,4,5}
int[] arr2 = {1,2,3,4,5}
package com.zhl.memory;public class ArrayDemo2 {public static void main(String[] args) {//目标：认识多个变量指向同一个数组对象的形式，并掌握其注意形式int[] arr1 = {11,13,57};//把int类型的数据变量arr1赋值给int类型数组变量arr2int[] arr2 = arr1;//地址相同System.out.println(arr1);System.out.println(arr2);//因为指向同一个地址，当一个被改后，另外一个数组也被修改arr2[1] = 99;System.out.println(arr1[1]);//注意：如果某个数组变量存储的地址是null，那么该变量将不再指向任何数组对象。arr1 = null;System.out.println(arr1);//访问数据时，则会报错,NullPointerException,因为没有数据可访问。//System.out.println(arr1[1]);//System.out.println(arr1.length);//也会报错}
}
十、方法的重载
1.方法的重载
在一个类中，出现多个方法的名称相同，但是他们的形参列表是不同的，那么这些方法就称为方法重载了。
2.注意事项：
在一个类中，只要有一些方法的名称相同，形参列表不同，那么他们就是方法重载了，其他的都不管(修饰符，返回值类型)
形参列表不同指的是：形参的个数、类型、顺序不同，不关心形参的名称。
3.案例：
开发一个武器系统，功能需求如下：
(1)可以默认发一枚导弹。
(2)可以指定地区发射一枚武器。
(3)可以指定地区发射多枚武器。
package com.zhl.overload;public class MethodTest2 {public static void main(String[] args) {//目的掌握重载方法的应用场景fire();fire("美国");fire("美国",99);}/*开发一个武器系统，功能需求如下：(1)可以默认发一枚导弹。(2)可以指定地区发射一枚武器。(3)可以指定地区发射多枚武器。*/public static void fire(){System.out.println("向漂亮的地方，发射一枚导弹");}public static void fire(String area){System.out.println("向"+area+"发射一枚武器");}public static void fire(String area,int count){System.out.println("向"+area+"发射"+count+"枚武器");}}
4.补充：return关键字在方法中单独使用
return关键字在无返回值的方法中，作用是：立即跳出并结束当前方法的执行，并将返回值返回给调用者。
5. return ; 跳出并立即结束所在方法的执行
break ; 跳出当前循环，结束循环
continue ; 跳出当前循环，继续下一次循环
：在商品对象创建系统中的应用)
