JavaSE-Day(4)学习笔记

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

选择结构switch语句的格式及其解释

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
1:switch语句(掌握)
	(1)格式：
		switch(表达式) {
			case 值1:
				语句体1;
				break;
			case 值2:
				语句体2;
				break;
			...
			default:
				语句体n+1;
				break;
		}
		
		格式解释说明：
			switch:说明这是switch语句。
			表达式:可以是byte,short,int,char
				JDK5以后可以是枚举
				JDK7以后可以是字符串
			case:后面的值就是要和表达式进行比较的值
			break:表示程序到这里中断，跳出switch语句
			default:如果所有的情况都不匹配,就执行这里,相当于if语句中的else
	(2)面试题
		switch语句的表达式可以是byte吗?可以是long吗?可以是String吗?
			可以,不可以,JDK7以后可以

选择结构switch语句的基本实用

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
package stephencurry;
import java.util.*;
import java.math.*;
import java.io.*;
public class Main {
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int week = sc.nextInt();
        switch(week)
        {
        case 1:
        	System.out.println("星期一");
        	break;
        case 2:
			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;
		default:
			System.out.println("你输入的数据有误");
			break;
        }
	}
}

选择结构switch语句的注意事项

注意事项：
A:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
B:default可以省略吗?
可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。
特殊情况：
case就可以把值固定。
A,B,C,D
C:break可以省略吗?
可以省略，但是结果可能不是我们想要的。
会出现一个现象：case穿透。
最终我们建议不要省略
D:default一定要在最后吗?
不是，可以在任意位置。但是建议在最后。
E:switch语句的结束条件
a:遇到break就结束了
b:执行到末尾就结束了

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
import java.util.Scanner;

class SwitchDemo2 {
	public static void main(String[] args) {
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		
		//控制键盘录入数据
		System.out.println("请输入一个数据(1-7):");
		int week = sc.nextInt(); //3
		
		//定义常量
		//int number = 3;
		//然后把case后面的值改为number，就会报错
		
		//switch判断语句
		switch(week) {
			case 1:
				System.out.println("星期一");
				break;
			case 2:
				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;
			default:
				System.out.println("你输入的数据有误");
				//break;
		}
	}
}

选择结构switch语句练习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
/*
	看程序写结果
*/
class SwitchTest {
	public static void main(String[] args) {
		int x = 2;
		int y = 3;
		switch(x){
			default:
				y++;
				break;
			case 3:
				y++;
			case 4:
				y++;
		}
		System.out.println("y="+y);
		System.out.println("---------------");
		
		int a = 2;
		int b = 3;
		switch(a){
			default:
				b++;
			case 3:
				b++;
			case 4:
				b++;
		}
		System.out.println("b="+b);
	}
}

结果是：y=4；b=6

选择结构switch语句练习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
/*
	模拟单项选择题。
	
	分析：
		A:出一个选择题，然后供你选择。
		B:键盘录入选择的数据。
		C:根据选择来给出你选择的结论。
*/
import java.util.Scanner;

class SwitchTest2 {
	public static void main(String[] args) {
		//出一个选择题，然后供你选择。
		//由于我们现在没有办法键盘录入得到一个'A','B'
		//这样的东西，我就用65，66这样的值替代
		//将来我们获取到这样的值以后，强制转换为字符类型
		System.out.println("下面的几个人你最爱谁?");
		System.out.println("65 林青霞");
		System.out.println("66 张曼玉");
		System.out.println("67 刘德华");
		System.out.println("68 王力宏");
		
		//键盘录入选择的数据。
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入你的选择：");
		int choiceNumber = sc.nextInt();
		
		//强制转换为字符类型
		char choice = (char) choiceNumber;
		
		switch(choice) {
			case 'A':
				System.out.println("恭喜你,选择正确");
				break;
			case 'B':
				System.out.println("不好意思，你选择有误");
				break;
			case 'C':
				System.out.println("不好意思，你选择有误");
				break;
			case 'D':
				System.out.println("不好意思，你选择有误");
				break;
			default:
				System.out.println("没有该选项");
				break;
		}
	}
}

