JavaSE-Day(3)学习笔记

Java系统学习-JavaSE篇
字数统计: 7.6k字   |   阅读时长: 37分

数据类型中补充的几个小问题

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
1:在定义Long或者Float类型变量的时候，要加L或者f。
  整数默认是int类型，浮点数默认是double。
  
  byte，short在定义的时候，他们接收的其实是一个int类型的值。
  这个是自己做了一个数据检测的，如果不再它们的范围内，就报错。
  
2:byte值的问题
	byte b1 = 127;
	byte b2 = (byte)128; //-128
	byte b3 = (byte)129; //-127
	byte b4 = (byte)130; //-126
	
	byte的范围：-128 ~ 127
	
	128：10000000
	-128：10000000 (这里的1即是符号位，也是数值位)
	
3:数据类型转换之默认转换
	byte,short,char -- int -- long -- float -- double
	
	long: 8个字节
	float：4个字节
	
	A:它们底层的存储结构不同。
	B:float表示的数据范围比long的范围要大
		long：2^63-1
		float：3.4*10^38 > 2*10^38 > 2*8^38 = 2*2^3^38 = 2*2^114 > 2^63-1

4:Java语言中的字符char可以存储一个中文汉字吗?为什么呢?
	可以。因为java语言中的字符占用两个字节。
	
	Java语言采用的是Unicode编码。

算术运算符的基本用法

算术运算符

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
/*
	算术运算符：
		+,-,*,/,%,++,--
		
	注意事项：
		A:整数相除只能得到整数。如果想得到小数，必须把数据变化为浮点数类型
		B:/获取的是除法操作的商，%获取的是除法操作的余数
*/

class OperatorDemo {
	public static void main(String[] args) {
		//定义变量
		int x = 3;  //把3赋值给int类型的变量x
		int y = 4;
		
		System.out.println(x+y);
		System.out.println(x-y);
		System.out.println(x*y);
		System.out.println(x/y); //整数相除只能得到整数
		
		//我就想得到小数，该肿么办呢?
		//只需要把操作的数据中任意的一个数据变为浮点数
		System.out.println(x*1.0/y);
		
		//%的应用
		System.out.println(x%y); //得到的是余数
	}
}

算术运算符++和—的使用

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
/*
	++,--运算符的使用：
		单独使用：
			放在操作数的前面和后面效果一样。(这种用法是我们比较常见的)
		参与运算使用：
			放在操作数的前面，先自增或者自减，然后再参与运算。
			放在操作数的后面，先参与运算，再自增或者自减。
			
	作用：就是对变量进行自增1或者自减1。
*/
class OperatorDemo2 {
		public static void main(String[] args) {
			//定义两个变量
			int x = 3;
			int y = 4;
			
			//字符串的拼接
			//System.out.println("x:"+x);
			//System.out.println("y:"+y);
			
			System.out.println("x:"+x+",y:"+y);
			
			//单独使用
			//x++;
			//y--;
			++x;
			--y;
			//System.out.println(x);
			System.out.println("x:"+x+",y:"+y);
			
			//意外的类型,常量是不可以这样做的
			//System.out.println(10++);
			
			System.out.println("-------------------");
			//参与运算使用
			int a = 3;
			int b = 4;
			
			//int c = a++;
			//int d = b--;
			
			int c = ++a;
			int d = --b;
			
			System.out.println("a:"+a); //4, 4
			System.out.println("b:"+b); //3, 3
			System.out.println("c:"+c); //3, 4
			System.out.println("d:"+d); //4, 3
		}
}

算术运算符+的多种用法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/*
	+的用法：
		A:加法
		B:正号
		C:字符串连接符
*/
class OperatorDemo3 {
	public static void main(String[] args) {
		//加法
		System.out.println(3+4);
		
		//正号
		System.out.println(+4);
		
		System.out.println('a');
		System.out.println('a'+1); //这里是加法
		
		//字符串连接符
		System.out.println("hello"+'a'+1);
		System.out.println('a'+1+"hello");
	}
}

