Java入门第四天_int record = scan.nextint();用这张方式如何定义date类型的数据-CSDN博客

本文链接：https://blog.csdn.net/ldq120132796/article/details/113677477

本文详细介绍了Java中的程序流程控制结构，包括Scanner类的使用，以及if-else和switch-case的语法、使用场景和实践示例。讲解了如何从键盘获取输入，if-else的多重条件判断以及switch-case的执行逻辑，并提供了多个实际应用的练习题，帮助读者深入理解这两种控制结构。

摘要由CSDN通过智能技术生成

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

前言

今天主要复习程序流程控制，主要包括 if-else 、 switch-case ，顺序结构就是从前到后，从上到下执行，不再赘述。首先需要了解一个小知识：从键盘输入字符。

一、Scanner

如何从键盘获取不同类型的变量：需要使用Scanner类

具体实现步骤：
1. 导包：import java.util.Scanner; //写在类的前面
2. Scanner的实例化
3. 调用Scanner类的相关方法( next() / nextXxx() )，来获取指定类型的变量(只能调用一次，多次调用会报错)

注意：
	需要根据相应的方法，来输入指定类型的值。如果输入的数据类型
	与要求的类型不匹配是，会报异常：InputMisMatchException，导
	致程序终止。

代码如下（示例）：

//1. 导包（写在类前面）
import java.util.Scanner;

class ScannerTest {
	public static void main(String[] args) {
		//2. Scanner实例化
		Scanner scan = new Scanner(System.in);
		//3. 调用Scanner类的相关方法，来获取指定类型的变量
		int num = scan.nextInt();
		System.out.println(num);

		//*******************************************************
		//相亲网站信息获取

		//Scanner scan = new Scanner(System.in); 此时再次Scanner实例化，则报错，因为他只能调用一次
		System.out.print("请输入您的姓名：");
		String name = Scan.next();//读取String类型的数据时，用next()而非nextString()
		System.out.println(name);

		System.out.print("请输入您的芳龄：");
		int age = scan.nextInt();
		System.out.println(age);

		System.out.print("请输入您的体重：（kg）");
		double weight = scan.nextDouble();
		System.out.println(weight);		

		System.out.print("您是否相中他/（她）了呢？");
		String isLove = scan.next();
		System.out.println(isLove);

		System.out.print("请输入您的性别：（男/女）");
		String gender = scan.next();//Scanner并没有提供相关方法，获取char型字符
		char genderChar = gender.charAt(0);//获取索引为0位置上的字符
		System.out.println(genderChar);
	}
}

二、分支结构：if-else、switch-case

1.if-else结构

1.1介绍

if 语句三种格式：

/*
	格式一：
		if(条件表达式) {
		执行代码块;

	格式二：
		if(条件表达式) {
			执行代码块1;
		}else {
			执行代码块2;
		}

	格式三：
		if(条件表达式1) {
			执行代码块1;
		}else if(条件表达式2) {
			执行代码块2;
		}
		······
		else {
			执行代码块n;
		}
*/
}

1.2使用说明

条件表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量
语句块只有一条执行语句时，一对{ }可以省略，但建议保留
if-else语句结构，根据需要可以嵌套使用。
当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略
当多个条件是“互斥”关系时，条件判断句及执行语句间顺序无所谓；当多个条件是“包含”关系时，“小上下大/子上父大”（这句话有点晦涩，自己看两个案例就很清楚了）

1.3 if-else应用举例

① 岳小鹏参加Java考试，他和父亲岳不群达成承诺：
如果：

	  成绩为100分时，奖励一辆BMW；
	  成绩为(80，99]时，奖励一台iphone xs max；
	  当成绩为[60,80]时，奖励一个 iPad；
	  其它时，什么奖励也没有。

	  请从键盘输入岳小鹏的期末成绩，并加以判断

import java.util.Scanner;

class IfTest {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);

		System.out.println("请输入岳小鹏此次的成绩：（0-100）");
		double grade = scan.nextDouble();

		if((grade > 100) || (grade < 0)) {
			System.out.println("输入错误，请重新输入！");
			//这里直接用grade重新接收输入的数据即可，如果再次用double
			grade = scan.nextDouble();
		}else if (grade == 100) {	//这里的等号和赋值号要注意区分！下次不能再错了
			System.out.println("奖励一台BMW");
		}else if ((grade > 80) && (grade <= 99)) {	//不能写成（80 < grade <= 99）,80 < grade运行结果为一个布尔型，无法和90进行比较
			System.out.println("奖励一台iPhone xs max");
		}else if ((grade <= 80) && (grade >= 60)) {
			System.out.println("奖励一个iPad");
		}else {
			System.out.println("无谓");
		}
	}
}