选择结构switch语句练习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
/*
	根据你键盘录入的字符串，判断是否有满足要求的，如果有就输出。
	否则，提示有误。
	
	String s = sc.nextLine();
*/
import java.util.Scanner;

class SwitchTest3 {
	public static void main(String[] args) {
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		
		//录入数据
		System.out.println("请输入你要判断的字符串：");
		String s = sc.nextLine();
		
		switch(s) {
			case "hello":
				System.out.println("你输入的是hello");
				break;
			case "world":
				System.out.println("你输入的是world");
				break;
			case "java":
				System.out.println("你输入的是java");
				break;
			default:
				System.out.println("没有找到你输入的数据");
				//break;
		}
	}
}

选择结构switch和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
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
/*
	用switch语句实现键盘录入月份，输出对应的季节
	
	分析：
		A:键盘录入一个月份，用Scanner实现
		B:用switch语句实现即可
		
	if语句和switch语句的区别?
		if语句：
			A:针对结果是boolean类型的判断
			B:针对一个范围的判断
			C:针对几个常量值的判断
		
		switch语句：
			针对几个常量值的判断
*/
import java.util.Scanner;

class SwitchTest4 {
	public static void main(String[] args) {
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		
		//录入数据
		System.out.println("请输入月份(1-12)：");
		int month = sc.nextInt();
		
		/*
		switch(month) {
			case 1:
				System.out.println("冬季");
				break;
			case 2:
				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;
			case 12:
				System.out.println("冬季");
				break;
			default:
				System.out.println("你输入的月份有误");
		}
		*/
		
		//这样写太麻烦了，我们使用一个我们不想使用的东西：case穿透
		switch(month) {
			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("你输入的月份有误");
		}
	}
}

循环结构循环语句概述

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/*
	需求：请在控制台输出10次"HelloWorld"
*/
class Demo {
	public static void main(String[] args) {
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
	}
}

循环结构for语句的格式和基本使用

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
/*
	循环语句：for循环,while循环,do...while循环。
	
	for循环格式：
		for(初始化语句;判断条件语句;控制条件语句) {
			循环体语句;
		}
		
		执行流程：
			A:执行初始化语句
			B:执行判断条件语句,看其返回值是true还是false
				如果是true，就继续执行
				如果是false，就结束循环
			C:执行循环体语句;
			D:执行控制条件语句
			E:回到B继续。
			
	需求：请在控制台输出10次"HelloWorld"
*/
class ForDemo {
	public static void main(String[] args) {
		//最原始的做法
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("----------");
		
		//这种做法不好,代码的重复度太高。
		//所以呢，我们用循环改进
		for(int x=1;x<=10;x++) {
			System.out.println("HelloWorld");
		}
	}
}

循环结构for语句的注意事项

注意事项：
A:判断条件语句无论简单还是复杂结果是boolean类型。

B:循环体语句如果是一条语句，大括号可以省略；如果是多条语句，大括号不能省略。建议永远不要省略。

C:一般来说：有左大括号就没有分号，有分号就没有左大括号

循环结构for语句练习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
/*
	需求：请在控制台输出数据1-10
*/
class ForDemo2 {
	public static void main(String[] args) {
		//原始做法
		System.out.println(1);
		System.out.println(2);
		System.out.println(3);
		System.out.println(4);
		System.out.println(5);
		System.out.println(6);
		System.out.println(7);
		System.out.println(8);
		System.out.println(9);
		System.out.println(10);
		
		System.out.println("-------------");
		
		//如何改进呢?用循环改进
		for(int x=1; x<=10; x++) {
			System.out.println(x);
		}
		
		System.out.println("-------------");
		
		//从0开始
		for(int x=0; x<10; x++) {
			System.out.println(x+1);
		}
	}
}

