-
debug调试 循环语句
教学目标
- 能够独立完成猜数字游戏案例
- 能够独立完成评委打分案例
- 能够独立完成使用switch编写春夏秋冬案例
第一章 方法重载OverLoad 方法重写 Override
1.1 方法练习
/*
需求:
1.定义一个获取两个int数字之和的方法
2.定义一个获取三个int数字之和的方法
3.定义一个获取两个double数字之和的方法
4.定义一个获取三个double数字之和的方法
定义一个获取两个int数字之和的方法
三要素:
1.方法名称: getSum1
2.未知数据参加运算: int a,int b
3.是否产生结果数据: int
发现问题:
以下四个方法都是在完成求和功能,在参数列表上已经有区别了,但是我们起了四个不同的的名字,
这样导致程序员学习和使用的成本增加(记不住)
解决方案:
方法重载
*/
public class Demo01MethodProblem {
public static void main(String[] args) {
//调用方法: 输出调用
System.out.println(getSum1(10,20));
System.out.println(getSum2(10,20,30));
System.out.println(getSum3(10.0,20.0));
System.out.println(getSum4(10.0,20.0,30.0));
}
//1.定义一个获取两个int数字之和的方法
public static int getSum1(int a, int b) {
System.out.println("求两个int数字之和....");
return a + b;
}
//2.定义一个获取三个int数字之和的方法
public static int getSum2(int a, int b,int c) {
System.out.println("求三个int数字之和....");
return a + b + c;
}
//3.定义一个获取两个double数字之和的方法
public static double getSum3(double a, double b) {
System.out.println("求两个double数字之和....");
return a + b;
}
//4.定义一个获取三个double数字之和的方法
public static double getSum4(double a, double b,double c) {
System.out.println("求三个double数字之和....");
return a + b + c;
}
}
1.2 概念
-
方法重载：指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返回值类型无关。
-
多个方法在同一个类中
-
多个方法具有相同的方法名
-
多个方法的参数不相同，类型不同或者数量不同
-
-
注意
-
参数列表：个数不同，数据类型不同，顺序不同。
-
重载方法调用：JVM通过方法的参数列表，调用不同的方法。
-
-
使用方法重载完成以上练习
public class Demo02MethodOverLoad {
public static void main(String[] args) {
//调用方法: 输出调用
System.out.println(getSum(10,20));
System.out.println(getSum(10,20,30));
System.out.println(getSum(10.0,20.0));
System.out.println(getSum(10.0,20.0,30.0));
}
//1.定义一个获取两个int数字之和的方法
public static int getSum(int a, int b) {
System.out.println("求两个int数字之和....");
return a + b;
}
//2.定义一个获取三个int数字之和的方法
public static int getSum(int a, int b,int c) {
System.out.println("求三个int数字之和....");
return a + b + c;
}
//3.定义一个获取两个double数字之和的方法
public static double getSum(double a, double b) {
System.out.println("求两个double数字之和....");
return a + b;
}
//4.定义一个获取三个double数字之和的方法
public static double getSum(double a, double b,double c) {
System.out.println("求三个double数字之和....");
return a + b + c;
}
}
1.2 方法重载注意事项一
/*
参数列表不同有哪些情况,可以构成重载?
1.参数的数量不同
2.参数的类型不同
3.多个类型顺序不同
方法重载关键看: 在方法名称相同的前提下,参数列表必须要有本质(名称不算)的区别
*/
public class Demo03MethodOverLoad {
public static void main(String[] args) {
}
//1.定义方法method,没有参数
public static void method() {
}
//2.定义方法method,有一个int参数
//1没有参数,2有一个参数,参数的数量不同,可以构成重载
public static void method(int a) {
}
//3.定义方法method,有一个double参数
//2有一个int参数,3有一个double参数,参数的类型不同,可以构成重载
public static void method(double a) {
}
//4.定义方法method,有一个int参数和一个double参数
public static void method(int a, double b) {
}
//5.定义方法method,有一个double参数和一个int参数
//4是先int后double,5是先double后int,多个类型顺序不同
public static void method(double a, int b) {
}
}
1.3 方法重载注意事项二
/*
方法重载与哪些因素无关?
1.与返回值类型无关
2.与参数名称无关
3.与修饰符无关
*/
public class Demo04MethodOverLoad {
public static void main(String[] args) {
}
//1.定义方法method,参数是一个int,一个double
public static int method(int a, double b) {
return 0;
}
//2.定义方法method,参数是一个int,一个double
//1返回int类型,2返回double类型,其它没有区别,不能构成重载,因为方法重载与返回值类型无关
/*public static double method(int a, double b) {
return 0.0;
}*/
//3.定义方法method,参数是一个int,一个double
//1.的参数名称叫a和b,3的参数名称叫c和d,其它没有却别,不能构成重载因为方法重载与参数名称无关
/*public static int method(int c, double d) {
return 0;
}*/
//4.定义方法method,参数是一个int,一个double
//1修饰符是public static,4修饰符是public,其它没区别,不能构成重载因为方法重载与修饰符无关
/*public int method(int a, double b) {
return 0;
}*/
}
1.4 方法重载练习
-
需求：判断哪些方法是重载关系。
public static void open(){}
public static void open(int a){}
static void open(int a,int b){}
public static void open(double a,int b){}
public static void open(int a,double b){}
public void open(int i,double d){}
public static void OPEN(){}
public static void open(int i,int j){}
第二章 Debug调试
2.1 什么是Debug模式
是供程序员使用的程序调试工具，它可以用于查看程序的执行流程，也可以用于追踪程序执行过程来调试程序。
使用IDEA的断点调试功能，查看程序的运行过程 Debug调试窗口介绍
2.2 Debug模式操作流程
-
如何加断点
-
选择要设置断点的代码行，在行号的区域后面单击鼠标左键即可
-
-
如何运行加了断点的程序
-
在代码区域右键Debug执行
-
-
看哪里
-
看Debugger窗口
-
看Console窗口
-
-
点哪里
-
点Step Into (F7)这个箭头，也可以直接按F7
-
-
如何删除断点
-
选择要删除的断点，单击鼠标左键即可
-
如果是多个断点，可以每一个再点击一次。也可以一次性全部删除
-
2.3 Debug查看求和
使用步骤:
1.在代码的第一行左侧空白(行号后面)处单击鼠标左键,添加断点
2.右键选择"debug...",进入断点调试界面
public class Demo01DeBugSum {
public static void main(String[] args) {
System.out.println("main...start....");
int a = 10;
int b = 20;
int sum = a + b;
System.out.println("sum="+sum);
System.out.println("main...end....");
}
}
2.4 Debug查看求和方法
public class Demo02DeBug {
public static void main(String[] args) {
System.out.println("main...start...");
method();
System.out.println("main...end...");
}
public static void method() {
for (int i = 1; i <= 5; i++) {
System.out.println(i);
}
return ;
}
}
/*
断点调试,演示有返回值的方法调用
*/
public class Demo03Debug {
public static void main(String[] args) {
System.out.println("main...start...");
int a = 10, b = 20;
int sum = getSum(a, b);
System.out.println("和: " + sum);
System.out.println("main...end...");
}
public static int getSum(int a, int b) {
int sum = a + b;
return sum;
}
}
第三章 方法的参数传递
3.1 参数传递的概念
-
可以理解当我们要调用一个方法时，我们会把指定的数值，传递给方法中的参数，这样方法中的参数就拥有了这个指定的值，可以使用该值，在方法中运算了。这种传递方式，我们称为参数传递。
-
在这里，定义方法时，参数列表中的变量，我们称为形式参数
-
调用方法时，传入给方法的数值，我们称为实际参数
3.2 基本数据类型作为方法参数
/*
参数传递概念:
当我们要调用一个方法时，我们会把指定的数值，传递给方法中的参数，
这样方法中的参数就拥有了这个指定的值，可以使用该值，在方法中运算了。
这种传递方式，我们称为参数传递。
形式参数:
在定义方法时,()中定义的变量,称为形式参数,定义时必须不能有值,方法被调用时,才会有值
实际参数:
在调用方法时,()中给定的参数(常量/变量),称为实际参数,如果是变量,则必须要有值
基本类型作为方法的形式参数
特点:
形式参数的改变,不会影响实际参数
原因:
基本类型作为参数,传递的是具体的数据值
每个方法都有自己的内存空间,所以每个方法内部的变量也有自己的内存空间,
即便是不同的方法内部定义了同名的变量,他们的内存空间不同,它们之间互不影响,互不干扰
*/
public class Demo03BaseVar {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println("ms..a="+a);//10
System.out.println("ms..b="+b);//20
//调用方法
change( a, b );//调用方法时,()中给出的参数,称为实际参数
System.out.println("me..a="+a);//10
System.out.println("me..b="+b);//20
}
//定义方法
public static void change(int a, int b) {//方法定义时,()中定义的变量,称为形式参数
System.out.println("cs..a="+a);//10
System.out.println("cs..b="+b);//20
a = a * 10;
b = b * 10;
System.out.println("ce..a="+a);//100
System.out.println("ce..b="+b);//200
return ;//结束方法,返回到调用处
}
}
注意：形式参数的改变不影响实际参数
3.3 基本数据类型作为方法参数调用图解
3.4 引用数据类型作为方法参数
/*
参数传递概念:
当我们要调用一个方法时，我们会把指定的数值，传递给方法中的参数，
这样方法中的参数就拥有了这个指定的值，可以使用该值，在方法中运算了。
这种传递方式，我们称为参数传递。
形式参数:
在定义方法时,()中定义的变量,称为形式参数,定义时必须不能有值,方法被调用时,才会有值
实际参数:
在调用方法时,()中给定的参数(常量/变量),称为实际参数,如果是变量,则必须要有值
引用类型作为方法的形式参数
特点:
形式参数的改变,会影响实际参数
通过形参找到堆内存空间的数组,修改元素值后,再通过实参看到的是修改后的数组内容
原因:
引用变量保存的是堆内存空间的地址值,调用方法传递的是地址值,
导致多个变量指向同一个数组,只要有一个变量修改的数组的元素,
其它变量看到的都是修改后的元素
*/
public class Demo04RefVar {
public static void main(String[] args) {
int[] a = new int[] {10,20};//数组变量a保存数组在堆内存空间的地址
System.out.println("ms..a[0]="+a[0]);//10
System.out.println("ms..a[1]="+a[1]);//20
//调用方法: 传递的是地址值
change( a );//调用方法时,()中给出的参数,称为实际参数
System.out.println("me..a[0]="+a[0]);//100
System.out.println("me..a[1]="+a[1]);//200
}
//定义方法
public static void change(int[] a) {//方法定义时,()中定义的变量,称为形式参数
System.out.println("cs..a[0]="+a[0]);//10
System.out.println("cs..a[1]="+a[1]);//20
a[0] = a[0] * 10;
a[1] = a[1] * 10;
System.out.println("ce..a[0]="+a[0]);//100
System.out.println("ce..a[1]="+a[1]);//200
return ;//结束方法,返回到调用处
}
}
注意：引用类型，作为方法参数，形式参数的改变会影响实际参数
3.5 引用数据类型作为方法参数调用图解
3.6 引用数据类型作为方法参数练习-评委打分
-
案例需求
在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。 选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。
-
思路
1:定义一个数组，用动态初始化完成数组元素的初始化，长度为6 2:键盘录入评委分数 3:由于是6个评委打分，所以，接收评委分数的操作，用循环改进 4:定义方法实现获取数组中的最高分(数组最大值)，调用方法 5:定义方法实现获取数组中的最低分(数组最小值) ，调用方法 6:定义方法实现获取数组中的所有元素的和(数组元素求和) ，调用方法 7:按照计算规则进行计算得到平均分 8:输出平均分
-
代码实现
import java.util.Scanner;
/*
引用数据类型作为方法参数练习-评委打分
案例需求
在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。
选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。
方法定义的实现步骤:
1.定义方法getArray,获取长度为6的int数组,代表6个评委的评分,元素值通过键盘录入
2.定义方法printArray,遍历输出一个int数组中的所有元素
3.定义方法getArrayAvg,计算一个int数组的平均分(总分-最高分-最低分后的平均分)
main方法的实现步骤:
1.调用getArray方法,获取int数组,保存到int数组变量array中
2.调用printArray方法,打印6个评委的评分
3.调用getArrayAvg方法,获取平均分结果,保存到int变量avg中
4.打印avg的值
*/
public class Demo06Score {
public static void main(String[] args) {
//1.调用getArray方法,获取int数组,保存到int数组变量array中
int[] array = getArray();
//2.调用printArray方法,打印6个评委的评分
System.out.print("6个评委的评分: ");
printArray(array);
//3.调用getArrayAvg方法,获取平均分结果,保存到int变量avg中
int avg = getArrayAvg(array);
//4.打印avg的值
System.out.println("6个评委的最终评分的平均分(去掉最大值和最小值): "+avg);
}
/*
1.定义方法,获取长度为6的int数组,代表6个评委的评分,元素值通过键盘录入
三要素:
(1)方法名称: getArray
(2)是否有未知数据参加运算: 没有,不需要定义参数
(3)是否产生结果数据: int[]
*/
public static int[] getArray() {
//1.创建长度为6的int数组,采用动态初始化
int[] array = new int[6];
//2.创建键盘录入Scanner类的对象
Scanner sc = new Scanner(System.in);
//3.获取6个评委的评分,存储到数组中
for (int i = 0; i < array.length; i++) {
System.out.println("请输入第" + (i + 1) + "个评委的评分: ");
array[i] = sc.nextInt();
}
return array;
}
/*
2.定义方法printArray,遍历输出一个int数组中的所有元素
三要素:
(1)方法名称: printArray
(2)是否有未知数据参加运算: int[] array
(3)是否产生结果数据: 没有结果,返回值类型void
打印格式要求:
数组: {60,70,80,90}
打印格式:[60, 70, 80, 90]
*/
public static void printArray(int[] array) {
//1.打印"[",不换行
System.out.print("[");
//2.使用for循环遍历数组
for (int i = 0; i < array.length; i++) {
//2.1 如果当前元素不是最后一个元素,打印 元素 + ", ",不换行
if (i != array.length - 1) {
System.out.print(array[i] + ", ");
} else {
//2.2 如果当前元素是最后一个元素,打印 元素,不换行
System.out.print(array[i]);
}
}
//3.打印"]",换行
System.out.println("]");
}
/*
3.定义方法getArrayAvg,计算一个int数组的平均分(总分-最高分-最低分 后的平均分)
三要素:
(1)方法名称: getArrayAvg
(2)是否有未知数据参加运算: int[] array
(3)是否产生结果数据: int
*/
public static int getArrayAvg(int[] array) {
//1.定义int变量sum,初始值0,用来累加求和
int sum = 0;
//2.假设索引0元素是最大的,保存到int变量max中
int max = array[0];
//3.假设索引0元素是最小的,保存到int变量min中
int min = array[0];
//4.使用for循环遍历数组array
for (int i = 0; i < array.length; i++) {
//5.把当前元素,累加到求和变量中
sum += array[i];
//6.只要当前元素 大于 max,说明max中已经不是最大的了
if (array[i] > max) {
//7.把当前元素值 赋值给max
max = array[i];
}
//8.只要当前元素 小于 min,说明min中已经不是最小的了
if (array[i] < min) {
//9.把当前元素值 赋值给min
min = array[i];
}
}
//10.根据题目需求计算平均值
int avg = (sum - max - min)/(array.length-2);
//11.返回结果
return avg;
}
}
第四章 随机数
4.1 Random产生随机数（掌握）
-
概述：
-
Random类似Scanner，也是Java提供好的API，内部提供了产生随机数的功能
-
API后续课程详细讲解，现在可以简单理解为Java已经写好的代码
-
-
使用步骤：
-
导入包
import java.util.Random;
-
创建对象
Random r = new Random();
-
产生随机数
int num = r.nextInt(10);
解释： 10代表的是一个范围，如果括号写10，产生的随机数就是0(包括)-9(包括)，括号写20，参数的随机数则是0(包括)-19(包括)
-
-
使用Random类，完成生成3个10以内的随机整数的操作，代码如下：
/* java.util.Random类: 就是用来帮助我们产生随机数字的,也是引用类型,使用有3个固定的步骤 1.导包: import 包名.类名; Random类导包: import java.util.Random; 2.创建对象: 类名 对象名 = new 类名(参数...); 键盘录入对象: Scanner sc = new Scanner(System.in); 注意: System.in目前是固定写法 随机数Random类的对象: Random r = new Random(); 注意:右侧()中什么都不用写,目前是固定写法 3.使用: r.nextInt(): 产生一个int范围(正负21亿)内的随机数字 r.nextInt(整数常量或者int类型变量 n): 产生一个0(包含)到n(不包含n)之间的随机数字 举例: r.nextInt(10): 产生一个0(包含0)到10(不包含10)之间的随机数字 [0,10) 等价于 [0,9] r.nextInt(100): 产生一个0(包含0)到100(不包含10)之间的随机数字 [0,100) 等价于 [0,99] 4.练习: (1)产生10个int范围内的随机数字 (2)产生10个1(包含1)到100(包含100)之间的随机数字 r.nextInt(100): 0,1,2,3......99 r.nextInt(100) + 1: 0,1,2,3......99 + 1 -------------------- 1,2,3......99,100 */ public class Demo05Random { public static void main(String[] args) { //创建Random类的对象 Random r = new Random(); //(1)产生10个int范围内的随机数字 for (int i = 0; i < 10; i++) { //产生1个int范围内的随机数字,保存到int变量num中 int num = r.nextInt(); System.out.println(num); } System.out.println("-------------"); //(2)产生10个1(包含1)到100(包含100)之间的随机数字 for (int i = 0; i < 10; i++) { //产生1个1(包含1)到100(包含100)之间的随机数字 int num = r.nextInt(100) + 1; System.out.println(num); } System.out.println("-------------"); while(true) { //产生1个1(包含1)到100(包含100)之间的随机数字 int num = r.nextInt(100) + 1; System.out.println(num); /*if (num == 1 || num == 100) { break; }*/ if (num == 0 || num == 101) { break; } } } }
4.2 Random练习-猜数字
-
需求：程序自动生成一个1-100(包含1和100)之间的数字，使用程序实现猜出这个数字是多少？
-
效果：
-
如果猜的数字比真实数字大，提示你猜的数据大了
-
如果猜的数字比真实数字小，提示你猜的数据小了
-
如果猜的数字与真实数字相等，提示恭喜你猜中了
-
-
代码实现
/* Random练习-猜数字 需求：程序自动生成一个1-100(包含1和100)之间的数字，使用程序实现猜出这个数字是多少？ 效果： 如果猜的数字比真实数字大，提示你猜的数据大了 如果猜的数字比真实数字小，提示你猜的数据小了 如果猜的数字与真实数字相等，提示恭喜你猜中了 实现步骤: 1.创建Random类的对象 2.产生一个1-100(包含1和100)之间的数字保存到int变量guessNum中,以供大家猜测 3.创建键盘录入Scanner类的对象 4.到底多少次可以猜对,是不确定的,使用死循环(while(true)) 4.1 获取键盘录入的用户猜测的数字,保存到int变量inputNum中 4.2 判断 如果用户猜测的inputNum中的数字 等于 产生的 guessNum 中的数字,说明猜对了 提示: "恭喜你猜中了" 使用break,结束循环 4.3 判断 如果用户猜测的inputNum中的数字 小于 产生的 guessNum 中的数字,说明没猜对 提示: "你猜的数据小了" 4.4 判断 如果用户猜测的inputNum中的数字 大于 产生的 guessNum 中的数字,说明没猜对 提示: "你猜的数据大了" */ public class Demo06GuessNum { public static void main(String[] args) { //1.创建Random类的对象 Random r = new Random(); //2.产生一个1-100(包含1和100)之间的数字保存到int变量guessNum中,以供大家猜测 int guessNum = r.nextInt(100) + 1; //3.创建键盘录入Scanner类的对象 Scanner sc = new Scanner(System.in); //4.到底多少次可以猜对,是不确定的,使用死循环(while(true)) while (true) { //4.1 获取键盘录入的用户猜测的数字,保存到int变量inputNum中 System.out.println("请输入您猜测的数字(1到100之间的): "); int inputNum = sc.nextInt(); //4.2 判断 如果用户猜测的inputNum中的数字 等于 产生的 guessNum 中的数字,说明猜对了 if (inputNum == guessNum) { //提示: "恭喜你猜中了" System.out.println("恭喜你猜中了"); //使用break,结束循环 break; } else if (inputNum < guessNum) { //4.3 判断 如果用户猜测的inputNum中的数字 小于 产生的 guessNum 中的数字,说明没猜对 //提示: "你猜的数据小了" System.out.println("你猜的数据小了"); } else { //4.4 判断 如果用户猜测的inputNum中的数字 大于 产生的 guessNum 中的数字,说明没猜对 //提示: "你猜的数据大了" System.out.println("你猜的数据大了"); } } } }
第五章 选择语句
5.1 选择语句--switch
-
switch语句格式：
1.switch语句的格式:
switch(表达式) {
case 常量值1:
语句体1;
break;
case 常量值2:
语句体2;
break;
...
case 常量值n:
语句体n;
break;
default:
语句体n+1;
break;
}
其它语句;
2.执行流程:
(1)首先计算出表达式的值
(2)其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
(3)最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
3.注意事项:
(1)switch语句()中表达式的类型: byte/short/char/int String/枚举 ---最重要的---
(2)case后面必须写常量,而且不能重复,常量的类型要和表达式的结果类型匹配
(3)switch和后面的(),以及()和{}之间都没有分号,case后面常量值的后面是冒号不是分号
(4)break是用来结束switch语句的,一旦遇到break,直接结束switch语句,
继续执行switch后面的其它语句
(5)default是用来兜底的,如果所有的case的常量值和表达式的结果都不相同,直接执行default中的代码
(6)如果每个case和default后面都有break,那么case和default的顺序可以任意调整,不影响结果
(7)如果default放在最后的话,那么可以省略default中的break
(8)语句体: 一条/多条语句(根据题目需求确定)
-
执行流程
-
首先计算出表达式的值
-
其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
-
最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
-
public class Demo06Switch {
public static void main(String[] args) {
int choose = 1;
switch (choose) {
case 1:
System.out.println("你好");
break;
case 2:
System.out.println("我好");
break;
case 3:
System.out.println("大家好,才是真的好");
break;
case 4:
System.out.println("他好,我也好");
break;
default:
System.out.println("一切安好");
break;
}
System.out.println("game...over....");
}
}
-
switch语句练习-春夏秋冬
-
需求：一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份，请用程序实现判断该月份属于哪个季节，并输出。
-
演示效果
输入： 1、2、12 输出：冬季
输入： 3、4、5 输出：春季
输入： 6、7、8 输出：夏季
输入： 9、10、11 输出：秋季
输入：其它数字 输出：数字有误
-
/*
实现步骤:
1.创建键盘录入Scanner类的对象
2.获取键盘录入的1到12之间的代表月份的整数数字,保存到int变量month中
3.因为month中的值有12+1种情况,使用switch判断month中的值,输出对应的季节
*/
public class Demo07SwitchMonth {
public static void main(String[] args) {
//1.创建键盘录入Scanner类的对象
Scanner sc = new Scanner(System.in);
//2.获取键盘录入的1到12之间的代表月份的整数数字,保存到int变量month中
System.out.println("请输入1到12之间的代表月份的整数数字: ");
int month = sc.nextInt();
//3.因为month中的值有12+1种情况,使用switch判断month中的值,输出对应的季节
switch (month) {//1
case 1:
System.out.println("冬季");
break;
case 2:
System.out.println("冬季");
break;
case 12:
System.out.println("冬季");
break;
case 3:
System.out.println("春季");
break;
case 4:
System.out.println("春季");
break;
case 5:
System.out.println("春季");
break;
case 6:
System.out.println("夏季");
break;
case 7:
System.out.println("夏季");
break;
case 8:
System.out.println("夏季");
break;
case 9:
System.out.println("秋季");
break;
case 10:
System.out.println("秋季");
break;
case 11:
System.out.println("秋季");
break;
default:
System.out.println("您输入的月份不存在,火星来的吧,哥屋恩....");
break;
}
System.out.println("game...over...");
}
}
switch语句中，表达式的数据类型，可以是byte，short，int，char，enum（枚举），JDK7后可以接收字符串。
5.2 case的穿透性
在switch语句中，如果case的后面不写break，将出现穿透现象，也就是不会在判断下一个case的值，直接向后运行，直到遇到break，或者整体switch结束。
package com.itheima06;
import java.util.Scanner;
/*
switch语句练习-春夏秋冬
发现问题:
多个连续的case中,有相同的代码和break,此时可以优化
解决方案:
只保留最后一个case中的代码和break,前面的若干个case中的代码和break,全部省略
case穿透:
找到第一个常量值和表达式值相同的case后,从该case中的代码一直向下执行,直到遇到break才会结束switch语句
*/
public class Demo08SwitchMonth {
public static void main(String[] args) {
//1.创建键盘录入Scanner类的对象
Scanner sc = new Scanner(System.in);
//2.获取键盘录入的1到12之间的代表月份的整数数字,保存到int变量month中
System.out.println("请输入1到12之间的代表月份的整数数字: ");
int month = sc.nextInt();
//3.因为month中的值有12+1种情况,使用switch判断month中的值,输出对应的季节
switch (month) {//1
case 1:
case 2:
case 12:
System.out.println("冬季");
break;
case 3:
case 4:
case 5:
System.out.println("春季");
break;
case 6:
case 7:
case 8:
System.out.println("夏季");
break;
case 9:
case 10:
case 11:
System.out.println("秋季");
break;
default:
System.out.println("您输入的月份不存在,火星来的吧,哥屋恩....");
break;
}
System.out.println("game...over...");
}
}
第六章 循环嵌套
6.1 需求: 打印3行5列的星
/*
需求: 打印3行5列的星
循环嵌套:
1.概念: 使用一个循环作为另外一个循环的循环体,外部的循环叫做外层循环,内部的循环叫做内层循环
2.格式:
for(外初始化表达式1;外循环条件2;外步进表达式7){
for(内初始化表达式3;内循环条件4;内步进表达式6){
内循环体5;
}
}
其它语句8;
3.注意:
(1)外层循环初始化表达式 int i = 1 执行了几次? 1次
(2)内层循环初始化表达式 int j = 1 执行了几次? 3次
(3)总结:
外层循环执行1次,内层循环要执行完整的一遍
内层循环的循环体执行的次数:
外层循环执行的次数 * 内层循环每遍执行的次数
*/
public class Demo07ForFor {
public static void main(String[] args) {
//使用for循环优化,打印5个星的代码
for (int i = 1; i <= 3; i++) {//外层循环: 执行3次
for (int j = 1; j <= 5; j++) {//内层循环: 每遍执行5次
System.out.print("*");
}
System.out.println();
}
}
}
6.2 循环嵌套
1.概念: 使用一个循环作为另外一个循环的循环体,内部的循环叫做内层循环,外面的循环叫做外层循环
2.格式:
for(初始化表达式1;布尔表达式2;步进表达式7) {
for(初始化表达式3;布尔表达式4;步进表达式6){
循环体5;
}
}
其它语句8;
3.执行流程:
1,2(true),3,4(true),5,6 --> 4(true),5,6 --> ... --> 4(false),内层循环结束,7
--> 2(true),3,4(true),5,6 --> 4(true),5,6 --> ... --> 4(false),内层循环结束,7
--> ...
--> 2(false),结束外层循环
6.3 练习
使用嵌套循环，打印2021年至2023年月份，格式：xxxx年x月
/*
1.使用循环嵌套:
打印2021年至2023年月份，格式：xxxx年x月
2.注意:
(1)外层循环初始化表达式 int year = 2021 执行了几次? 1次
(2)内层循环初始化表达式 int month = 1 执行了几次? 3次
(3)总结:
外层循环执行1次,内层循环要执行完整的一遍
内层循环的循环体执行的次数: 3 * 12 = 36
*/
public class Demo08ForForMonth {
public static void main(String[] args) {
for (int year = 2021; year <= 2023; year++) {//外层循环: 获取年份,循环3次
for (int month = 1; month <= 12; month++) {//内层循环: 获取每年的12个月份,每遍执行12次
System.out.println(year + "年" + month + "月");
}
}
}
}
9万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