说明：

else结构是可选的（即最后的else可加可不加，不加就不是一定执行一个语句了，可能一个也不执行）。
针对于条件表达式：
如果多个条件表达式之间有“互斥”关系（或没有交集关系），哪个判断和执行语句先执行都无所谓（在上面/下面）；
如果多个条件表达式之间有“交集”关系，需要根据实际情况考虑清楚应该将哪个结构声明在上面；
如果多个条件表达式之间有“包含”关系，通常情况下，需要将范围小的声明在范围大的上面，否则范围小的就没机会执行了。

② 编写程序：由键盘输入三个整数分别存入变量num1、num2、num3，对它们进行排序(使用 if-else if-else),并且从大到小输出。

import java.util.Scanner;
class IfTest2 {
	public static void main(String[] args){
		Scanner scan = new Scanner(System.in);
		
		//输入三个整数：num1、num2、num3
		System.out.print("请输入整数num1：");
		int num1 = scan.nextInt();
		
		System.out.print("请输入整数num2：");
		int num2 = scan.nextInt();

		System.out.print("请输入整数num3：");
		int num3 = scan.next();

		//此时已经完成了输入部分，接下来开始进行判断大小并输出
		//我们可以先确定两个数的大小，第三个数就只有在两者之间、在最左、在最右三种情况
		if (num1 > num2) {
			if (num3 > num1) {
				System.out.println(num3 + "," + num1 + "," + num2);//这里想美观一点，在逗号后面打了个空格，结果无效
			}else if (num3 < num2) { 
				System.out.println(num1 + "," + num2 + "," + num3);
			}else {
				System.out.println(num1 + "," + num3 + "," + num2);
			}
		}else { //num1 < num2
			if (num3 < num1) {
				System.out.println(num2 + "," + num1 + "," + num3);
			}else if (num3 > num2) {
				System.out.println(num3 + "," + num2 + "," + num1);
			}else {
				System.out.println(num1 + "," + num2 + "," + num3);
			}
		}
		//Ps：这是我看过最简单的算法了，自己写的太冗余了，拿不出手QAQ
		
	}
}

说明：

if-else是可以互相嵌套的
虽然if-else后面的大括号虽然在执行语句只有一行时可以省略，但是不省略是一种良好的习惯（听说不想被同时打死就得加~）

③ 练习1：声明两个int型变量并复制，判断两数之和，如果大于等于50，打印“Hello World”

		int num1 = 25;
		int num2 = 27;
		int add;
		add = num1 + num2;
		if(add > 50){
			System.out.println("hello world!");
		}
		//今日错误：cd 进入IfExer文件夹，用了cd /IfExer,应该用cd IfExer

④ 练习2：声明2个double型变量并赋值。判断第一个数大于10.0，且第2个数小于20.0，打印两数之和。否则，打印两数的乘积。

		double num_1 = 20.0;
		double num_2 = 11.0;
		if((num_1 > 10.0) && (num_2 < 20.0)){
			System.out.println("num_1 + num_2 = " + (num_1 + num_2));
		}else{
			System.out.println("num_1 * num_2 = " + (num_1 * num_2));
		}