循环结构for语句练习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
/*
	需求：求出1-10之间数据之和
	
	分析：
		0+1=1
			1+2=3
				3+3=6
					6+4=10
						10+5=15
							 ...
							 
		由此可见我们要定义两个变量：
			一个变量用于存储第一个加数，第一个加数其实保存的是以前的所有数据和。默认初始化值应该是0。
			一个变量用于存储第二个加数，第二个加数其实就是每次的数据变化的值。
			
	求和思想。		
*/
class ForDemo3 {
	public static void main(String[] args) {
		//原始做法
		System.out.println(1+2+3+4+5+6+7+8+9+10);
		
		//定义第一个加数
		int sum = 0;
		
		for(int x=1; x<=10; x++) {
			//这里的x其实是第二个加数
			sum = sum + x;
			/*
				0 + 1 = 1
						1 + 2 = 3
								3 + 3 = 6
								...
			*/
			
			//sum += x;
		}
		
		System.out.println("sum:"+sum);
	}
}

循环结构for语句练习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
/*
	需求：
		A:求1-100之和。
		B:求出1-100之间偶数和
		C:求出1-100之间奇数和(自己做)
*/
class ForDemo4 {
	public static void main(String[] args) {
		//求1-100之和。
		int sum1 = 0;
		
		for(int x=1; x<=100; x++) {
			sum1 +=x;
		}
		
		System.out.println("1-100之和是："+sum1);
		System.out.println("------------------");
		
		//求出1-100之间偶数和
		//方式1
		int sum2 = 0;
		
		for(int x=1; x<=100; x++) {
			if(x%2 == 0) {
				sum2 += x;
			}
		}
		
		System.out.println("1-100偶数之和是："+sum2);
		System.out.println("------------------");
		
		//方式2
		int sum3 = 0;
		
		for(int x=0; x<=100; x+=2) {
				sum3 += x;
		}
		
		System.out.println("1-100偶数之和是："+sum3);
		System.out.println("------------------");
	}
}

循环结构for语句练习4阶乘

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
/*
	需求：求5的阶乘。
	
	什么是阶乘呢?
		n! = n*(n-1)! 规则
		n! = n*(n-1)*(n-2)*...*3*2*1
		
	求和思想。
	求阶乘思想。
*/
class ForDemo5 {
	public static void main(String[] args) {
		//定义最终结果变量
		int jc = 1;
		
		//这里的x其实可以直接从2开始
		//for(int x=1; x<=5; x++) 
		
		for(int x=2; x<=5; x++) {
			jc *=x;
		}
		
		System.out.println("1-5的阶乘是："+jc);
	}
}

循环结构for语句练习5水仙花数

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
/*
	天将降大任于斯人也,必先盗其QQ,封其微博,收其wifi,夺其手机。让其静心学习Java欧耶。

	需求：在控制台输出所有的”水仙花数”
	
	分析：
		我们都不知道什么叫"水仙花数"，你让我怎么做呢?
		
		所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。
		举例：153就是一个水仙花数。
		153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153

		A:三位数其实是告诉了我们范围。
		B:通过for循环我们就可以实现获取每一个三位数
		  但是麻烦是如何获取这个三位数的个,十,百位上的数据
		  
		  我们如何获取一个数据的个,十,百呢?
			假设有个一个数据:153
			ge:	153%10 = 3
			shi: 153/10%10 = 5
			bai：153/10/10%10 = 1
			qian：x/10/10/10%10
			wan:  x/10/10/10/10%10
			...

		C:让ge*ge*ge+shi*shi*shi+bai*bai*bai和该数据比较
		  如果相同，就把该数据在控制台输出。
*/
class ForDemo6 {
	public static void main(String[] args) {
		//三位数其实是告诉了我们范围。
		for(int x=100; x<1000; x++) {
			int ge = x%10;
			int shi = x/10%10;
			int bai = x/10/10%10;
			
			//让ge*ge*ge+shi*shi*shi+bai*bai*bai和该数据比较
			if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) {
				//如果相同，就把该数据在控制台输出。
				System.out.println(x);
			}
		}
	}
}

