Frank's blog
Frank
2021-10-14
目录

类型转换、运算符、流程控制语句

# 类型转换、运算符、流程控制语句

思维导图 (opens new window)

# 1.类型转换

概述：Java程序中要求参与计算的数据，必须要保证数据类型的一致性，如果数据类型不一致将发生类型的转换。

public class Test{
    public static void main(String[] args){
        int a = 10;
        double b = 12.3;
        数据类型 c = a + b;  //这个c的数据类型到底是int呢 还是double呢  
    }
}
1
2
3
4
5
6
7

分类：数据类型转换分为自动类型转换和强制类型转换

# 1.1.自动类型转换和强制类型转换

# 1.1.1 自动类型转换

概念：把一个表示数据范围小的数值或者变量赋值给表示数据范围大的变量。这种转换方式是自动的。

取值范围从大到小

自动提升的规则为

byte、short、char 运算时直接提升为int 。

byte a = 10;
byte b = 20;
int c = a + b;
1
2
3

自动类型转换内存原理图

注意:自动类型转换,就是在数据前面按照要求补充若干字节的0。

# 1.1.2 强制类型转换

概念：把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量。需要程序员写代码实现。

格式：目标数据类型 变量名 = (目标数据类型)值或者变量。

double d = 90.90;
int num = (int)d;
System.out.println(num);//90，强制类型转换会有精度损失问题
1
2
3

强制类型转换内存原理图：

注意: 强制类型转换,根据要求砍掉数据前面的若干字节,如果被砍掉的字节都是0,对数据没有影响 只要被砍掉的数据中包含1,对数据有影响，所以强制类型转换有可能会出现精度损失问题，基本数据类型不推荐强制类型转换

复杂类型转换原理图：

