韩顺平 零基础30天学会Java第五章_输入整数year (1

顺序控制

顺序控制介绍

程序从上到下逐行地执行，中间没有任何判断和跳转。

顺序控制举例和注意事项

Java中定义变量时采用合法的前向引用。如:

public class Test{
	int num1 = 12;
	int num2 = num1 + 2;
}
//错误形式:
public class Test{
	int num2 = num1 +2;//错误
	int num1 = 12;
}
1
2
3
4
5
6
7
8
9

分支控制if-else

分支控制if-else介绍
让程序有选择的的执行,分支控制有三种：
1)单分支
2)双分支
3)多分支

单分支

基本语法

if(条件表达式){
	执行代码块;(可以有多条语句.)
}
1
2
3

说明:当条件表达式为ture时，就会执行{}的代码。如果为false ,就不执行.特别说明，如果{}中只有一条语句，则可以不用{}，建议写上{}
案例说明
编写一个程序,可以输入人的年龄,如果该同志的年龄大于18岁,则输出“你年龄大于18,要对自己的行为负责,送入监狱”

import java.util.Scanner;
public class If01 {
	//编写一个main方法
	public static void main(String[] args) {
		//编写一个程序,可以输入人的年龄,如果该同志的年龄大于18岁,
		//则输出“你年龄大于18,要对自己的行为负责,送入监狱"
		//
		//思路分析
		//1．接收输入的年龄，应该定义一个Scanner 对象
		//2．把年龄保存到一个变量int age
		//3．使用if 判断,输出对应信息
		//应该定义一个Scanner 对象
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入年龄");
		//把年龄保存到一个变量int age
		int age = myScanner.nextInt();
		//使用if判断,输出对应信息
		if(age > 18) {
		System.out.println("你年龄大于18,要对自己的行为负责,送入监狱");
		}
		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

双分支

基本语法

if(条件表达式){
	执行代码块1;
}
else {
执行代码块2;
}
1
2
3
4
5
6

说明:当条件表达式成立，即执行代码块1，否则执行代码块2.如果执行代码块只有一条语句，则可以省略，否则，不能省略
案例演示
请大家看个案例
编写一个程序,可以输入人的年龄,如果该同志的年龄大于18岁,则输出"你年龄大于18,要对自己的行为负责,送入监狱"。否则,输出"你的年龄不大这次放过你了."

import java.util.Scanner;
public class If02 {
	//编写一个main方法
	public static void main(String[] args) {
		//编写一个程序,可以输入人的年龄,如果该同志的年龄大于18岁,
		//则输出“你年龄大于18,要对自己的行为负责,送入监狱"
		//否则,输出"你的年龄不大这次放过你了."
		//思路分析
		//1．接收输入的年龄，应该定义一个Scanner 对象
		//2．把年龄保存到一个变量int age
		//3．使用if-else 判断,输出对应信息
		//应该定义一个Scanner 对象
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入年龄");
		//把年龄保存到一个变量int age
		int age = myScanner.nextInt();
		//使用if判断,输出对应信息
		if(age > 18) {
		System.out.println("你年龄大于18,要对自己的行为负责,送入监狱");
		} else {//双分支
			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

单分支和双分支练习题

1.对下列代码，若有输出，指出输出结果。

int x = 7;
int y = 4;
if (x > 5) {
	if (y > 5){
	System.out.println(x + y);
	}
	System.out.println("韩顺平教育~");
} else
	System.out.println("x is " + x);
//输出的内容是?韩顺平教育~
1
2
3
4
5
6
7
8
9
10

2.编写程序，声明2个double型变量并赋值。判断第一个数大于10.0，且第2个数小于20.0，打印两数之和

double d1 = 3.5;
double d2 = 2.6;
if(d1 > 10.0 && d2 < 20.0) {
	system.out.println("两个数和=" + (d1 + d2));
}
1
2
3
4
5

3.【课后自己练】定义两个变量int,判断二者的和，是否能被3又能被5整除,打印提示信息

//思路分析
//1．定义两个变量int num1,num2
//2．定义一个变量int sum = num1 + num2;
//3.sum %3,5后等于0说明可以整除
//4．使用if - else 来提示对应信息
int num1 = 10;
int num2 = 5;
int sum = num1 + num2 ;
if(sum % 3 ==  &8 sum % 5 ==) {
	System.out.print1n("和可以被3又能被5整除");
} else {
	system.out.println("和可以不能被3和5整除");
}
1
2
3
4
5
6
7
8
9
10
11
12
13

4.判断一个年份是否是闰年，闰年的条件是符合下面二者之一:(1)年份能被4整除，但不能被100整除;(2)能被400整除

思路分析
//1。定义int year保存年
//2．年份能被4整除,但不能被100整除,
// 	=> year % 4 == 0 && year %100 !=0
//3．能被400整除=> year % 400 == 0
//4. 上面的 2和3是或的关系
//代码实现工
int year = 2023;
if( (year % 4 == 0 && year % 100 !=0)|| year % 400 ==0 ) {
	System.out.println(year +”是闰年");
}else {
	System.out.print1n(year + “不是闰年");
}
1
2
3
4
5
6
7
8
9
10
11
12
13

多分支基本语法

if(条件表达式1) {
	执行代码块1;
} else if (条件表达式2) {
	执行代码块2;
}
...
else{
执行代码块n;
}
1
2
3
4
5
6
7
8
9

特别说明:(1)多分支可以没有else，如果所有的条件表达式都不成立，则一个执行入口都没有(2)如果有else ,如果所有的条件表达式都不成立，则默认执行else代码块
案例演示1
请大家看个案例[If03.java]:
输入保国同志的芝麻信用分:
如果:
1.信用分为100分时，输出信用极好;
2.信用分为(80，99]时，输出信用优秀;
3.信用分为[60,80]时，输出信用一般;
4.其它情况，输出信用不及格
5.请从键盘输入保国的芝麻信用分,并加以判断

import java.util.Scanner;
public class If03 {
	//编写一个main方法
	public static void main(String[ ] args) {
		/*
		输入保国同志的芝麻信用分∶
		如果︰
		信用分为100分时，输出信用极好;
		信用分为(80,99]时，输出信用优秀;
		信用分为[60,80]时，输出信用一般﹔
		其它情况，输出信用不及格
		请从键盘输入保国的芝麻信用分，并加以判断假定信用分数为int
		*/
		Scanner myScanner = new Scanner(System.in);
		//接收用户输入
		system.out.println("请输入信用分:");
		int grade = myScanner.nextInt();//因为有4种情况，所以使用多分支
		//先对输入的信用分，进行一个范围的有效判断1-100，否则提示输入错误
		if(grade >=1 && grade <= 100) {

			if(grade == 100) {
				System.out.println("信用极好");
			} else if (grade > 80 && grade <= 99){
				system.out.println("信用优秀");
			} else if (grade >= 60 && grade <= 80){
				system.out.println("信用一般");
			}else {
				system.out.print1n("信用不及格");
			}
		} else {
			system.out.println("信用分需要在1-100,请重新输入:)");
		}
	}
}
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

案例演示2

//代码,看看输出什么?
boolean b = true;
if(b == false) // 【b】
	System.out.println("a");
else if(b)
	System.out.println("b");
else if(!b)
	System.out.println("c");
else
	System.out.println("d");
1
2
3
4
5
6
7
8
9
10

嵌套分支

基本介绍
在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层分支，外面的分支结构称为外层分支。规范:不要超过3层(可读性不好)
基本语法

if(){
	if(){
		//if-else....
	}else{
		//if-else
	}
}
1
2
3
4
5
6
7

应用案例
参加歌手比赛，如果初赛成绩大于8.0进入决赛，否则提示淘汰。并且根据性别提示进入男子组或女子组。【可以让学员先练习下】，输入成绩和性别，进行判断和输出信息。

提示:double score; char gender;
接收字符: char gender = scanner.next().c harAt(0)

import java.util.Scanner;
public class NestedIf {
//编写一个main方法
	public static void main(String[] args) {
	//思路分析
	//1．创建Scanner对象，接收用户输入
	//2．接收成绩保存到double score
	//3．使用if-else 判断如果初赛成绩大于8.0进入决赛,否则提示淘汰
	//4．如果进入到决赛，再接收char gender，使用if-else 输出信息
	//代码实现
	Scanner myScanner = new Scanner(System.in);
	System.out.println("请输入该歌手的成绩");
	double score = myScanner.nextDouble();
	if( score > 8.0 ) {
			System.out.println("请输入性别");
			char gender = myScanner.next().charAt(O);
			if( gender == '男') {
				System.out. print1n("进入男子组");
			} else if(gender == '女') {
				System.out.println("进入女子组");
			}else {
				System.out.println("你的性别有误，不能参加决赛");
			}
		}else {
			System.out. print1n( "sorry ,你被淘汰了~");
		}
	}
}
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

应用案例2
出票系统:根据淡旺季的月份和年龄，打印票价[课后练习]
4_10旺季:
成人(18-60) :60
儿童(<18):半价
老人(>60) :1/3
淡季:
成人:40
其他:20
思路分析
(1)淡旺季- if- else
(2)在旺季中，可以使用多分支处理三种情况
(3)在淡季情况，使用双分支处理即可

import java.util.Scanner;
public class hw01 {
	public static void main(String[] args){
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入当前月份：");
		int month = myScanner.nextInt();
		System.out.println("请输入您的年龄：");
		int age = myScanner.nextInt();
		if (4 <= month && month <= 10){
			if (age > 60){
				System.out.println("票价为20元");
			} else if(age >= 18){
				System.out.println("票价为60元");
			} else {
				System.out.println("票价为30元");
			}
		} else {
			if (18 <= age && age <= 60) {
				System.out.println("票价为40元");
			} else {
				System.out.println("票价为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

switch分支结构

switch(表达式){
	case常量1;//当……
	语句块1;
	break;
	case常量2;
	语句块2;
	break;
	…
	case常量n;
	语句块n;
	break;
	default:
	default语句块;
	break;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

老韩解读switch
1.switch关键字，表示swtich分支
2.表达式对应一个值
3.case常量1:当表达式的值等于常量1，就执行语句块1
4.break :表示退出swtich
5.如果和case常量1匹配，就执行语句块1，如果没有匹配，就继续匹配case常量2
6.如果一个都没有匹配上，执行default

快速入门

案例:Switch01.java
1.请编写一个程序，该程序可以接收一个字符，比如:a,b,c,d.ef.g
2. a表示星期一，b表示星期二…
3. 根据用户的输入显示相依的信息.要求使用switch 语句完成

import java.util.Scanner;
public class Switch01 {
	//编写一个main方法
	public static void main(String[] args) {
		/*
		思路分析
		1.接收一个字符,创建Scanner对象
		2．使用switch来完成匹配,并输出对应信息代码
		代码*/
		Scanner myScanner = new Scanner(system.in);
		system.out.println("请输入一个字符(a-g)");
		char c1 = myScanner.next().charAt(O);
		//在java中,只要是有值返回，就是一个表达式
		switch(c1) {
			case 'a' :
				System.out.print1n("今天星期一,猴子穿新衣");
				break ;
			case 'b':
				System.out.println("今天星期二,猴子当小二");
				break;
			case 'c' :
				System.out.print1n("今天星期三,猴子爬雪山");
				break;
			//.....
			default:
				System. out.println("你输入的字符不正确，没有匹配的");
		}
		System.out.println("退出了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

switch注意事项和细节讨论

1．表达式数据类型，应和case后的常量类型一致，或者是可以自动转成可以相互比较类型，比如输入的是字符，而常量是int

char c = 'a ';
switch(c) {
	case 'a' :
		System.out.print1n( "ok1" );break;
	case 'b' :
		System.out.print1n( "ok2" );break;
	default :
		System.out.print1n( "ok3");

1
2
3
4
5
6
7
8
9

2 . switch(表达式)中表达式的返回值必须是:(byte,short,int,char,enum[枚举],String)

double c = 1.1;
switch(c) {//错误
	case 1.1: //错误
		System.out.print1n( "ok1" );break;
	case 2.1 :
		System.out.print1n( "ok2" );break;
	default :
		System.out.print1n( "ok3");
//错误，返回值不正确
1
2
3
4
5
6
7
8
9

3 . case子句中的值必须是常量或常量表达式 ,而不能是变量

char c = 'a ';
char c2 = 'c';
switch(c) {
	case 'a':
		system.out.println( "ok1" );break;
	case c2 : //错误，不能使用变量
		System.out.println( "ok2" );break;
	default :
		System.out.println( "ok3" );
}	
1
2
3
4
5
6
7
8
9
10

4 . default子句是可选的，当没有匹配的case时，执行default；如果没有default子句,有没有匹配任何常量，则没有输出
5 . break语句用来在执行完一个case分支后使程序跳出switch语句块;如果没有写break，程序会顺序执行到switch结尾，除非没有遇到break。

switch课堂练习(学员先做)

1.使用switch 把小写类型的char型转为大写(键盘输入)。只转换a, b, c, d, e.其它的输出"other"。

import java.util.Scanner;
public class hw02{
	public static void main(String[] args) {
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入一个字符(a-e)");
		char c1 = myScanner.next().charAt(0);
		switch(c1){
			case 'a':
				System.out.println("A");
				break;
			case 'b':
				System.out.println("B");
				break;
			case 'c':
				System.out.println("C");
				break;
			case 'd':
				System.out.println("D");
				break;
			case 'e':
				System.out.println("E");
				break;
			default :
				System.out.println("other");

		}
	}
}
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

2对学生成绩大于60分的,输出"合格"。低于60分的，输出"不合格"。(注:输入的成绩不能大于100),提示成绩/60

//思路分析
//1．这道题,可以使用分支来完成，但是要求使用switch
//2．这里我们需要进行一个转换,编程思路:
//如果成绩在[60,100] , (int)(成绩/60)= 1
//如果成绩在[0,60), (int)(成绩/60)= 0
//代码实现
double score = 88.5;
//使用if-else保证输入的成绩有有效的 6-100
if(score >= 0 && score<= 100) {
	switch ((int) (score / 60)){
		case 0 :
			system.out.println("不合格");
			break;
		case 1 :
			System.out.println("合格");
			break;
	}
} else {
			system.out. print1n("输入的成绩在O-100");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3.根据用于指定月份,打印该月份所属的季节。3.4.5春季6,7,8夏季9,10,11秋季12,1,2冬季[课堂练习,提示使用穿透]

//思路分析
//1．创建Scanner对象,接收用户输入
//2．使用int month接收
//3．使用switch 来匹配,使用穿透来完成，比较简洁
scanner myScanner = new Scanner(System.in);
system.out.print1n("输入月份");
int month = myScanner.nextInt();
switch(month) {
	case 3:
	case 4:
	case 5:
		System.out.println("这是春季");
		break;
	case 6:
	case 7:
	case 8:
		System.out.print1n("这是夏季");
		break;
	case 9:
	case 10:
	case 11:
		system.out.println("这是秋季");
		break;
	case 1:
	case 2:
	case 12:
		System.out.println("这是冬季");
		break;
	default :
		system.out.println("你输入的月份不对(1-12)");
}
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

switch和if的比较

• 如果判断的具体数值不多，而且符合byte、 short、int、char、 enum、 String这6种类型。虽然两个语句都可以使用，建议使用swtich语句。
• 其他情况:对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广

for循环控制

基本介绍:听其名而知其意,就是让你的代码可以循环的执行.看一个实际需求
请大家看个案例
编写一个程序,可以打印10句“你好，韩顺平教育!".请大家想想怎么做?

• 基本语法

for(循环变量初始化;循环条件;循环变量迭代){
		循环操作(可以多条语句);
}
1
2
3

• 老韩说明
  1.for关键字，表示循环控制
  2 . for有四要素:⑴循环变量初始化(2)循环条件(3)循环操作(4)循环变量迭代
  3.循环操作，这里可以有多条语句，也就是我们要循环执行的代码
  4.如果循环操作(语句)只有一条语句,可以省略{ },建议不要省略

//使用for循环控制
for( int i = 1; i <= 10; i++) {
	System.out.println("你好，韩顺平教育” +i); 
}

1
2
3
4
5

注意事项和细节说明

1)循环条件是返回一个布尔值的表达式
2)for(;循环判断条件;)中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略。

//使用for循环控制
int i = 1;//循环变量初始化
for( ; i<= 10 ; ) {
	system.out.println("你好，韩顺平教育" + i);
	i++;
}
system.out.println( "i=" + i);//11 ok
//补充
for(;;) {//表示一个无限循环,死循环
	System.out.println( "ok~" );
}

1
2
3
4
5
6
7
8
9
10
11
12

3)循环初始值可以有多条初始化语句，但要求类型一样,并且中间用逗号隔开,循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开。
4)使用内存分析法，老师分析输出下面代码输出什么?

int count = 3;
for (int i = 0, j = 0; i < count; i++,j+= 2) {
	System.out.println("i=" + i + "j="+ j);
}
//i = 0, j= 0;
//i = 1, j= 2;
//i = 2, j= 4
1
2
3
4
5
6
7

for循环练习题(学员先做)

1．打印1~100之间所有是9的倍数的整数，统计个数及总和

//思路分析
//打印1~100之间所有是9的倍数的整数，统计个数及总和//化繁为简
//(1）完成输出1-100的值
//(2）在输出的过程中，进行过滤，只输出9的倍数i%9 ==O
//(3）统计个数定义一个变量int count = 0;当条件满足时count++;
//(4）总和,定义一个变量int sum = 0;当条件满足时累积sum += i;
int count = 0;//统计9的倍数个数变量
int sum = 0;//总和
int start = 1;
int end = 100;
int t = 9;//倍数
for(int i = start; i <=end;i++) {
	if( i % t ==0) {
		system.out.println( "i=" + i);
		count++;
		sum += i;//累积
	}
}
system.out.print1n( "count=" +count);
System.out.println( "sum=" + sum);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

2. 完成下面的表达式输出[老师评讲]
   

int n =5;
for( int i = 0; i <= n; i++) {
	System.out.print1n(i + "+" + (n-i) +"=" +n);
}

1
2
3
4
5

while循环控制

基本语法

循环变量初始化;
while(循环条件){
循环体(语句);
循环变量迭代;
}
说明

1. while循环也有四要素
   2)只是四要素放的位置和for不一样.

//输出10句你好,韩顺平教育
int i = 1;//循环变量初始化
while( i <= 10 ) {//循环条件
	system.out.print1n("你好，韩顺平教育"+ i);//执行语句
	i++;//循环变量迭代
}
system.out.print1n("退出while ，继续..");
1
2
3
4
5
6
7

注意事项和细节说明

1．循环条件是返回一个布尔值的表达式
2. while循环是先判断再执行语句

课堂练习题[学员先做]

1．打印1—100之间所有能被3整除的数[使用while,老师评讲]

int i = 1;
int endNum = 100;
while( i <= endNum) {
	if( i % 3 ==) {
		System.out.print1n( "i=" + i);
	}
	i++;//变量自增
}
1
2
3
4
5
6
7
8

2.打印40—200之间所有的偶数[使用while,课后练习]

int j =40;//变量初始化
while ( j <= 200) {
	//判断
	if(j % 2 ==) {
		System.out.println( "j=”+ j);
	}
	j++;//循环变量的迭代
}
1
2
3
4
5
6
7
8

do…while循环控制

基本语法

循环变量初始化;
do{
循环体(语句);
循环变量迭代;
}while(循环条件);
说明:
1.do while是关键字
2.也有循环四要素,只是位置不一样
4.先执行，再判断，也就是说，一定会执行一次
4.最后有一个分号;
5.while和do…while区别举例:要账

int i = 1;//循环变量初始化
do {
	//循环执行语句
	System.out.print1n("你好，韩顺平教育" + i);//循环变量迭代
	i++;
}while(i <= 10);
system.out.println("退出do..while 继续执行..");

1
2
3
4
5
6
7
8

注意事项和细节说明

1)循环条件是返回一个布尔值的表达式
2)do…while循环是先执行，再判断，因此它至少执行次

课堂练习题

1)打印1—100[学生做]
2)计算1—100的和[学生做]
3)统计1———200之间能被5整除但不能被3整除的个数

//(1）使用do-while输出1-200
//(2)过滤能被5整除但不能被3整除的数%
//(3）统计满足条件的个数
int count = 0;
int i = 1;
int count = 0;//统计满足条件的个数
do {
	if( i % 5 ==  && i % 3 !=0 ) {
	System.out.println( "i=" + i);
	count++;
	}
	i++;
}while(i <= 200);
System.out.println( " count=" + count);
1
2
3
4
5
6
7
8
9
10
11
12
13
14

4)如果李三不还钱，则老韩将一直使出五连鞭，直到李三说还钱为止
[System.out.println(“老韩问:还钱吗? y/n”)]do…while …

import java.utiL.Scanner;
public class DowhileExercise62 {
	//编写一个main方法
	public static void main(String[] args) {
	//如果李三不还钱，则老韩将一直使出五连鞭，直到李三说还钱为
	// [System.out.println("老韩问:还钱吗?y/n")] 
	//do. . .while ..
	//化繁为简
	//(1)不停的问还钱吗?
	//(2)使用char answer接收,定义一个Scanner对象
	//(3)在do-while 的while判断如果是y就不在循环
	//
	Scanner myScanner = new Scanner(System.in);
	char answer = ' ';
	do {
		System.out.print1n("老韩使出五连鞭~");
		System.out.print1n("老韩问∶还钱吗?y/n");
		answer = myScanner.next().charAt(0);
		System.out.println("他的回答是"+ answer);
	} while(answer != 'y');
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

多重循环控制(难点!重点!)

介绍

1.将一个循环放在另一个循环体内，就形成了嵌套循环。其中,for ,while ,do…while均可以作为外层循环和内层循环。【建议一般使用两层，最多不要超过3层,否则，代码的可读性很差】
2实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环[听不懂,走案例]。
3.设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。

for( int i= 1; i<= 7; i++) {
	for( int j = 1;j<=2; j++) {
		System.out.println("ok~~");//7*2=14
	}
}
1
2
3
4
5

多重循环执行步骤分析

请分析下面的多重循环执行步骤,并写出输出=>韩老师的内存分析法/双层for

for(int i = 0; i< 2; i++) {
	for( int j = 0; j < 3; j++) {
		System.out.println("i=" +i + "j="+j);
	}
}
1
2
3
4
5

应用实例

1．统计3个班成绩情况，每个班有5名同学，求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。
2.统计三个班及格人数，每个班有5名同学。

import java.util.scanner;
public class MulForExerciseo1 {
	//编写一个main方法
	public static void main(String[] args) {
	//思路分析://化繁为简
	//(1）先计算一个班,5个学生的成绩,使用for
	//1.1创建Scanner 对象然后，接收用户输入
	//1.2得到该班级的平均分,定义一个doubel sum把该班级5个学生的成绩累积
	//(2)统计3个班(每个班5个学生）平均分
	//(3）所有班级的平均分
	//3.1 定义一个变量,double totalScore累积所有学生的成绩
	//3.2 当多重循环结束后， totalScore / ( 3* 5)
	//(4）统计三个班及格人数
	//4.1定义变量int passNum = 0;当有一个学生成绩>=60,passNum++
	//(5)可以优化[效率，可读性，结构]
	//创建Scanner对象
		scanner myScanner = new Scanner(System.in);
		double totalScore = 0;//累积所有学生的成绩
		int passNum = 0;//累积及格人数
		for(int i = 1; i <= 3; i++){//i 表示班级
			double sum = 0;//一个班级的总分
			for( int j = 1; j <= 5; j++){//j表示学生
				System.out.println("请数第"+i+"个班的第"+j+"个学生的成绩");
				double score = myScanner.nextDouble();
				//当有一个学生成绩>=60，passNum++
				if(score >= 60) {
					passNum++;
				}
				sum += score;//累积
				System.out.println("成绩为" + score);
			}
			//因为sum是5个学生的总成绩
			System.out.println( "sum=" + sum + "平均分=" + (sum / 5));
			//把sum累积到 totalScore
			totalScore += sum;
		}
		System.out.println("三个班总分="+totalscore
			+"平均分=" + totalscore / 15); 
		System.out.println("及格人数=" + passNum);
	}
}
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

3.打印出九九乘法表[课后题]

public class hw02{
	public static void main(String[] args) {
		for (int i = 1; i <= 9; i++){
			for (int j = 1; j <=i; j++){
				System.out.print(j + "*" + i + "=" + i*j + "\t" );
			} 
			System.out.print("\n");
		}
	}
}
1
2
3
4
5
6
7
8
9
10

经典的打印金字塔

使用for循环完成下面的案例
请编写一个程序，可以接收一个整数,表示层数(totalLevel),打印出金字塔。(Stars.java)[化繁为简,先死后活]

1)完成思路,可以先从矩形开始打
2)代码实现
3)请同学使用while来实现一把

for( int i = 1; i <= 5; i++) {//i表示层数
//在输出*之前，还有输出对应空格=总层数-当前层
	for(int k = 1; k<= 5 - i; k++ ) {
		System.out.print(" ");
	}
	//控制打印每层的*个数
	for(int j = 1;j<=2 * i - 1;j++){
		//当前行的第一个位置是*,最后一个位置也是*
		if(j == 1 || j == 2 * i - 1 || i ==5 ){
			System.out.print( "*");
		}else {//其他情况输出空格
			System.out.print( " ");
		}
	}
	//每打印完一层的*后，就换行println本身会换行
	System.out.println("");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

跳转控制语句-break

看下面一个需求
随机生成1-100的一个数，直到生成了97这个数,看看你一共用了几次?
提示使用(int)(Math.random()*100)+1

思路分析

循环，但是循环的次数不知道.-> break ,当某个条件满足时，终止循环通过该需求可以说明其它流程控制数据的必要性，比如break

基本介绍

break语句用于终止某个语句块的执行，一般使用在switch或者循环[for , while , do-while]中基本语法:
{ ……
break;
……}

public static void main( String[] args) {
//测试代码
	for( int i = 0; i < 10; i++) {
		if( i == 3){
			break;
		}
		System.out.println( "i=" + i);
	}
	system.out. println("退出for循环，继续执行..");
}
1
2
3
4
5
6
7
8
9
10

注意事项和细节说明

1. break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块
   2.标签的基本使用

label1: { .....
label2:		{ .....
label3:			{   .....
					break label2;
					.....
				}
			}
		}
1
2
3
4
5
6
7
8

老韩解读
(1)break语句可以指定退出哪层
(2)label1是标签，名字由程序员指定。
(3)break后指定到哪个label 就退出到哪里
(4)在实际的开发中，老韩尽量不要使用标签.
(5)如果没有指定break,默认退出最近的循环体

public class BreakDetail {
	//编写一个main方法
	public static void main(String[ ] args) {
		abc1:
		for(int j = 0; j <4; j++) {//外层for
		abc2:
			for(int i =0; i < 10; i++) {//内层for
				if(i == 2){
					break;//等价break abc2
				}
				System.out.println( "i = " + i);
			}
		}
	}
}
//输出为：0;1;0;1;0;1;0;1
//如果改为break abc1;输出为0;1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

课堂练习题

1)1-100以内的数求和,求出当和第一次大于20的当前数【for + break】

//思路分析
//1．循环1-100，求和sum
//2．当sum > 20时，记录下当前数，然后break
int sum = 0;//累积和
for(int i = 1; i <= 100; i++) {
	sum += i;//累积
	if(sum > 20) {
		System.out.println("和>20时候当前数i=”+ i);
		break;
	}
}
1
2
3
4
5
6
7
8
9
10
11

2)实现登录验证，有3次机会，如果用户名为"丁真”,密码"666"提示登录成功,否则提示还有几次机会,请使用for+ break完成

import java.util.Scanner;
public class BreakExercise02 {
	//编写一个main方法
	public static void main(String[] args) {
		//思路分析
		// 1．创建Scanner对象接收用户输入
		//2．定义String name ; String passwd;保存用户名和密码
		//3．最多循环3次[登录3次]，如果满足条件就提前退出
		//4．定义—般变量int chance 记录还有几次登录机会
		Scanner myScanner = new Scanner(System.in);
		String name = "";
		String passwd = "";
		int chance = 3;//登录一次,就减少一次
		for( int i = 1; i<= 3; i++) {
			System.out.println("请输入名字");
			name = myScanner.next();
			System.out.println("请输入密码");
			passwd = myScanner.next();
			//比较输入的名字和密码是否正确
			//补充说明字符串的内容比较使用的方法equals
			//字符串相等判断
			//string name =“林黛玉";
			//System.out.println(name.equals("林黛玉"));
			//T
			//System.out.println("林黛玉".equals(name));
			//T[推荐，可以避免空指针]
			if("丁真".equals(name)&& "666".equals(passwd)) {
				System.out.print1n("恭喜你，登录成功~");
				break;
			}
			//登录的机会就减少一次
			chance--;
			System.out.println("你还有"+ chance +"次登录机会");
		}
	}
}
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

跳转控制语句-continue

基本介绍

1. continue语句用于结束本次循环，继续执行下一次循环。
2. continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环，这个和前面的标签的使用的规则一样.

基本语法

{......
	continue;
	......
}
1
2
3
4

快速入门案例

int i = 1;
while ( i <= 4) {
	i++;
	if (i ==2) {
	continue;
	}
	System.out.println( "i=" + i);
}
//输出为3;4;5
1
2
3
4
5
6
7
8
9

细节案例分析和说明:

label1:
for(int j = 0; j< 4; j++){
	label2:
	for(int i = 0; i< 10; i++){
		if(i== 2){
			//看看分别输出什么值，并分析
			//continue ;输出4次[O,1,3,4,5,6,7,8,9]
			//continue label2;输出4次[O,1,3,4,5,6,7,8,9]
			//continue label1;输出2次[O,1]
		}
		System.out.println("i = " + i);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

跳转控制语句-return

介绍

return使用在方法，表示跳出所在的方法，在讲解方法的时候，会详细的介绍，这里我们简单的提一下。注意:如果return写在main方法，退出程序

for(int i=1;i<=5;i++){
	if(i==3) {
		System.out.println("韩顺平教育"+i);
		return;
		//return写在main方法
		//["Hello World!";"Hello World!";"韩顺平教育3"]
		//continue;["Hello World!";"Hello World!";"韩顺平教育3";"Hello World!";"Hello World!";"go on.."]
		//break;["Hello World!";"Hello World!";"韩顺平教育3";"go on.."]
	}
	System.out.println("Hello World!");
}
System.out.println("go on..");

1
2
3
4
5
6
7
8
9
10
11
12
13

本章作业

1.编程实现如下功能
某人有100,000元,每经过一次路口，需要交费,规则如下:
1)当现金>50000时,每次交5%
2)当现金<=50000时,每次交1000
编程计算该人可以经过多少次路口，要求:使用while break方式完成

double money = 100000;//还有多少钱
int count = 0;//累积过的路口
while(true) {
	if(money > 50000) {//过路口
		// money = money - money * 0.05;
		money*= 0.95;//过了这个路口后，还有这么多钱
		count++;
	}else if(money >=1000){
		money -=1000;
		count++;
	}else {//钱不够
		break;
	}
}
System.out.print1n("100000可以过" + count +"路口..");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2.实现判断一个整数，属于哪个范围:大于0;小于0;等于0
思路:定义int n = 22;使用if – else if – else即可
3.判断一个年份是否为闰年
4.判断一个整数是否是水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。例如:153 =111 +333+555
思路分析
1.比如int n = 153;
2．先得到n的百位，十位，各位的数字，使用if 判断他们的立方和是否相等
3. n的百位 = n / 100
4. n的十位 = n % 100/ 10
5. n的个位 = n % 10
6. 判断即可

int n = 153;
int n1 = / 100;
int n2 = n % 100/ 10;
int n3 = n % 10;
if(n1 * n1 * n1 + n2 * n2* n2 + n3 * n3 * n3 == n) {
	System.out.println(n +"是水仙花数");
}else {
	system.out.println(n +"不是水仙花数");
}
1
2
3
4
5
6
7
8
9

5.看看下面代码输出什么?

class Demo {
	public static void main(String[] args){
		int m=0,n=3;
		if(m>0){
			if(n>2)
				System.out.println("OK1");
			else
				System.out.println("OK2");
		}
	}
}
//什么都不输出
1
2
3
4
5
6
7
8
9
10
11
12

6.输出1-100之间的不能被5整除的数，每5个一行
思路分析

1. 先输出1-100的所有数
   2．然后过滤输出不能被5整除的数i % 5 !=0
   3．每5个一行，我们使用int count 统计输出的个数当count%5=0就说明
   输出了5个，这时，我们输出一个换行即可控制

int count = 0;//统计输出的个数
for(int i = 1; i <= 100; i++) {
	if(i% 5 !=O){
		count++;
		system.out.print(i + " ");
		//判断,每满5个，就输出一个换行..
		if(count % 5 ==) {
			System.out.println();
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11

7.输出小写的a-z以及大写的Z-A

//思路分析
//1.'b' = 'a’ + 1 c = 'a' +2
//2．使用for搞定
for(char c1 = 'a'; 'c1 <= 'z'; c1++) {
	System.out.print(c1 +" ");
}
for( char c1 = 'Z'; c1 >= 'A'; c1--) {
	System.out.print(c1 +" ");
}
1
2
3
4
5
6
7
8
9

8.求出1-1/2+1/3-1/4…1/100的和

/*
思路分析
1.1-1/2+1/3-1/4.....1/100=(1/1)-(1/2)+(1/3)-(1/4)...1/100
2．从上面的分析我们可以看到
(1)一共有100数，分子为1,分母从1-100
(2）还发现当分母为奇数时，前面是+，当分母是偶数时，前面是-
3．我们可以使用for +半判断即可完成
4．把结果存放到double sum
5．这里有一个隐藏的陷阱，要把公式分子1写出1.0才能得到精确的小数
*/
double sum = 0;
for(int i = 1; i <= 100; i++) {
	//判断是奇数还是偶数，然后做不同的处理
	if( i % 2 !=0) {//分母为奇数
		sum += 1.0/i;
	}else {//分母为偶数
			sum -= 1.0/i;
	}
}
System.out.print1n( "sum=" + sum);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

9.求1+(1+2) +(1+2+3) +(1+2+3+4) +…+(1+2+3+…+100)的结果

int sum = 0;
for(int i = 1; i <= 100; i++) {
	for(int j = 1;j <= i; j++){//内层对1-i进行循环
		sum += j;
	}
}
system.out.print1n( "sum=" + sum);
1
2
3
4
5
6
7