循环结构for语句练习6改进版的回文数

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:五位数就告诉了我们范围。
		B:分解每一个五位数的个，十，百，千，万位上的数据
		C:按照要求进行判断即可
*/
class ForDemo7 {
	public static void main(String[] args) {
		//五位数就告诉了我们范围。
		for(int x=10000; x<100000; x++) {
			//分解每一个五位数的个，十，百，千，万位上的数据
			int ge = x%10;
			int shi = x/10%10;
			int bai  = x/10/10%10;
			int qian = x/10/10/10%10;
			int wan = x/10/10/10/10%10;
			
			//按照要求进行判断即可
			if((ge==wan) && (shi==qian) && (ge+shi+qian+wan==bai)) {
				System.out.println(x);
			}
		}
	}
}

循环结构for语句练习7统计思想

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
/*
	需求：统计”水仙花数”共有多少个
	
	分析：
		A:首先必须知道什么是水仙花数
			所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。
			举例：153就是一个水仙花数。
			153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153
		B:定义统计变量，初始化值是0
		C:三位数告诉了我们范围，用for循环就可以搞定
		D:获取每一个三位数的个，十，百的数据
		E:按照要求进行判断
		F:如果满足要求就计数。
*/
class ForDemo8 {
	public static void main(String[] args) {
		//定义统计变量，初始化值是0
		int count = 0;
		
		//三位数告诉了我们范围，用for循环就可以搞定
		for(int x=100; x<1000; x++) {
			//获取每一个三位数的个，十，百的数据
			int ge = x%10;
			int shi = x/10%10;
			int bai = x/10/10%10;
			
			//按照要求进行判断
			if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) {
				//如果满足要求就计数。
				count++;
			}
		}
		
		System.out.println("水仙花数共有"+count+"个");
	}
}

循环结构for语句练习8同时取余问题

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
/*
	需求：请统计1-1000之间同时满足如下条件的数据有多少个：
			对3整除余2
			对5整除余3
			对7整除余2

	分析：
		A:定义统计变量,初始化值是0
		B:1-1000之间是一个范围，用for很容易就可以实现。
		C:每个数据要同时满足如下要求
			x%3==2
			x%5==3
			x%7==2
		D:如果满足条件，统计数据++即可，最后输出统计变量
*/
class ForDemo9 {
	public static void main(String[] args) {
		//定义统计变量,初始化值是0
		int count = 0;
	
		//1-1000之间是一个范围，用for很容易就可以实现。
		for(int x=1; x<=1000; x++) {
			/*
				每个数据要同时满足如下要求
				x%3==2
				x%5==3
				x%7==2
			*/
			if(x%3==2 && x%5==3 && x%7==2) {
				count++;
				System.out.println(x);
			}
		}
		
		//输出数据
		System.out.println("满足这样条件的数据共有："+count+"个");
	}
}

循环结构while语句的基本格式和使用

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
/*
	while循环的基本格式：
		while(判断条件语句) {
			循环体语句;
		}
		
		扩展格式：
		
		初始化语句;
	    while(判断条件语句) {
			 循环体语句;
			 控制条件语句;
		}
		
		通过这个格式，我们就可以看到其实和for循环是差不多的。
		
		for(初始化语句;判断条件语句;控制条件语句) {
			循环体语句;
		}
*/
class WhileDemo {
	public static void main(String[] args) {
		//输出10次"HelloWorld"
		//for语句版
		for(int x=0; x<10; x++) {
			System.out.println("HelloWorld");
		}
		System.out.println("--------------");
		//while语句版
		int x=0;
		while(x<10) {
			System.out.println("HelloWorld");
			x++;
		}
	}
}