算术运算符++和—的练习

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
/*
	++,--的练习题
	
	第一题：
	int a = 10;
	int b = 10;
	int c = 10;

	a = b++;
	c = --a;
	b = ++a;
	a = c--;
	请分别计算出a,b,c的值
	
	第二题：
	int x = 4;
	int y = (x++)+(++x)+(x*10);
	请分别计算出x,y的值
*/
class OperatorTest {
	public static void main(String[] args) {
		int a = 10;
		int b = 10;
		int c = 10;

		a = b++; //a=10,b=11,c=10
		c = --a; //a=9,b=11,c=9
		b = ++a; //a=10,b=10,c=9
		a = c--; //a=9,b=10,c=8
		
		System.out.println("a:"+a);
		System.out.println("b:"+b);
		System.out.println("c:"+c);
		System.out.println("--------------");
		
		int x = 4;
		int y = (x++)+(++x)+(x*10);
		//4+6+60
		//x=5,6
		
		System.out.println("x:"+x);
		System.out.println("y:"+y);
	}
}

赋值运算符的基本用法

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
/*
	赋值运算符：
		基本的赋值运算符：=
			把=右边的数据赋值给左边。
			
		扩展的赋值运算符：+=,-=,*=,/=,%=
			+= 把左边和右边做加法，然后赋值给左边。
*/
class OperatorDemo {
	public static void main(String[] args) {
		//定义一个变量
		int x = 10;
		
		//其他用法
		int a,b; 
		a = b = 10;
		System.out.println(a); 
		System.out.println(b);
		System.out.println("-----------");

		//定义一个变量
		int y = 10;
		
		y += 20;
		
		System.out.println(y);
		
	}
}

赋值运算符的面试题

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
/*
	面试题：
		short s=1;s = s+1; 
		
		short s=1;s+=1;
		上面两个代码有没有问题，如果有，那里有问题。
		
		为什么第二个木有问题呢?
			扩展的赋值运算符其实隐含了一个强制类型转换。
			
			s += 1;
			不是等价于 s = s + 1;
			而是等价于 s = (s的数据类型)(s + 1);
*/
class OperatorTest {
	public static void main(String[] args) {
		//short s = 1;
		//s = s + 1;
		//System.out.println(s);
		
		short s = 1;
		s += 1; //好像是 s = s + 1;
		System.out.println(s);
	}
}

比较运算符的基本用法及其注意事项

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
/*
	比较运算符：
		==,!=,>,>=,<,<=
		
	特点：
		无论你的操作是简单还是复杂，结果是boolean类型。
		
	注意事项：
		"=="不能写成"="。
*/
class OperatorDemo {
	public static void main(String[] args) {
		int x = 3;
		int y = 4;
		int z = 3;
	
		System.out.println(x == y);
		System.out.println(x == z);
		System.out.println((x+y) == (x+z));
		System.out.println("------------");
		
		System.out.println(x != y);
		System.out.println(x > y);
		System.out.println(x >= y);
		System.out.println(x < y);
		System.out.println(x <= y);
		System.out.println("------------");
		
		int a = 10;
		int b = 20;
		
		//boolean flag = (a == b);
		//boolean flag = (a = b); //这个是有问题的，不兼容的类型
		//System.out.println(flag);
		
		int c = (a = b); //把b赋值给a，然后把a留下来
		System.out.println(c);
	}
}