public class Test {
    public static void main(String[] args) {
        byte b = 30;
        short s = 40;
        int num1 = b + s;//byte short参与运算首先会自动提升为int类型
        System.out.println(num1);//70
        short s2 = (short) (b + s);//强制类型转换
        byte b2 = (byte) (b + s);//强制类型转换
        System.out.println(s2);//70
        System.out.println(b2);//70
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

案例：

byte a = 10;
byte b = 20;
//byte c = a + b;  错误的，因为byte参与运算时会首先提升为int，所以a+b是两个int相加，结果还是int，不可以直接赋值给一个byte类型
byte c = (byte) (a + b);
byte d = 3 + 4; //常量优化机制，在编译器的时候就会让3 + 4进行相加，自动判断7是否在byte取值范围内。不在范围内则编译报错，在范围内则编译通过。 

float h = 3.5 + 3.5;//直接编译报错，小数没有常量优化机制

long l = 2300000000L;
1
2
3
4
5
6
7
8
9

# 2.运算符

# 2.1 运算符和表达式

运算符：是一种特殊的符号，用以表示数据的运算、赋值、比较等。

表达式：用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。

不同运算符连接的表达式体现的是不同类型的表达式。

举例

int a = 10;
int b = 20;
int c = a + b;
1
2
3

+：是运算符，并且是算术运算符。

a + b：是表达式，由于+是算术运算符，所以这个表达式叫算术表达式。

# 2.2 算数运算符

+: 加法
-: 加法
*: 乘法
/: 除法
%: 取余
1
2
3
4
5

示例代码

public class Demo07Operator {
	public static void main(String[] args) {
		//定义2个int变量
		int a = 20;
		int b = 10;
		System.out.println(a + b);//20 + 10: 30
		System.out.println(a - b);//20 - 10: 10
		System.out.println(a * b);//20 * 10: 200
		System.out.println(a / b);//20 /10 : 2  
		System.out.println(a*1.0 / b);//2.0 Java程序中，整数运算，结果只能得到整数，想得到小数，需要浮点数参与运算
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

# 2.2.1 取余

/*
	%:取余作用
		取模运算(取余数)，两个数字相除取余数
		数学中:
				被除数/除数 = 商(/: 求的就是商) ..... 余数(%: 求的就是余数)
				
	%的作用:
		1.判断数字的奇偶性:
			偶数: 数字%2 结果  0
			奇数: 数字%2 结果  1
			
		2.判断一个数字能否被另外一个数字整除
			18%5   0
		
		3.使用/和% 可以 求出某个数字的每一位上的数字
		
			比如:
				1234
				个位: 4
				十位: 3
				百位: 2
				千位: 1
				
*/
public class Demo08Operator {
	public static void main(String[] args) {
		System.out.println(6%2);//0  说明6是偶数
		System.out.println(11%2);//1  说明1是奇数
		System.out.println(100%25);//0  说明100可以被25整除
		System.out.println(101%25);//1  说明101不可以被25整除
		System.out.println("---------------------");//1  说明101不可以被25整除
		
		//定义int变量
		int num = 1234;	
		//个位
		int ge = num%10;	
		//十位
		//System.out.println(123%10);//如何获取123?
		//System.out.println(1234/10);//123
		int shi = num/10%10;		
		//百位
		//System.out.println(1234/100);//12
		//System.out.println(1234/100%10);
		int bai = num/100%10;		
		//千位
		int qian = num/1000%10;	//也可以直接/1000拿到千位1，但是这种是一个通用写，5位数照样可以适用
		System.out.println(ge);
		System.out.println(shi);
		System.out.println(bai);
		System.out.println(qian);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

# 2.2.2 字符的+操作

char类型参与算术运算，使用的是计算机底层对应的十进制数值（编码）。

编码简介

计算机只能保存只能保存二进制码。

不能直接保存字符，为了方便保存字符，于是将所有字符先进行编号，当计算机要保存某个字符时，
只需要将该字符编号转换，然后保存即可。

所谓字符集就是所有字符的编号。'A'  65
    
美国人常用的字符无非是英文字符、数字、标点符号，至多100多个字符。
所以早期采用的是一个字节（8位，可以表示256个字符）。这就是ASCII字符集。

如果要表示所有中文，显然一个字节是不够的，至少需要两个字节，而且还不能和ASCII编码冲突，
所以，中国制定了GB2312编码，用来把中文编进去。

后来亚洲国家制定了本国的字符集，但这些字符集并不兼容，为了统一所有文字的编码，Unicode应运而生。Unicode把所有语言都统一到一套编码里
其中前256个字符和ASCII中的字符完全一样。

java采用的是16位的Unicode字符集作为编码方式。

char参与运算时使用的是编码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

需要我们记住三个字符对应的数值：

'a' -- 97 a-z是连续的，所以'b'对应的数值是98，'c'是99，依次递加

'A' -- 65 A-Z是连续的，所以'B'对应的数值是66，'C'是67，依次递加

'0' -- 48 0-9是连续的，所以'1'对应的数值是49，'2'是50，依次递加

// 可以通过使用字符与整数做算术运算，得出字符对应的数值是多少
char ch1 = 'a';
System.out.println(ch1 + 1); // 输出98，97 + 1 = 98

char ch2 = 'A';
System.out.println(ch2 + 1); // 输出66，65 + 1 = 66

char ch3 = '0';
System.out.println(ch3 + 1); // 输出49，48 + 1 = 49
1
2
3
4
5
6
7
8
9

算术表达式中包含不同的基本数据类型的值的时候，整个算术表达式的类型会自动进行提升。

提升规则：

  • byte类型，short类型和char类型将被提升到int类型，不管是否有其他类型参与运算。

  • 整个表达式的类型自动提升到与表达式中最高等级的操作数相同的类型

    等级顺序：byte,short,char --> int --> long --> float --> double

例如：

byte b1 = 10; 
byte b2 = 20;
// byte b3 = b1 + b2; // 该行报错，因为byte类型参与算术运算会自动提示为int，int赋值给byte可能损失精度
int i3 = b1 + b2; // 应该使用int接收
byte b3 = (byte) (b1 + b2); // 或者将结果强制转换为byte类型
-------------------------------
int num1 = 10;
double num2 = 20.0;
double num3 = num1 + num2; // 使用double接收，因为num1会自动提升为double类型
1
2
3
4
5
6
7
8
9

tips：正是由于上述原因，所以在程序开发中我们很少使用byte或者short类型定义整数。也很少会使用char类型定 义字符，而使用字符串类型，更不会使用char类型做算术运算。

# 2.2.3 字符串的+操作

当“+”操作中出现字符串时，这个”+”是字符串连接符，而不是算术运算。

System.out.println("itheima" + 666); // 输出：itheima666
1

当连续进行“+”操作时，从左到右逐个执行。当遇到()时，先计算()中的式子的结果。

System.out.println(1 + 99 + "年黑马"); // 输出：199年黑马
System.out.println(1 + 2 + "itheima" + 3 + 4); // 输出：3itheima34
// 可以使用小括号改变运算的优先级
System.out.println(1 + 2 + "itheima" + (3 + 4)); // 输出：3itheima7
1
2
3
4

# 2.3 案例_数值拆分

需求：键盘录入一个三位数，将其拆分为个位、十位、百位后，打印在控制台。

打印格式为：
整数567分个位为7
整数567分十位为6
整数567分百位为5
1
2
3
4
5
6

代码

import java.util.Scanner;
public class Test {
	public static void main(String[] args) {
		// 1：使用Scanner键盘录入一个三位数
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个三位数");
		int num = sc.nextInt();
		// 2：个位的计算：数值 % 10
		int ge = num % 10;	
		// 3：十位的计算：数值 / 10 % 10
		int shi = num / 10 % 10;
		// 4：百位的计算：数值 / 100
		int bai = num / 100;
		// 5：将个位, 十位, 百位拼接上正确的字符串, 打印即可
		System.out.println("整数"+num+"个位为:" + ge);
		System.out.println("整数"+num+"十位为:" + shi);
		System.out.println("整数"+num+"百位为:" + bai);	
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 2.4.自增自减运算符（理解）

概念：对变量进行加1或者减1操作。

使用方式：

  • 单独使用：单独成行。前置后置效果一样。
  • 混合使用：前置++，先给变量加1，再使用变量。后置++，先使用变量，再加1。

实际开发中，单独使用最常见。

符号 作用 说明
++ 自增 变量的值加1
-- 自减 变量的值减1
int i = 10;
i++; // 单独使用
System.out.println("i:" + i); // i:11

int j = 10;
++j; // 单独使用
System.out.println("j:" + j); // j:11

int x = 10;
int y = x++; // 赋值运算，++在后边，所以是使用x原来的值赋值给y，x本身自增1
System.out.println("x:" + x + ", y:" + y); // x:11，y:10

int m = 10;
int n = ++m; // 赋值运算，++在前边，所以是使用m自增后的值赋值给n，m本身自增1
System.out.println("m:" + m + ", n:" + n); // m:11，n:11
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

练习

int x = 10;
	  //10 +  11  + 12
int y = x++ + x++ + x++;
System.out.println(y); // y的值是多少？
/*
解析，三个表达式都是++在后，所以每次使用的都是自增前的值，但程序自左至右执行，所以第一次自增时，使用的是10进行计算，但第二次自增时，x的值已经自增到11了，所以第二次使用的是11，然后再次自增。。。
所以整个式子应该是：int y = 10 + 11 + 12;
输出结果为33。
*/
注意：通过此练习深刻理解自增和自减的规律，但实际开发中强烈建议不要写这样的代码！小心挨打！
1
2
3
4
5
6
7
8
9
10

# 2.5 赋值运算符（应用）

赋值运算符的作用是将一个表达式的值赋给左边，左边必须是可修改的，不能是常量。

符号 作用 说明
= 赋值 a=10，将10赋值给变量a
+= 加后赋值 a+=b，将a+b的值给a
-= 减后赋值 a-=b，将a-b的值给a
*= 乘后赋值 a*=b，将a×b的值给a
/= 除后赋值 a/=b，将a÷b的商给a
%= 取余后赋值 a%=b，将a÷b的余数给a

注意：

扩展的赋值运算符隐含了强制类型转换。

short s = 10;
s = s + 10; // 此行代码报出，因为运算中s提升为int类型，运算结果int赋值给short可能损失精度

s += 10; // 此行代码没有问题，隐含了强制类型转换，相当于 s = (short) (s + 10);
1
2
3
4

# 2.6 关系运算符（应用）

关系运算符有6种关系，分别为小于、小于等于、大于、等于、大于等于、不等于。

符号 说明
== a==b，判断a和b的值是否相等，成立为true，不成立为false
!= a!=b，判断a和b的值是否不相等，成立为true，不成立为false
> a>b，判断a是否大于b，成立为true，不成立为false
>= a>=b，判断a是否大于等于b，成立为true，不成立为false
< a<b，判断a是否小于b，成立为true，不成立为false
<= a<=b，判断a是否小于等于b，成立为true，不成立为false

注意事项：

  • 关系运算符的结果都是boolean类型，要么是true，要么是false。
  • 千万不要把“==”误写成“=”，"=="是判断是否相等的关系，"="是赋值。
int a = 10;
int b = 20;
System.out.println(a == b); // false
System.out.println(a != b); // true
System.out.println(a > b); // false
System.out.println(a >= b); // false
System.out.println(a < b); // true
System.out.println(a <= b); // true

// 关系运算的结果肯定是boolean类型，所以也可以将运算结果赋值给boolean类型的变量
boolean flag = a > b;
System.out.println(flag); // 输出false
1
2
3
4
5
6
7
8
9
10
11
12

# 2.7 逻辑运算符（应用）

逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断的结果是 true 或 false。

符号 作用 说明
& 逻辑与 a&b，a和b都是true，结果为true，否则为false。见false则false
| 逻辑或 a|b，a和b都是false，结果为false，否则为true。见true则true
^ 逻辑异或 a^b，a和b结果不同为true，相同为false
! 逻辑非 !a，结果和a的结果正好相反
//定义变量
int i = 10;
int j = 20;
int k = 30;

//& “与”，并且的关系，只要表达式中有一个值为false，结果即为false
System.out.println((i > j) & (i > k)); //false & false,输出false
System.out.println((i < j) & (i > k)); //true & false,输出false
System.out.println((i > j) & (i < k)); //false & true,输出false
System.out.println((i < j) & (i < k)); //true & true,输出true
System.out.println("--------");

//| “或”，或者的关系，只要表达式中有一个值为true，结果即为true
System.out.println((i > j) | (i > k)); //false | false,输出false
System.out.println((i < j) | (i > k)); //true | false,输出true
System.out.println((i > j) | (i < k)); //false | true,输出true
System.out.println((i < j) | (i < k)); //true | true,输出true
System.out.println("--------");

//^ “异或”，相同为false，不同为true
System.out.println((i > j) ^ (i > k)); //false ^ false,输出false
System.out.println((i < j) ^ (i > k)); //true ^ false,输出true
System.out.println((i > j) ^ (i < k)); //false ^ true,输出true
System.out.println((i < j) ^ (i < k)); //true ^ true,输出false
System.out.println("--------");

//! “非”，取反
System.out.println((i > j)); //false
System.out.println(!(i > j)); //!false，,输出true
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# 2.8 短路逻辑运算符（理解）

符号 作用 说明
&& 短路与 作用和&相同，但是有短路效果
|| 短路或 作用和|相同，但是有短路效果

在逻辑与运算中，只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值都计算出来，短路与操作就有这样的效果，可以提高效率。同理在逻辑或运算中，一旦发现值为true，右边的表达式将不再参与运算。

  • 逻辑与&，无论左边真假，右边都要执行。

  • 短路与&&，如果左边为真，右边执行；如果左边为假，右边不执行。

  • 逻辑或|，无论左边真假，右边都要执行。

  • 短路或||，如果左边为假，右边执行；如果左边为真，右边不执行。

int x = 3;
int y = 4;
System.out.println((x++ > 4) & (y++ > 5)); // 两个表达都会运算
System.out.println(x); // 4
System.out.println(y); // 5

System.out.println((x++ > 4) && (y++ > 5)); // 左边已经可以确定结果为false，右边不参与运算
System.out.println(x); // 4
System.out.println(y); // 4
1
2
3
4
5
6
7
8
9

# 2.9 三元运算符（理解）

三元运算符语法格式：

数据类型  变量名  =  关系表达式 ? 表达式1 : 表达式2;
1

解释：问号前面的位置是判断的条件，判断结果为boolean型，为true时调用表达式1，为false时调用表达式2。其逻辑为：如果条件表达式成立或者满足则执行表达式1，否则执行第二个。

举例：

int a = 10;
int b = 20;
int c = a > b ? a : b; // 判断 a>b 是否为真，如果为真取a的值，如果为假，取b的值
1
2
3

注意：

三元表达式的结果必须用一个变量接收，此变量的数据类型必须和表达式1和表达式2的数据类型保持一致

# 2.10 三元运算符案例(应用)

1、需求：动物园里有两只老虎，已知两只老虎的体重分别为180kg、200kg，请用程序实现判断两只老虎的体重是否相同。

public class OperatorTest01 {
    public static void main(String[] args) {
        //1.定义两个变量用于保存老虎的体重
        int weight1 = 180;
        int weight2 = 200;
        //2.用三元运算符实现老虎体重的判断，体重相同，返回true，否则返回false
        boolean b = weight1 == weight2 ? true : false;
        //3.输出结果
        System.out.println("b:" + b)
    }
}
1
2
3
4
5
6
7
8
9
10
11

2、需求：一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm，请用程序实现获取这三个和尚的最高身高。

public class OperatorTest02 {
	public static void main(String[] args) {
		//1：定义三个变量用于保存和尚的身高，单位为cm，这里仅仅体现数值即可。
		int height1 = 150;
		int height2 = 210;
		int height3 = 165;	
		//2：用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来。
		int tempHeight = height1 > height2 ? height1 : height2;		
		//3：用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。
		int maxHeight = tempHeight > height3 ? tempHeight : height3;	
		//4：输出结果
		System.out.println("maxHeight:" + maxHeight);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 3.数据输入（应用）

我们可以通过Scanner类来获取用户的输入。使用步骤如下:

1、导包。Scanner类在java.util包下，所以需要将该类导入。导包的语句需要定义在类的上面。

import java.util.Scanner;
1

2、创建Scanner对象

Scanner sc = new Scanner(System.in);//创建Scanner类对象，sc表示变量名，其他均可不变
1

3、接受数据

int i = sc.nextInt();//表示将键盘录入的值作为int数返回。
1

示例：

import java.util.Scanner;
public class ScannerDemo {
	public static void main(String[] args) {
        //创建对象
        Scanner sc = new Scanner(System.in);
        //接受数据
        int x = sc.nextInt();
        //输出数据
        System.out.println("x:" + x);
    }
}
1
2
3
4
5
6
7
8
9
10
11

改写三个和尚案例，数据使用键盘录入。

import java.util.Scanner;
public class ScannerTest {
	public static void main(String[] args) {
		//身高未知，采用键盘录入实现。首先导包，然后创建对象。
		Scanner sc = new Scanner(System.in);
		//键盘录入三个身高分别赋值给三个变量
		System.out.println("请输入第一个和尚的身高：")；
		int height1 = sc.nextInt();
		System.out.println("请输入第二个和尚的身高：")；
		int height2 = sc.nextInt();
		System.out.println("请输入第三个和尚的身高：")；
		int height3 = sc.nextInt();
		//用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来
		int tempHeight = height1 > height2 ? height1 : height2;
		//用三元运算符获取临时身高值和第三个和尚的身高较高值，并用最大身高变量保存
		int maxHeight = tempHeight > height3 ? tempHeight : height3;
		//输出结果
		System.out.println("这三个和尚中身高最高的是：" + maxHeight + "cm");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 4.流程控制语句

在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。所以，我们必须清楚每条语句的执行流程。而且，很多时候要通过控制语句的执行顺序来实现我们想要的功能。

# 4.1 流程控制语句分类(了解)

  • 顺序结构
  • 分支结构(if, switch)
  • 循环结构(for, while, do…while)

# 4.2 顺序结构(了解)

顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。

顺序结构执行流程图：

# 4.3 分支结构之if语句

# 4.3.1 if语句格式1（理解）

格式：
if (关系表达式){
    语句体;	
}
后续代码
1
2
3
4
5

执行流程：

①首先计算关系表达式的值

②如果关系表达式的值为true就执行语句体

③如果关系表达式的值为false就不执行语句体

④继续执行后面的语句内容

image-20210801125138211

示例：

public class IfDemo {
	public static void main(String[] args) {
		System.out.println("开始");
        
		// 如果年龄大于18岁, 就可以上网吧
		int age = 17;
		
		if(age >= 18){
			// int a = 10;
			System.out.println("可以上网吧");
		}
			
		System.out.println("结束");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 4.3.2 if语句格式2（理解）

格式：
if (关系表达式) {
    语句体1;	
} else {
    语句体2;	
}
后续代码
1
2
3
4
5
6
7

执行流程：

①首先计算关系表达式的值

②如果关系表达式的值为true就执行语句体1

③如果关系表达式的值为false就执行语句体2

④继续执行后面的语句内容

image-20210801125213029

示例：奇偶数

​ 任意给出一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该整数是奇数还是偶数。

import java.util.Scanner;
public class Demo2If {
	public static void main(String[] args) {
		//为了体现任意给出一个整数，采用键盘录入一个数据。（导包，创建对象，接受数据）
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数：")；
        int number = sc.nextInt();
        //判断整数是偶数还是奇数分两种情况进行判断，使用if.else结构
        //判断是否偶数需要使用取余运算符实现该功能 number % 2 ==0
        //根据判定情况，在控制台输出对应的内容
		if(num % 2 == 0){
			System.out.println(number + "是偶数");
		}else{
			System.out.println(number + "是奇数");
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 3.3.3 if语句格式3（理解）

格式：
if (关系表达式1) {
    语句体1;	
} else if (关系表达式2) {
    语句体2;	
} else if (关系表达式3) {
    语句体3;	
} 
…
else {
    语句体n+1;
}
后续代码
1
2
3
4
5
6
7
8
9
10
11
12
13

执行流程：

①首先计算关系表达式1的值

②如果值为true就执行语句体1；如果值为false就计算关系表达式2的值

③如果值为true就执行语句体2；如果值为false就计算关系表达式3的值

④…

⑤如果没有任何关系表达式为true，就执行语句体n+1。

示例：

​ 定义一个在0~100之间的变量a, 90~100优秀，80~89良好，70~79中等，60~69及格，0~59请努力加油！

public class Demo3If {
	public static void main(String[] args){
		int score = 65;
		if(score >= 90 && score <= 100){
			System.out.println("优秀");
		}else if (score >= 80 && score <= 89){
			System.out.println("良好");
		}else if (score >= 70 && score <= 79){
			System.out.println("中等");
		}else if (score >= 60 && score <= 69){
			System.out.println("及格");
		}else if (score >= 0 && score <= 59){
			System.out.println("请努力加油");
		}else{
			System.out.println("成绩有误!");
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 3.3.4 if语句格式3案例（应用）

需求：小明快要期末考试了，小明爸爸对他说，会根据他不同的考试成绩，送他不同的礼物，假如你可以控制小明的得分，请用程序实现小明到底该获得什么样的礼物，并在控制台输出。

分析：

​ ①小明的考试成绩未知，可以使用键盘录入的方式获取值

​ ②由于奖励种类较多，属于多种判断，采用if...else...if格式实现

​ ③为每种判断设置对应的条件

​ ④为每种判断设置对应的奖励

import java.util.Scanner;
public class IfTest02 {
	public static void main(String[] args){
		// 1. 使用Scanner录入考试成绩
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入您的成绩:");
		int score = sc.nextInt();
		// 2. 判断成绩是否在合法范围内 0~100
		if(score >=0 && score <= 100){
			// 合法成绩
			// 3. 在合法的语句块中判断成绩范围符合哪一个奖励
			if(score >= 95 && score <= 100){
				System.out.println("自行车一辆");
			}else if(score >= 90 && score <= 94){
				System.out.println("游乐场游玩一次");
			}else if(score >= 80 && score <= 89){
				System.out.println("变形金刚一个");
			}else {
				System.out.println("挨顿揍, 这座城市又多了一个伤心的人~");
			}
		}else{
			// 非法的话, 给出错误提示
			System.out.println("您的成绩输入有误!");
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
在Github中编辑 (opens new window)
上次更新: 2021/11/29, 10:27:07
java基础语法
switch&循环语句

← switch&循环语句→

最近更新
01
面试问题套路
04-21
02
Mysql多版本安装
05-28
03
Go语言基础类型
05-04
更多文章>
Theme by Vdoing | Copyright © 2021-2024 Master Frank | 粤ICP备2021148573号
×