循环结构while语句的练习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
/*
	练习：用while循环实现
	左边：求出1-100之和
	右边：统计水仙花数有多少个
	
	初始化语句;
	while(判断条件语句) {
		 循环体语句;
		 控制条件语句;
	}
	
	
	
	for(初始化语句;判断条件语句;控制条件语句) {
		循环体语句;
	}

*/
class WhileDemo2 {
	public static void main(String[] args) {
		//求出1-100之和
		//for语句版本
		int sum = 0;
		
		for(int x=1; x<=100; x++) {
			sum+=x;
		}
		
		System.out.println("sum:"+sum);
		System.out.println("--------");
		//while语句版本
		int sum2 = 0;
		
		int y=1;
		while(y<=100) {
			sum2+=y;
			y++;
		}
		
		System.out.println("sum2:"+sum2);
		System.out.println("--------");
	}
}

循环结构while语句的练习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
/*
	需求：统计水仙花数有多少个
*/
class WhileDemo3 {
	public static void main(String[] args) {
		//for循环版本
		int count = 0;
		
		for(int x=100; x<1000; x++) {
			int ge = x%10;
			int shi = x/10%10;
			int bai = x/10/10%10;
			
			if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {
				count++;
			}
		}
		
		System.out.println("count:"+count);
		System.out.println("------------");
		
		//while循环版本
		int count2 = 0;
		
		int y = 100;
		while(y<1000) {
			int ge = y%10;
			int shi = y/10%10;
			int bai = y/10/10%10;
			
			if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == y) {
				count2++;
			}
			
			y++;
		}
		
		System.out.println("count2:"+count2);
	}
}

循环结构while语句和for语句的区别

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
/*
	while循环和for循环的区别?
		使用区别：如果你想在循环结束后，继续使用控制条件的那个变量，用while循环，否则用for循环。不知道用for循环。
		          因为变量及早的从内存中消失，可以提高内存的使用效率。
				  
		其实还有一种场景的理解:
			如果是一个范围的，用for循环非常明确。
			如果是不明确要做多少次，用while循环较为合适。
				举例：吃葡萄。
*/
class WhileDemo4 {
	public static void main(String[] args) {
		//for循环实现
		for(int x=0; x<10; x++) {
			System.out.println("学习Java技术哪家强,中国北京传智播客");
		}
		//这里不能在继续访问了
		//System.out.println(x);
		
		//while循环实现
		int y = 0;
		while(y<10) {
			System.out.println("学习Java技术哪家强,中国北京传智播客");
			y++;
		}
		//这里是可以继续访问的
		System.out.println(y);
	}
}

循环结构while语句和练习珠穆朗玛峰

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
/*
	我国最高山峰是珠穆朗玛峰：8848m，我现在有一张足够大的纸张，厚度为：0.01m。
	请问，我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度?

	分析：
		A:定义一个统计变量，默认值是0
		B:最高山峰是珠穆朗玛峰：8848m这是最终的厚度
		  我现在有一张足够大的纸张，厚度为：0.01m这是初始厚度
		C:我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度?
		  折叠一次有什么变化呢?就是厚度是以前的2倍。
		D:只要每次变化的厚度没有超过珠穆朗玛峰的高度，就折叠，统计变量++
		E:输出统计变量。
*/

class WhileDemo5 {
	public static void main(String[] args) {
		//定义一个统计变量，默认值是0
		int count = 0;
		
		//最高山峰是珠穆朗玛峰：8848m这是最终的厚度
		//我现在有一张足够大的纸张，厚度为：0.01m这是初始厚度
		//为了简单，我把0.01变成1，同理8848就变成了884800
		int end = 884800;
		int start = 1;
		
		while(start<end) {
			//只要每次变化的厚度没有超过珠穆朗玛峰的高度，就折叠，统计变量++
			count++;
			
			//折叠一次有什么变化呢?就是厚度是以前的2倍。
			start *= 2;
			
			System.out.println("第"+count+"次厚度是"+start);
		}
		
		//输出统计变量。
		System.out.println("要叠"+count+"次");
	}
}