⑤ 练习3：我家的狗5岁了，5岁的狗相当于人类多大呢？其实，狗的前两年每一年相当于人类的10.5岁，之后每增加一年就增加四岁。那么5岁的狗相当于人类多少年龄呢？应该是：10.5 + 10.5 + 4 + 4 + 4 = 33岁。

	编写一个程序：获取用户输入的狗的年龄，通过程序显示其相当于人类的年龄。如果用户输入负数，请显示一个提示信息。

		System.out.println("请输入狗狗的年龄：（岁）");
		double age = scan.nextDouble();//接收狗的年龄		
		double ageOfHuman = 0;//系统要求初始化变量
		/*
			在类中定义的成员变量如果没有初始化，Java会自动帮你初始化，如果是数字会自动
			初始化为0，字符会初始化为'0'，对象引用会初始化为null，当然如果你定义的是局
			部变量就必须初始化，否则编译会报错，这正是java的特点，极大地提高了代码安全性
		*/

		if(age < 0){
			System.out.println("输入错误，请重新输入一个正整数！");
			age = scan.nextDouble();
			
			if(age <= 2.0){
			ageOfHuman = age * 10.5;
			}else{
				ageOfHuman = 21.0 + (age - 2.0) * 4.0;
			}

		System.out.println(age + "的狗狗相当于人类的" + ageOfHuman + "岁。");

⑥ 练习4：假设你想开发一个玩彩票的游戏，程序随机地产生一个两位数的彩票，提示用户输入一个两位数，然后按照下面的规则判定用户是否能赢。

			1)如果用户输入的数匹配彩票的实际顺序，奖金10 000美元。
			2)如果用户输入的所有数字匹配彩票的所有数字，但顺序不一致，奖金 3 000美元。
			3)如果用户输入的一个数字仅满足顺序情况下匹配彩票的一个数字，奖金1 000美元。
			4)如果用户输入的一个数字仅满足非顺序情况下匹配彩票的一个数字，奖金500美元。
			5)如果用户输入的数字没有匹配任何一个数字，则彩票作废。

//由于这个涉及到新知识，所以给出全部代码
import java.util.Scanner;
class IfExer {
	public static void main(String[] args){
		/*创建一个随机数（随机数为double型）
		double value = Math.random();//	随机数[0.0,1.0)
		double value = Math.random() * 100;	//随机数[0.0-1.0) --> [0.0,100.0)
		*/
		//创建一个[10,100)的int型随机数
		int value = (int)(Math.random() * 90 + 10);	//强制转换为int型，[0.0,1.0) --> [0.0,90.0) --> [10.0,100.0) -强制转换-> [10,99]
		System.out.println(value);//输出随机数value，方便测试
		
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入您想购买的彩票数字（10-99）：");
		int num = scan.nextInt();

		int value1 = 0,value2 = 0;//value为用户输入数字num的十位，value2为个位（不能写成int value1 = value2 = 0;）
		value1 = num / 10;
		value2 = num % 10;

		if((value1 * 10 + value2) == value) {
			System.out.println("恭喜您中奖了，中奖金额：10000美元");
		}else if (value2 * 10 + value1) {
			System.out.println("恭喜您中奖了，中奖金额：3000美元");
		}else if ((value1 == value / 10) || (value2 == value % 10)) {
			System.out.println("恭喜您中奖了，中奖金额：1000美元");
		}else if ((value2 == value /10) || (value1 == value % 10)) {
			System.out.println("恭喜您中奖了，中奖金额：500美元");
		}else {
			System.out.println("很遗憾，您未中奖！");
		}
	}
}

2. switch-case结构

2.1 格式

siwtch(表达式){
case 常量1:
		执行语句1;
		//break;		
case 常量2:
		执行语句2;
		//break;		
……	
default:
		执行语句n;
		//break;	
	}

2.2 使用说明

根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应的case语句中，
调用其执行语句。当调用完执行语句之后，则仍然继续向下执行其他case结构中的执行语句，直到遇
到break关键字或次switch-case结构末尾结束为止。

break，可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构

switch结构中的表达式，只能是如下的6中类型之一：
byte、short、char、int、枚举类型（JDK5.0新增）、String类型（JDK6.0新增）

case之后只能声明常量，不能为变量

break关键字是可选的，根据实际情况自己选择加不加。

default：相当于if-else中的else（备胎,指舔到最后应有尽有的那种）。
default结构是可选的，而且位置是灵活的（可以放在开头或者几个case中间）。

凡是可以使用switch-case的结构，都可以转换为if-else，反之不成立。
我们写分支结构时，当发现既可以使用if-else，又可以使用switch-case（同时，分支又不多）时，
优先使用switch-case，原因是执行效率高。