逻辑运算符的基本用法

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
53
54
/*
	逻辑运算符：
		&,|,^,!
		&&,||
		
	特点：
		逻辑运算符一般用于连接boolean类型的表达式或者值。
			
		表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。
			算术表达式：a + b
			比较表达式：a == b
			
	结论：
		&逻辑与:有false则false。
		|逻辑或:有true则true。
		^逻辑异或:相同为false，不同为true。
			举例：情侣关系。男男,男女,女男,女女
		!逻辑非:非false则true，非true则false。
			特点：偶数个不改变本身。
*/
class OperatorDemo {
	public static void main(String[] args) {
		int a = 3;
		int b = 4;
		int c = 5;
		
		//&逻辑与
		System.out.println((a > b) & (a > c)); //false & false = false
		System.out.println((a > b) & (a < c)); //false & true = false
		System.out.println((a < b) & (a > c)); //true & false = false
		System.out.println((a < b) & (a < c)); //true & true = true
		System.out.println("---------------");
		
		//|逻辑或
		System.out.println((a > b) | (a > c)); //false | false = false
		System.out.println((a > b) | (a < c)); //false | true = true
		System.out.println((a < b) | (a > c)); //true | false = true
		System.out.println((a < b) | (a < c)); //true | true = true
		System.out.println("---------------");
		
		//^逻辑异或
		System.out.println((a > b) ^ (a > c)); //false ^ false = false
		System.out.println((a > b) ^ (a < c)); //false ^ true = true
		System.out.println((a < b) ^ (a > c)); //true ^ false = true
		System.out.println((a < b) ^ (a < c)); //true ^ true = false
		System.out.println("---------------");
		
		//!逻辑非
		System.out.println(!(a > b)); //!false = true
		System.out.println(!(a < b)); //!true = false
		System.out.println(!!(a > b)); //!!false = false
		System.out.println(!!!(a > b)); //!!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
30
31
32
33
34
/*
	&&和&的区别? 同理||和|的区别?
		A:最终结果一样。
		B:&&具有短路效果。左边是false，右边不执行。
		C:||具有短路效果，左边是true，右边不执行。
		
	开发中常用的逻辑运算符：
		&&,||,!
*/
class OperatorDemo2 {
	public static void main(String[] args) {
		int a = 3;
		int b = 4;
		int c = 5;
		
		//&&双与
		System.out.println((a > b) && (a > c)); //false && false = false
		System.out.println((a > b) && (a < c)); //false && true = false
		System.out.println((a < b) && (a > c)); //true && false = false
		System.out.println((a < b) && (a < c)); //true && true = true
		System.out.println("----------------");
		
		int x = 3;
		int y = 4;
		
		//boolean b1 = ((x++ == 3) & (y++ == 4));
		//boolean b1 = ((x++ == 3) && (y++ == 4));
		//boolean b1 = ((++x == 3) & (y++ == 4));
		boolean b1 = ((++x == 3) && (y++ == 4));
		System.out.println("x:"+x);
		System.out.println("y:"+y);
		System.out.println(b1);
	}
}

位运算的基本用法1

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
53
54
55
56
57
58
59
/*
	位运算符：
		&,|,^,~
		<<,>>,>>>
		
	注意：
		要做位运算，首先要把数据转换为二进制。
*/
class OperatorDemo {
	public static void main(String[] args) {
		//&,|,^,~
		
		int a = 3;
		int b = 4;
		
		System.out.println(3 & 4);
		System.out.println(3 | 4);
		System.out.println(3 ^ 4);
		System.out.println(~3);
	}
}
/*
	分析：因为是位运算，所以我们必须先把数据换算成二进制。
	
	3的二进制：11
		00000000 00000000 00000000 00000011
	4的二进制：100
		00000000 00000000 00000000 00000100
	
	&位与运算：有0则0。
		00000000 00000000 00000000 00000011
	   &00000000 00000000 00000000 00000100
		-----------------------------------
		00000000 00000000 00000000 00000000
		结果是：0
		
	|位或运算：有1则1。
		00000000 00000000 00000000 00000011
	   |00000000 00000000 00000000 00000100
		-----------------------------------
		00000000 00000000 00000000 00000111
		结果是：7
		
	^位异或运算：相同则0，不同则1。
		00000000 00000000 00000000 00000011
	   &00000000 00000000 00000000 00000100
		-----------------------------------
		00000000 00000000 00000000 00000111
		结果是：7
		
	~按位取反运算符：0变1，1变0
		00000000 00000000 00000000 00000011
	   ~11111111 11111111 11111111 11111100 (补码)
	   
	   补码：11111111 11111111 11111111 11111100
	   反码：11111111 11111111 11111111 11111011
	   原码：10000000 00000000 00000000 00000100
		结果是：-4
*/

位异或运算符的特点

1
2
3
4
5
6
7
8
9
10
11
12
/*
	^的特点：一个数据对另一个数据位异或两次，该数本身不变。
*/
class OperatorDemo2 {
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		
		System.out.println(a ^ b ^ b); //10
		System.out.println(a ^ b ^ a); //20
	}
}

位运算的面试题

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
/*
	面试题：
		请自己实现两个整数变量的交换
		注意：以后讲课的过程中，我没有明确指定数据的类型，默认int类型。
*/
class OperatorTest {
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		
		System.out.println("a:"+a+",b:"+b);
		