循环结构do…while语句的格式和基本使用

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
/*
	do...while循环的基本格式：
		do {
			循环体语句;
		}while(判断条件语句);
		
		扩展格式；
		初始化语句;
		do {
			循环体语句;
			控制条件语句;
		}while(判断条件语句);
*/
class DoWhileDemo {
	public static void main(String[] args) {
		//输出10次HelloWorld。
		int x = 0;
		do {
			System.out.println("HelloWorld");
			x++;
		}while(x<10);
		
		System.out.println("--------------");
		
		//求和1-100
		int sum = 0;
		int a = 1;
		do {
			sum += a;
			a++;
		}while(a<=100);
		
		System.out.println(sum);
	}
}

循环结构三种循环语句的区别

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
/*
	循环语句的区别:
		do...while循环至少执行一次循环体。
		而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。
		
	那么，我们一般使用哪种循环呢?
		优先考虑for，其次考虑while，最后考虑do...while
*/
class DoWhileDemo2 {
	public static void main(String[] args) {
		int x = 3;
		while(x < 3) {
			System.out.println("我爱林青霞");
			x++;
		}
		
		System.out.println("--------------");
		
		int y = 3;
		do {
			System.out.println("我爱林青霞");
			y++;
		}while(y < 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
/*
	注意死循环：
		A:一定要注意控制条件语句控制的那个变量的问题，不要弄丢了，否则就容易死循环。
		B:两种最简单的死循环格式
			while(true){...}
			for(;;){...}
			
*/
class DoWhileDemo3 {
	public static void main(String[] args) {
		int x = 0;
		while(x < 10) {
			System.out.println(x);
			x++;
		}
		System.out.println("------------");
		
		/*
		while(true) {
			System.out.println("今天我很高兴，学习了死循环");
			
		}
		*/
		
		for(;;) {
			System.out.println("今天我很高兴，学习了死循环");
		}
	}
}

循环结构循环嵌套输出4行5列的星星

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
/*
	需求：请输出一个4行5列的星星(*)图案。
	结果：
		*****
		*****
		*****
		*****
		
	循环嵌套：就是循环语句的循环体本身是一个循环语句。
	
	通过结果我们知道这样的一个结论：
		外循环控制行数
		内循环控制列数
*/
class ForForDemo {
	public static void main(String[] args) {
		//原始做法
		System.out.println("*****");
		System.out.println("*****");
		System.out.println("*****");
		System.out.println("*****");
		System.out.println("-------------");
		
		//虽然可以完成需求，但是不是很好
		//如果是多行多列就会比较麻烦
		//所以我们准备改进
		//如何改进呢?
		//我先考虑如何实现一行*的问题
		//System.out.println("*****");
		//我们要想的是如何实现一次输出一颗*的问题
		//System.out.println("*");
		//System.out.println("*");
		//现在虽然可以一次一颗*，但是却换行了，我要求不能换行，怎么办呢?
		//输出语句的另一种格式：System.out.print(); 这个是不带换行的
		//System.out.print("*");
		//System.out.print("*");
		//System.out.print("*");
		//System.out.print("*");
		//System.out.print("*");
		//如果我要在一行上打出多颗*，比较麻烦，而代码是重复的，所以我决定用循环改进
		for(int x=0; x<5; x++) {
			System.out.print("*");
		}
		//我们可以通过空的输出语句实现换行：System.out.println();
		System.out.println();
		
		//既然我可以打出一行，我就可以打出第二行
		for(int x=0; x<5; x++) {
			System.out.print("*");
		}
		//我们可以通过空的输出语句实现换行：System.out.println();
		System.out.println();
	
		//同理打出第三行，第四行
		for(int x=0; x<5; x++) {
			System.out.print("*");
		}
		//我们可以通过空的输出语句实现换行：System.out.println();
		System.out.println();
		
		//既然我可以打出一行，我就可以打出第二行
		for(int x=0; x<5; x++) {
			System.out.print("*");
		}
		//我们可以通过空的输出语句实现换行：System.out.println();
		System.out.println();
		System.out.println("-----------------");
		//同样的代码出现了4次，说明我们程序写的不好，用循环改进
		for(int y=0; y<4; y++) {
			for(int x=0; x<5; x++) {
				System.out.print("*");
			}
			//我们可以通过空的输出语句实现换行：System.out.println();
			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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
/*
	需求：请输出下列的形状
		*
		**
		***
		****
		*****
*/
class ForForDemo2 {
	public static void main(String[] args) {
		//通过简单的观察，我们看到这是一个行是5，列数是变化的形状
		//我们先打印出一个5行5列的形状
		for(int x=0; x<5; x++) {
			for(int y=0; y<5; y++) {
				System.out.print("*");
			}
			System.out.println();
		}
		
		System.out.println("--------------");
		
		//我们实现了一个5行5列的形状
		//但是这不是我们想要的
		//我们要的是列数变化的
		//列数是如何变化的呢?
		//第一行：1列	y=0,y<=0,y++
		//第二行：2列	y=0,y<=1,y++
		//第三行：3列	y=0,y<=2,y++
		//第四行：4列	y=0,y<=3,y++
		//第五行：5列	y=0,y<=4,y++
		//在看外循环x的变化，恰好就是x=0,1,2,3,4
		//所以这个最终版的程序就是如下
		for(int x=0; x<5; x++) {
			for(int y=0; y<=x; y++) {
				System.out.print("*");
			}
			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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
/*
	需求：在控制台输出九九乘法表。
	
	首先我们写出九九乘法表：
		1*1=1
		1*2=2	2*2=4
		1*3=3	2*3=6	3*3=9
		1*4=4	2*4=8	3*4=12	4*4=16
		...
		1*9=9	2*9=18	3*9=27	...
		
	我们先把这个九九乘法表看出是这样的一个形状：
		*
		**
		***
		****
		*****
		******
		*******
		********
		*********
		
	注意：
		'\x' x表示任意，这种做法叫转移字符。
		
		'\t'	tab键的位置
		'\r'	回车
		'\n'	换行
*/
class ForForDemo3 {
	public static void main(String[] args) {
		for(int x=0; x<9; x++) {
			for(int y=0; y<=x; y++) {
				System.out.print("*");
			}
			System.out.println();
		}
		System.out.println("--------------");
		//为了使用数据，我们从1开始
		for(int x=1; x<=9; x++) {
			for(int y=1; y<=x; y++) {
				System.out.print(y+"*"+x+"="+y*x+"\t");
			}
			System.out.println();
		}
	}
}

控制跳转语句break语句

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
package stephencurry;
import java.util.*;
import java.math.*;
import java.io.*;
public class Main {
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        for(int x=0; x<10; x++) {
			if(x == 3) {
				break;
			}
			System.out.println("HelloWorld");
		}
		
		System.out.println("over");
		System.out.println("-------------");
		
		wc:for(int x=0; x<3; x++) {
			nc:for(int y=0; y<4; y++) {
				if(y == 2) {
					//break nc;
					break wc;
				}
				System.out.print("*");
			}
			System.out.println();
		}
	}
}

控制跳转语句continue语句

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
/*
	continue:继续
	
	使用场景：
		循环中。离开此场景无意义。
		
	测试，找到和break的区别：
		break:跳出单层循环
		continue:跳出一次循环，进入下一次的执行
		
	练习题：
		for(int x=1; x<=10; x++) {
			if(x%3==0) {
				//在此处填写代码
			}
			System.out.println(“Java基础班”);
		}
		
		我想在控制台输出2次:“Java基础班“
			break;
		我想在控制台输出7次:“Java基础班“
			continue;
		我想在控制台输出13次:“Java基础班“	
			System.out.println(“Java基础班”);


*/
class ContinueDemo {
	public static void main(String[] args) {
		for(int x=0; x<10; x++) {
			if(x == 3) {
				//break;
				continue;
			}
			
			System.out.println(x);
		}
	}
}

控制跳转语句return语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/*
	return:返回
	
	其实它的作用不是结束循环的，而是结束方法的。
*/
class ReturnDemo {
	public static void main(String[] args) {
		for(int x=0; x<10; x++) {
			if(x == 2) {
				System.out.println("退出");
				//break;
				//continue;
				return;
			}
			
			System.out.println(x);
		}
		
		System.out.println("over");
	}
}

while语句和break结合使用之小芳存钱

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
/*
	需求：小芳的妈妈每天给她2.5元钱，她都会存起来，但是，
	      每当这一天是存钱的第5天或者5的倍数的话，她都会花去6元钱，
		  请问，经过多少天，小芳才可以存到100元钱。

	分析：
		A:小芳的妈妈每天给她2.5元钱
			double dayMoney = 2.5;
		B:她都会存起来
			double daySum = 0;
		C:从第一天开始存储
			int dayCount = 1;
		D:经过多少天，小芳才可以存到100元钱。
			double result = 100;
		E:这一天是存钱的第5天或者5的倍数的话，她都会花去6元钱，
			说明要判断dayCount的值，如果对5整除就减去6元钱。
				daySum -= 6;
		  由此还隐含了一个问题，就是如果不是5的倍数天的话，钱要累加
				daySum += dayMoney;
		F:因为不知道是多少天，所以我用死循环，一旦超过100元我就退出循环。
*/
class WhileDemo {
	public static void main(String[] args) {
		//每天要存储的钱是2.5元
		double dayMoney = 2.5;
		
		//存钱的初始化值是0
		double daySum = 0;
		
		//从第一天开始存储
		int dayCount = 1;
		
		//最终存储不小于100就不存储了
		int result = 100;
		
		//因为不知道是多少天，所以我用死循环，
		while(true) {
			//累加钱
			daySum += dayMoney;
			
			//一旦超过100元我就退出循环。
			if(daySum >= result) {
				System.out.println("共花了"+dayCount+"天存储了100元");
				break;
			}
			
			if(dayCount%5 == 0) {
				//花去6元钱
				daySum -= 6;
				System.out.println("第"+dayCount+"天花了6元钱");
			}
			
			//天数变化
			dayCount++;
		}
	}
}

赏

×

纯属好玩

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

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

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

文章作者:Stephencurry6666

发布时间:2020年05月14日 - 15时14分

最后更新:2020年05月14日 - 20时44分

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

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

文章目录
  1. 1. 选择结构switch语句的格式及其解释
  2. 2. 选择结构switch语句的基本实用
  3. 3. 选择结构switch语句的注意事项
  4. 4. 选择结构switch语句练习1看程序写结果
  5. 5. 选择结构switch语句练习2单项选择题
  6. 6. 选择结构switch语句练习3表达式求字符串
  7. 7. 选择结构switch和if语句的各自使用场景
  8. 8. 循环结构循环语句概述
  9. 9. 循环结构for语句的格式和基本使用
  10. 10. 循环结构for语句的注意事项
  11. 11. 循环结构for语句练习1获取数据
  12. 12. 循环结构for语句练习2求和思想
  13. 13. 循环结构for语句练习3偶数和
  14. 14. 循环结构for语句练习4阶乘
  15. 15. 循环结构for语句练习5水仙花数
  16. 16. 循环结构for语句练习6改进版的回文数
  17. 17. 循环结构for语句练习7统计思想
  18. 18. 循环结构for语句练习8同时取余问题
  19. 19. 循环结构while语句的基本格式和使用
  20. 20. 循环结构while语句的练习1求和思想
  21. 21. 循环结构while语句的练习2统计思想
  22. 22. 循环结构while语句和for语句的区别
  23. 23. 循环结构while语句和练习珠穆朗玛峰
  24. 24. 循环结构do…while语句的格式和基本使用
  25. 25. 循环结构三种循环语句的区别
  26. 26. 循环结构循环注意事项之死循环
  27. 27. 循环结构循环嵌套输出4行5列的星星
  28. 28. 循环结构循环嵌套输出直角三角形
  29. 29. 循环结构九九乘法表
  30. 30. 控制跳转语句break语句
  31. 31. 控制跳转语句continue语句
  32. 32. 控制跳转语句return语句
  33. 33. while语句和break结合使用之小芳存钱
,
字数统计：87.6k 载入天数...载入时分秒...