class  SwitchCaseTest{
	public static void main(String[] args) {
		
		int num = 2;
		switch(num){
		
		case 0:
			System.out.println("zero");
			//break;
		case 1:
			System.out.println("one");
			//break;
		case 2:
			System.out.println("two");
			//break;
		

		//default放在前面，起到的效果和case一样，执行语句里没有break，还是会执行下一个语句
		/*
		default:
			System.out.println("other");
		*/
		
		
		case 3:
			System.out.println("three");
			//break;
		default:
			System.out.println("other");
			//已经是最后一行了，break; 加不加无所谓
		}

		//*******************如下两种情况变量不通过********************
		
		/*
		情况一：
		boolean isHandsome = true;
		switch(isHandsome){	//boolean类型不能用于switch条件表达式
		
		case true:
			System.out.pritnln("好帅啊~~~");
		case false:
			System.out.pritnln("好丑啊~~~");
		default:
			System.out.pritnln("一般般吧~~~");
		*/

		/*
		情况二：
		int age = 10;
		switch(age){
		
		case age < 18:	//条件表达式中age是int型，age < 18为boolean，无法匹配
			System.out.println("未成年");
		default:
			System.out.pritnln("成年了");
		}
		*/
		}
	}
}

2.3 练习题

1. 使用 switch 把小写类型的 char型转为大写。只转换 a, b, c, d, e，其它的输出 “other”。

import java.util.Scanner;
class SwitchExer {
	public static void main(String[] args){
		Scanner scan = new Scanner(System.in);

		System.out.println("请输入要转换的字符（a-e）：");
		String strCh = scan.next();
		char ch = strCh.charAt(0);
		
		/*
		方法1：使用if-else替代default
		if((ch < 'a') || (ch > 'e')){
			System.out.println("other");
		}else {
			switch(1) {
			case 1 : char c = (char)(ch - 32);
					 System.out.println("转换后的结果是：" + c);	
					 //这里两句可以一起写成System.out.println("转换后的结果是：" + (char)(ch - 32));
					 /*
					 	不能写成：
					 	switch (ch) {
						case ch : System.out.println(ch - 32);
						}
							这样写，错误如下：
							>switch表达式虽然可以是char型，但是case不行，还是需要一个常量，即使此时ch已经有了一个值，
							但是任然被看做是变量，而case需要一个常量
							
							>ch - 32 是char与int之间的运算，结果自动转换为int型，即如果 ch == 'a'，结果应该是65（a的ASCII码为97）
					*/
			}
		}
		*/


		//方法2
		switch (ch) {
		case 'a' : System.out.println("A");
		case 'b' : System.out.println("B");
		case 'c' : System.out.println("C");
		case 'd' : System.out.println("D");
		case 'e' : System.out.println("E");
		default : System.out.println("other");
		}

	}
}

2. 对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。

System.out.print("请输入学生成绩：");
		int score = scan.nextInt();

		int flag = 1;	//默认为合格，flag = 1

		if((score < 0) || (score > 100)){
			System.out.println("输入错误，请输入正确的分数：");
			score = scan.nextInt();
			
		}else if(score < 60){
				flag = 0;	//如果成绩小于60，不合格，flag = 0
		 }
		
		switch(flag){
		
		case 0 : System.out.println("不合格");
				 break;
		default : System.out.println("合格");
				 break;
		}

3. 根据用于指定月份，打印该月份所属的季节。 3,4,5 春季 6,7,8夏季 9,10,11秋季 12, 1, 2 冬季

System.out.println("请输入月份，以此来判断季节（1-12）：");
		int season = scan.nextInt();

		switch(season){
		
		case 3:
		case 4:
		case 5: System.out.println(season + "月是春季");
				break;

		case 6:
		case 7:
		case 8: System.out.println(season + "月是夏季");
				break;

		case 9:
		case 10:
		case 11: System.out.println(season + "月是秋季");
				 break;
		case 12:
		case 1:
		case 2: System.out.println(season + "月是冬季");
				break;

		default: System.out.println("输入错误！请输入正确的月份！");
		}

4. 从键盘分别输入年、月、日，判断这一天是当年的第几天

			注：判断一年是否是闰年的标准：
			1）可以被4整除，但不可被100整除
			或
			2）可以被400整除