		//方式1：使用第三方变量(开发中用的)
		/*
		int c = a;
		a = b;
		b = c;
		System.out.println("a:"+a+",b:"+b);
		System.out.println("------------");
		*/
		
		//方式2：用位异或实现(面试用)
		//左边：a,b,a
		//右边：a ^ b
		/*
		a = a ^ b;
		b = a ^ b; //a ^ b ^ b = a
		a = a ^ b; //a ^ b ^ a = b
		System.out.println("a:"+a+",b:"+b);
		*/
		
		//方式3：用变量相加的做法
		/*
		a = a + b; //a=30
		b = a - b; //b=10
		a = a - b; //a=20
		System.out.println("a:"+a+",b:"+b);
		*/
		
		//方式4：一句话搞定
		b = (a+b) - (a=b); //b=30-20=10,a=20
		System.out.println("a:"+a+",b:"+b);
	}
}

位运算的基本用法2及面试题

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
53
54
55
56
/*
	<<:左移	左边最高位丢弃，右边补齐0
	>>:右移	最高位是0，左边补齐0；最高为是1，左边补齐1
	>>>:无符号右移 无论最高位是0还是1，左边补齐0
	
	面试题：
		请用最有效率的方式写出计算2乘以8的结果?
			2 * 8
			
			2 << 3

*/
class OperatorDemo3 {
	public static void main(String[] args) {
		//<< 把<<左边的数据乘以2的移动次幂
		System.out.println(3 << 2); //3*2^2 = 3*4 = 12;
	
		//>> 把>>左边的数据除以2的移动次幂
		System.out.println(24 >> 2); //24 / 2^2 = 24 / 4 = 6
		System.out.println(24 >>> 2);
		
		System.out.println(-24 >> 2); 
		System.out.println(-24 >>> 2);
	}
}
/*
	计算出3的二进制：11
		00000000 00000000 00000000 00000011
	(00)000000 00000000 00000000 0000001100
		
	>>的移动：	
	计算出24的二进制：11000
		原码：10000000 00000000 00000000 00011000
		反码：11111111 11111111 11111111 11100111
		补码：11111111 11111111 11111111 11101000
		
		11111111 11111111 11111111 11101000
		1111111111 11111111 11111111 111010(00) 补码
		
		补码：1111111111 11111111 11111111 111010
		反码：1111111111 11111111 11111111 111001
		原码：1000000000 00000000 00000000 000110
		
		结果：-6
		
	>>>的移动：
		计算出24的二进制：11000
		原码：10000000 00000000 00000000 00011000
		反码：11111111 11111111 11111111 11100111
		补码：11111111 11111111 11111111 11101000
		
		11111111 11111111 11111111 11101000
		0011111111 11111111 11111111 111010(00)
		
		结果：
*/

三元运算符的基本用法

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
/*
	单目运算符：~3
	双目运算符：3 + 4

	三目运算符：
		格式：比较表达式?表达式1:表达式2;
		
		比较表达式:结果是一个boolean类型。
		
		执行流程：
			根据比较表达式的计算返回一个true或者false。
			如果是true，就把表达式1作为结果。
			如果是false，就把表达式2作为结果。
*/
class OperatorDemo {
	public static void main(String[] args) {
		int x = 100;
		int y = 200;
		
		int z = ((x > y)? x: y);
		
		//int z = ((x < y)? x: y);
		
		//int z = ((x == y)? x: y);
		
		//报错
		//int z = ((x = y)? x : y);
		
		System.out.println("z:"+z);
	}
}

三元运算符的练习

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
/*
	练习：
		获取两个整数中的最大值
		获取三个整数中的最大值
		比较两个整数是否相同
*/
class OperatorTest {
	public static void main(String[] args) {
		//获取两个整数中的最大值
		int x = 100;
		int y = 200;
		
		int max = (x > y? x: y);
		System.out.println("max:"+max);
		System.out.println("--------");
		
		//获取三个整数中的最大值
		int a = 10;
		int b = 30;
		int c = 20;
		
		//分两步：
		//A:先比较a,b的最大值
		//B:拿a,b的最大值在和c进行比较
		int temp = ((a > b)? a: b);
		//System.out.println(temp);
		int max1 = (temp > c? temp: c);
		System.out.println("max1:"+max1);
		
		//一步搞定
		//int max2 = (a > b)?((a > c)? a: c):((b > c)? b: c);
		//这种做法不推荐。
		//int max2 = a > b?a > c? a: c:b > c? b: c;
		//System.out.println("max2:"+max2);
		System.out.println("--------");
		
		//比较两个整数是否相同
		int m = 100;
		int n = 200;
		
		//boolean flag = (m == n)? true: false;
		boolean flag = (m == n);
		System.out.println(flag);
	}
}

键盘录入的基本格式讲解

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
/*
	为了让程序的数据更符合开发的数据，我们就加入了键盘录入。
	让程序更灵活一下。
	
	那么，我们如何实现键盘数据的录入呢?
		A:导包
			格式：
				import java.util.Scanner; 
			位置：
				在class上面。
		B:创建键盘录入对象
			格式：
				Scanner sc = new Scanner(System.in);
		C:通过对象获取数据	
			格式：
				int x = sc.nextInt();
*/
import java.util.Scanner;

class ScannerDemo {
	public static void main(String[] args) {
		//创建键盘录入数据对象
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请你输入一个数据：");
		int x = sc.nextInt();
		
		System.out.println("你输入的数据是："+x);
	}
}

键盘录入的练习1

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
/*
	键盘录入练习：
		键盘录入两个数据，并对这两个数据求和，输出其结果
*/
import java.util.Scanner;

class ScannerTest {
	public static void main(String[] args) {
		//键盘录入两个数据，并对这两个数据求和，输出其结果
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入第一个数据：");
		int x = sc.nextInt();
		
		System.out.println("请输入第二个数据：");
		int y = sc.nextInt();
		
		//把键盘录入的数据进行相加即可
		int sum = (x + y);
		System.out.println("sum:"+sum);
	}
}

/*
	键盘录入练习：键盘录入两个数据，获取这两个数据中的最大值
*/

import java.util.Scanner;

class ScannerTest2 {
	public static void main(String[] args) {
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入第一个数据：");
		int a = sc.nextInt();
		
		System.out.println("请输入第二个数据：");
		int b = sc.nextInt();
		
		//获取这两个数据中的最大值
		int max = (a > b? a: b);
		System.out.println("max:"+max);
	}
}

键盘录入的练习2

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
/*
	练习：
		键盘录入三个数据，获取这三个数据中的最大值
		键盘录入两个数据，比较这两个数据是否相等
*/
import java.util.Scanner;

class ScannerTest3 {
	public static void main(String[] args) {
		//键盘录入三个数据，获取这三个数据中的最大值
	
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入第一个数据：");
		int a = sc.nextInt();
		
		System.out.println("请输入第二个数据：");
		int b = sc.nextInt();
		
		System.out.println("请输入第三个数据：");
		int c = sc.nextInt();
		
		//获取这三个数据中的最大值
		int temp = ((a > b)? a: b);
		int max = (temp > c? temp : c);
		System.out.println("max:"+max);
		System.out.println("------------------");
		
		//键盘录入两个数据
		System.out.println("请输入第一个数据：");
		int x = sc.nextInt();
		
		System.out.println("请输入第二个数据：");
		int y = sc.nextInt();
		
		//比较这两个数据是否相等
		boolean flag = (x == y);
		System.out.println("flag:"+flag);
	}
}

顺序结构语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/*
	流程控制语句：可以控制程序的执行流程。
	
	分类：
		顺序结构
		选择结构
		循环结构
		
	顺序结构：
		从上往下，依次执行。
*/
class ShunXuJieGouDemo {
	public static void main(String[] args) {
		System.out.println("程序开始了");
		
		System.out.println("我爱Java");
		
		System.out.println("程序结束了");
	}
}

选择结构if语句格式1

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
/*
	选择结构：
		if语句
		switch语句
		
	if语句：
		格式1
		格式2
		格式3
		
	if语句的格式：
		if(比较表达式) {
			语句体;
		}
		
		执行流程：
			先计算比较表达式的值，看其返回值是true还是false。
			如果是true，就执行语句体；
			如果是false，就不执行语句体；
*/
class IfDemo {
	public static void main(String[] args) {
		int x = 10;
		
		if(x == 10) {
			System.out.println("x等于10");
		}
		
		if(x == 20) {
			System.out.println("x等于20");
		}
		
		System.out.println("over");
	}
}