//从键盘读取年、月、日
		System.out.println("请输入正确的年份：");
		int year = scan.nextInt();
		System.out.println("请输入正确的月份：");
		int month = scan.nextInt();
		System.out.println("请输入正确的日份：");
		int day = scan.nextInt();
		//也可以这么写，但是可读性差：int year = scan.nextInt(), month = scan.nextInt(), day = scan.nextInt();
	
		//定义leapYear = 0，判断是否是闰年，若是闰年，则leapYear = 1
		int leapYear = 0;
		if( ((year % 4 == 0) && (year % 100 != 0)) || (year % 100 == 0)){
			leapYear = 1;
		}
		//测试leapYear：System.out.println(leapYear);

		if((year < 0) || ((month < 0) || (month > 12)) || ((day < 0) || (day >31))){
			System.out.println("年月日输入有误！");
			System.exit(0);
		}

		int dayNum = 0;	//默认0天
		switch(month){
			case 1 : dayNum = day;
					 break;
			case 2 : dayNum = day + 31;
					 break;
			case 3 : dayNum = day + 31 + 28;
					 break;
			case 4 : dayNum = day + 31 + 28 + 31;
					 break;
			case 5 : dayNum = day + 31 + 28 + 31 + 30;
					 break;
			case 6 : dayNum = day + 31 + 28 + 31 + 30 + 31;
					 break;
			case 7 : dayNum = day + 31 + 28 + 31 + 30 + 31 + 30;
					 break;
			case 8 : dayNum = day + 31 + 28 + 31 + 30 + 31 + 30 + 31;
					 break;
			case 9 : dayNum = day + 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31;
					 break;
			case 10 : dayNum = day + 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30;
					 break;
			case 11 : dayNum = day + 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31;
					 break;
			case 12 : dayNum = day + 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 +30;
					 break;
		}
		if(leapYear == 1){
			if(month > 2){
				day++;//前面推荐的自增写法
			}
		}
		System.out.println(dayNum);
		//System.out.println(year + "年" + month + "月" + day + "日" + "是" + year "年的第" + dayNum + "天");


		//方法2
		switch(month){
		
		case 12: dayNum += 30;

		case 11: dayNum += 31;

		case 10: dayNum += 30;

		case 9: dayNum += 31;

		case 8: dayNum += 31;

		case 7: dayNum += 30;

		case 6: dayNum += 31;

		case 5: dayNum += 30;

		case 4: dayNum += 31;

		case 3: dayNum += 28;//三月几日天数就是day加上一月份和二月份的天数
	
		case 2: dayNum += 31;//二月几日天数就是day加上一月份的天数
		
		case 1: dayNum += day;//一月几日天数就是day
		}
		
		System.out.println(year + "年" + month + "月" + day + "日" + "是" + year + "年的第" + dayNum + "天");

说明：

System.exit(int status)：不管status为何值都会退出程序（即结束当前正在运行的java虚拟机），
但是只有在status等于0，即System.exit(0)；的时候整个程序正常退出。当status为除0之外的数字时
都视为程序的不正常退出。（示例在一个if-else判断中，如果我们程序是按照我们预想的执行，到最后
我们需要停止程序，那就使用System.exit(0)，而System.exit(1)一般放在catch块中，当捕获到异常，
需要停止程序，我们使用System.exit(1)。）
return：return；是只能直接回到上一层继续往下执行，不会直接导致整个程序的停止执行。
break：break；只在switch语句体和循环体应用，一个break；语句能退出一个switch语句体或循环体，
不会执行循环体或switch语句体余下的语句，不能连续退出多个switch语句体或循环体。
continue：自己目前只在循环体应用，continue；跳过本次循环体中余下尚未执行的语句，接着再一次
进行循环的条件判定是否执行。

5. 编写程序：从键盘上读入一个学生成绩，存放在变量score中，根据score的值输出其对应的成绩等级：

			score>=90 等级: A
			70<=score<90 等级: B
			60<=score<70 等级: C
			score<60 等级: D
			方式一：使用if-else
			方式二：使用switch-case: score / 10: 0 - 10

System.out.print("请输入学生成绩：");
		int score = scan.nextInt();//从键盘上读入一个学生成绩，存放在变量score中

		System.out.println();//因为前一个输出语句没有换行，所以想要用这个单独换行，没想到它在输入数字并回车后自动换行了
		//方式一
		if(score >= 90){
			System.out.println("A");
		}else if((score >= 70) && (score < 90)){
			System.out.println("B");
		}else if((score >= 60) && (score < 70)){
			System.out.println("C");
		}else{
			System.out.println("D");
		}


		//方式二
		switch(score / 10){
		
		case 1: 
		case 2: 
		case 3:
		case 4:
		case 5: System.out.println("D");
				break;

		case 6: System.out.println("C");
				break;

		case 7: 
		case 8: System.out.println("B");
				break;

		case 9:
		case 10: System.out.println("A");
				break;
		}```

# 总结
<font color=#999AAA >这次拖了好久，发生了好多事，终于算是告一段落了QAQ，猛男落泪，明天继续冲！