选择结构if语句注意事项

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
/*
	if语句的注意事项：
		A:比较表达式无论简单还是复杂，结果必须是boolean类型
		B:if语句控制的语句体如果是一条语句，大括号可以省略；
		  如果是多条语句，就不能省略。建议永远不要省略。
		C:一般来说：有左大括号就没有分号，有分号就没有左大括号
*/
class IfDemo2 {
	public static void main(String[] args) {
		int x = 10;
		
		if(x == 10) {
			System.out.println("x等于10");
		}
		
		if((x > 5) || (x == 10)) {
			System.out.println("x大于或者等于10");
		}
		System.out.println("-------------------");
		
		int a = 100;
		
		/*
		if(a == 100) {
			System.out.println("a的值是100");
		}
		*/
		
		if(a != 100) {
			System.out.println("a的值是100");
			System.out.println("over");
		}
		System.out.println("-------------------");
		
		int b = 100;
		if(b != 100);  //这里其实是有语句体的，只不过是空语句体。
		
		//代码块
		{
			System.out.println("b的值是100");
			System.out.println("over");
		}
	}
}

选择结构if语句格式2

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
/*
	if语句格式2：
		if(比较表达式) {
			语句体1;
		}else {
			语句体2;
		}
	执行流程：
		首先计算比较表达式的值，看其返回值是true还是false。
		如果是true，就执行语句体1；
		如果是false，就执行语句体2；
		
	注意：else后面是没有比较表达式的，只有if后面有。
*/
class IfDemo3 {
	public static void main(String[] args) {
		//判断两个数据是否相等
		
		int a = 10;
		int b = 20;
		
		if(a == b) {
			System.out.println("a等于b");
		}else {
			System.out.println("a不等于b");
		}
	}
}

选择结构if语句格式2的练习

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
/*
	if语句格式2的练习：
		A:获取两个数据中较大的值
		B:判断一个数据是奇数还是偶数,并输出是奇数还是偶数
*/
import java.util.Scanner;

class IfTest {
	public static void main(String[] args) {
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		
		//获取两个数据中较大的值
		System.out.println("请输入第一个数据：");
		int a = sc.nextInt();
		
		System.out.println("请输入第二个数据：");
		int b = sc.nextInt();
		
		//定义一个变量接收最大值
		int max;
		
		if(a > b) {
			max = a;
		}else {
			max = b;
		}
		
		System.out.println("max:"+max);
		System.out.println("----------------");
		
		//判断一个数据是奇数还是偶数
		System.out.println("请输入你要判断的数据：");
		int x = sc.nextInt();
		
		if(x%2 == 0) {
			System.out.println(x+"这个数据是偶数");
		}else {
			System.out.println(x+"这个数据是奇数");
		}
	}
}

if语句的格式2和三元的相互转换问题

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
/*
	由于if语句的第二种格式刚才也完成了三元运算符可以完成的效果。
	所以，我们就认为他们可以完成一样的操作。
	但是，他们就一点区别没有吗?肯定不是。
	
	区别：
		三元运算符实现的，都可以采用if语句实现。反之不成立。
		
		什么时候if语句实现不能用三元改进呢?
			当if语句控制的操作是一个输出语句的时候就不能。
			为什么呢?因为三元运算符是一个运算符，运算符操作完毕就应该有一个结果，而不是一个输出。
*/
class IfDemo4 {
	public static void main(String[] args) {
		//获取两个数据的最大值
		int a = 10;
		int b = 20;
		
		//用if语句实现
		int max1;
		if(a > b) {
			max1 = a;
		}else {
			max1 = b;
		}
		System.out.println("max1:"+max1);
		
		//用三元改进
		int max2 = (a > b)? a: b;
		System.out.println("max2:"+max2);
		System.out.println("----------");
		
		//判断一个数据是奇数还是偶数,并输出是奇数还是偶数
		int x = 100;
		
		if(x%2 == 0) {
			System.out.println("100是一个偶数");
		}else {
			System.out.println("100是一个奇数");
		} 
		
		//用三元改进
		//这种改进是错误的。
		//String s = (x%2 == 0)?System.out.println("100是一个偶数");:System.out.println("100是一个奇数");;
	}
}

选择结构if语句格式3

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
/*
	if语句的格式3：
		if(比较表达式1) {
			语句体1;
		}else if(比较表达式2) {
			语句体2;
		}else if(比较表达式3) {
			语句体3;
		}
		...
		else {
			语句体n+1;
		}
		
	执行流程：
		首先计算比较表达式1看其返回值是true还是false，
		如果是true，就执行语句体1，if语句结束。
		如果是false，接着计算比较表达式2看其返回值是true还是false，
		
		如果是true，就执行语句体2，if语句结束。
		如果是false，接着计算比较表达式3看其返回值是true还是false，
		...
		
		如果都是false，就执行语句体n+1。
*/
import java.util.Scanner;

class IfDemo5 {
	public static void main(String[] args) {
		//需求：键盘录入一个成绩，判断并输出成绩的等级。
		/*
			90-100 优秀
			80-90  好
			70-80  良
			60-70  及格
			0-60   不及格
		*/
		
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		
		//录入数据
		System.out.println("请输入你的考试成绩：");
		int score = sc.nextInt();
		
		/*
		if(score>=90 && score<=100) {
			System.out.println("优秀");
		}else if(score>=80 && score<90) {
			System.out.println("好");
		}else if(score>=70 && score<80) {
			System.out.println("良");
		}else if(score>=60 && score<70) {
			System.out.println("及格");
		}else {
			System.out.println("不及格");
		}
		*/
		//这样写已经满足我的基本要求，但是可能别人在使用的时候，不会按照你要求的数据给出了。
		//在做一个程序的基本测试的时候，一定要考虑这样的几个问题：
		//正确数据，错误数据，边界数据。
		//而我们刚才写的程序并没有处理错误数据，所以这个程序不是很好，要改进
		/*
		if(score>=90 && score<=100) {
			System.out.println("优秀");
		}else if(score>=80 && score<90) {
			System.out.println("好");
		}else if(score>=70 && score<80) {
			System.out.println("良");
		}else if(score>=60 && score<70) {
			System.out.println("及格");
		}else if(score>=0 && score<60){
			System.out.println("不及格");
		}else {
			System.out.println("你输入的成绩有误");
		}
		*/
		
		//另一种判断改进
		if(score<0 || score>100) {
			System.out.println("你输入的成绩有误");
		}else if(score>=90 && score<=100) {
			System.out.println("优秀");
		}else if(score>=80 && score<90) {
			System.out.println("好");
		}else if(score>=70 && score<80) {
			System.out.println("良");
		}else if(score>=60 && score<70) {
			System.out.println("及格");
		}else {
			System.out.println("不及格");
		}
	}
}

选择结构if语句格式3的练习

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
/*
	键盘录入月份的值，输出对应的季节。
	
	春	3,4,5
	夏	6,7,8
	秋	9,10,11
	冬	12,1,2
	
	分析：
		A:键盘录入月份的值，所以我们要使用Scanner。
		B:我们应该判断这个月份在那个季节，而这个判断情况较多，所以，用if语句格式3。
		
	if语句的使用场景：
		A:针对表达式是一个boolean类型的判断
		B:针对一个范围的判断
*/
import java.util.Scanner;

class IfTest3 {
	public static void main(String[] args) {
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		
		//录入数据
		System.out.println("请你输入一个月份:");
		int month = sc.nextInt();
		
		//第三种格式实现即可
		if(month<1 || month>12) {
			System.out.println("你输入的月份有误");
		}else if(month == 1) {
			System.out.println("冬季");
		}else if(month == 2) {
			System.out.println("冬季");
		}else if(month == 3) {
			System.out.println("春季");
		}else if(month == 4) {
			System.out.println("春季");
		}else if(month == 5) {
			System.out.println("春季");
		}else if(month == 6) {
			System.out.println("夏季");
		}else if(month == 7) {
			System.out.println("夏季");
		}else if(month == 8) {
			System.out.println("夏季");
		}else if(month == 9) {
			System.out.println("秋季");
		}else if(month == 10) {
			System.out.println("秋季");
		}else if(month == 11) {
			System.out.println("秋季");
		}else {
			System.out.println("冬季");
		}
		System.out.println("--------------");
		
		//这个程序确实是符合了我们的需求，但是就是看起来比较麻烦
		//那么，我们能不能改进一下呢?
		//month == 3
		//month == 4
		//month == 5
		//我们发现，上面三个都是春季。
		//而他们本身每一个都是一个boolean表达式
		//所以，我们就可以考虑使用逻辑运算符给他们连接起来改进
		if(month<1 || month>12) {
			System.out.println("你输入的月份有误");
		}else if(month==3 || month==4 || month==5) {
			System.out.println("春季");
		}else if(month==6 || month==7 || month==8) {
			System.out.println("夏季");
		}else if(month==9 || month==10 || month==11) {
			System.out.println("秋季");
		}else {
			System.out.println("冬季");
		}
		System.out.println("--------------");
		
		//这个时候，程序代码以及可以了。
		//但是呢，假如我要求你输入一个月份，判断是上半年还是下半年。
		//这个时候，我们的判断条件连接就是6个boolean表达式
		//我们可能还有更多的连接
		//这个时候，其实我们还有另外的一种改进方案：
		//month == 3
		//month == 4
		//month == 5
		//month>=3 && month<=5
		//用范围也是可以改进的。
		if(month<1 || month>12) {
			System.out.println("你输入的月份有误");
		}else if(month>=3 && month<=5) {
			System.out.println("春季");
		}else if(month>=6 && month<=8) {
			System.out.println("夏季");
		}else if(month>=9 && month<=11) {
			System.out.println("秋季");
		}else {
			System.out.println("冬季");
		}
		System.out.println("--------------");
	}
}

选择结构if语句的嵌套使用

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
/*
	获取三个数据中的最大值
	
	由此案例主要是为了讲解if语句是可以嵌套使用的。而且是可以任意的嵌套。
*/
class IfTest4 {
	public static void main(String[] args) {
		int a = 10;
		int b = 30;
		int c = 20;
		
		//三元实现
		//int temp = (a>b)? a: b;
		//int max = (temp>c)? temp: c;
		//System.out.println("max:"+max);
		//System.out.println("--------");
		
		//用if语句实现
		int max;
		if(a > b) {
			if(a > c) {
				max = a;
			}else {
				max = c;
			}
		}else {
			if(b > c) {
				max = b;
			}else {
				max = c;
			}
		}
		System.out.println("max:"+max);
	}
}

赏

×

纯属好玩

扫码支持
扫码打赏，你说多少就多少

打开支付宝扫一扫，即可进行扫码打赏哦

本文标题:JavaSE-Day(3)学习笔记

文章作者:Stephencurry6666

发布时间:2020年05月12日 - 17时38分

最后更新:2020年05月12日 - 20时39分

原始链接:https://stephencurry6666.github.io/2020/05/12/JavaSE-Day(3)%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/

许可协议: "署名-非商用-相同方式共享 3.0" 转载请保留原文链接及作者。

文章目录
  1. 1. 数据类型中补充的几个小问题
  2. 2. 算术运算符的基本用法
    1. 2.1. 算术运算符
    2. 2.2. 算术运算符++和—的使用
    3. 2.3. 算术运算符+的多种用法
    4. 2.4. 算术运算符++和—的练习
    5. 2.5. 赋值运算符的基本用法
    6. 2.6. 赋值运算符的面试题
    7. 2.7. 比较运算符的基本用法及其注意事项
    8. 2.8. 逻辑运算符的基本用法
    9. 2.9. 逻辑运算符&&和&的区别
    10. 2.10. 位运算的基本用法1
    11. 2.11. 位异或运算符的特点
    12. 2.12. 位运算的面试题
    13. 2.13. 位运算的基本用法2及面试题
    14. 2.14. 三元运算符的基本用法
    15. 2.15. 三元运算符的练习
    16. 2.16. 键盘录入的基本格式讲解
    17. 2.17. 键盘录入的练习1
    18. 2.18. 键盘录入的练习2
    19. 2.19. 顺序结构语句
    20. 2.20. 选择结构if语句格式1
    21. 2.21. 选择结构if语句注意事项
    22. 2.22. 选择结构if语句格式2
    23. 2.23. 选择结构if语句格式2的练习
    24. 2.24. if语句的格式2和三元的相互转换问题
    25. 2.25. 选择结构if语句格式3
    26. 2.26. 选择结构if语句格式3的练习
    27. 2.27. 选择结构if语句的嵌套使用
,
字数统计：87.6k 载入天数...载入时分秒...