java流程控制语句_利用for循环实现。计算1+3+5+7+……+2001的和,并输出。

流程控制语句

定义

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

分类

顺序结构
选择结构
循环结构

1.流程控制语句之顺序结构语句

定义

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

执行流程

从上往下，依次执行。

案例演示

输出几句话看效果即可

2.流程控制语句之选择语句

定义

也被称为分支结构。
选择结构有特定的语法规则，代码要执行具体的逻辑运算进行判断，
逻辑运算的结果有两个，所以产生选择，按照不同的选择执行不同的代码。

分类

if语句
switch语句

2.1if语句

2.1.1格式1

if(比较表达式或者是boolean类型的值) {
		语句体;
	}
1
2
3

执行流程：

先计算比较表达式的值，看其返回值是true还是false。
如果是true，就执行语句体；
如果是false，就不执行语句体；

案例演示1

判断两个数据是否相等

案例演示2

a:比较表达式无论简单还是复杂，结果必须是boolean类型
b:if语句控制的语句体如果是一条语句，大括号可以省略；如果是多条语句，就不能省略。建议永远不要省略。
c:一般来说：有左大括号就没有分号，有分号就没有左大括号

2.1.2格式2

	if(比较表达式) {
		语句体1;
	}else {
		语句体2;
	}

	注意事项：else后面是没有比较表达式的，只有if后面有。

1
2
3
4
5
6
7
8
9

执行流程

首先计算比较表达式的值，看其返回值是true还是false。
如果是true，就执行语句体1；
如果是false，就执行语句体2；

案例演示3

a:获取两个数据中较大的值

class  IFDemo2{
	public static void main(String[] args) {
		int b=20;
		int a=100;

		//用if else 来求两个数的最值
		int max=0; //定义一个变量，来接收最大值；
		if(a>b){
			 //System.out.println("最大值是:"+a);
			 max=a;
		}else{
		
		    //System.out.println("最大值是:"+b);
			max=b;
		}

		//获取和打印看一下是两个意思。
		
		//下面的代码中，要用到最大值

        System.out.println("最大值是:"+max);

	}
}

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

b:判断一个数据是奇数还是偶数,并输出是奇数还是偶数

格式2和三元的相互转换问题
案例演示4

获取两个数中较大的值。
判断一个数据是奇数还是偶数,并输出是奇数还是偶数
同时使用if语句和三元运算符进行操作。

三元运算符实现的，都可以采用if语句实现。反之不成立。

什么时候if语句实现不能用三元改进呢?
  当if语句控制的操作是一个输出语句的时候就不能。
为什么呢?
  因为三元运算符是一个运算符，运算符操作完毕就应该有一个结果，而不是一个输出。

2.1.3格式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

执行流程

首先计算比较表达式1看其返回值是true还是false，
如果是true，就执行语句体1，if语句结束。
如果是false，接着计算比较表达式2看其返回值是true还是false，

如果是true，就执行语句体2，if语句结束。
如果是false，接着计算比较表达式3看其返回值是true还是false，
…

如果都是false，就执行语句体n+1。

注意事项： 当只要有一个条件满足时，if语句结束。else是可以省略，但是不建议省略。
案例演示5

	//需求：键盘录入一个成绩，判断并输出成绩的等级。
	/*
		90-100 优秀
		80-89  良
		70-79  中
		60-69  及格
		0-59   差
	*/
1
2
3
4
5
6
7
8

import java.util.Scanner;
class  IFDemo6{
	public static void main(String[] args) {
		//多重条件选择 if(条件){代码} else if(条件2){代码} else if(){}.....else{}
		//根据你的成绩来输出优良中差
		Scanner sc=new Scanner(System.in);
		System.out.println("请输入你的成绩0-100");

        int score=sc.nextInt();

		if(score>=0&&score<60){
			System.out.println("你的成绩不及格");
		}else if(score>=60&&score<70){
			System.out.println("你的成绩很差");
		
		}else if(score>=70&&score<85){
		
			System.out.println("你的成绩中等");
		}else if(score>=85&&score<90){
		
			System.out.println("你的成绩良好");
		}else if(score>=90&&score<=99){
		
			System.out.println("你的成绩优秀");
		}else if(score==100){
		
			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
27
28
29
30
31
32
33
34
35
36

练习题

需求：键盘录入x的值，计算出y的并输出。

		x>=3	   y = 2x + 1;
		-1<=x<3	    y = 2x;
		x<-1		y = 2x – 1;
1
2
3

class  IFDemo7{
	public static void main(String[] args) {
	/*
	
	  	x>=3	   y = 2x + 1;
		-1<=x<3	    y = 2x;
		x<-1		y = 2x – 1;
	
	*/
        
	int x=10;
	int y=0;

	 if(x>=3){
		y = 2*x + 1;
	 }else if(x>=-1&&x<3){
		y = 2*x;
	 
	 }else if(x<-1){
	     y = 2*x-1;
	 }
		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

if语句的嵌套使用
案例演示6

需求：获取三个数据中的最大值
  if语句的嵌套使用。
可以三元实现，也可以if嵌套实现。

class  IFDemo3{
	public static void main(String[] args) {
		int a=20;
		int b=200;
		int c=20;
		 
		int max=0;
        if(a>b){
			//a 大
			if(a>c){
			
		     max=a;
			}else{
			  max=c;
			
			}
		
		}else{
		   // b 大
			if(b>c){
				max=b;
			}else{
			
				max=c;
			}
		}
		
		System.out.println("最大值是："+max);
	}
}

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

class  IFDemo4{
	public static void main(String[] args) {
        int a=20;
		int b=400;
		int c=50;

		int max=0;

		if(a>b&&a>c){
			max=a;
		}

		if(b>a&&b>c){
			max=b;
		}

		if(c>a&&c>b){
			max=c;
		}

		System.out.println("最大值是："+max);
	}
}

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

class  IFDemo5{
	public static void main(String[] args) {
		int a=20;
		int b=50;
		int c=100;

		int max=0;

		int m=0;

		if(a>b){
		
		   m=a;
	
		}else{
		
		    m=b; 
		}

		if(m>c){
		
		   max=m;
		}else{
		  max=c;
		
		}


		System.out.println("最大值是："+max);
	}
}

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

class  IFDemo8{
	public static void main(String[] args) {
		//定义变量时，最好给一个初始化值。
		int num=0;

		/*
		if(5>3){
			num=10;
		}else{
		    num=15;
		}
		*/
         
		 if(5==3){
		    num=10;
		 }else if(2>9){
			num=50;
		 }else if(6>8){
			num=100;
		 }else{
		    num=200;
		 }

		System.out.println("num:"+num);
	}
}

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

2.2switch语句

格式

switch(表达式){
		case 值1:
			语句体1;
			break;
		case 值2:
			语句体2;
			break;
		case 值3:
			语句体3;
			break;
		....
		default：	
			语句体n+1;
			break;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

格式解释

(1):switch表示这是switch语句
  表达式的取值：byte,short,int,char
  JDK5以后可以是枚举
  JDK7以后可以是String
(2):case后面跟的是要和表达式进行比较的值
(3):语句体部分可以是一条或多条语句
(4):break表示中断，结束的意思，可以结束switch语句
(5):default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似

执行流程

先计算表达式的值
然后和case后面的匹配，如果匹配成功就执行对应的语句，遇到break就会结束,否则执行default控制的语句

练习题

byte可以作为switch的表达式吗?
long可以作为switch的表达式吗?
String可以作为switch的表达式吗?JDK1.7

class SwitchDemo2 {
	public static void main(String[] args) {
		//switch语句所要注意的事项
		//1.switch语句所支持的数据类型，byte short int char JDK1.7支持字符串 String 还有枚举类型
		//2.case 后面只能是常量值，不能跟变量
		//3. 多个case 后面的值不能有相同的 
		//4. defualt 项可以省略不写,放的位置，可以放前面，放后面。
		 //5. break 中断，结束，他的作用，就是用来结束switch语句，可以省略不写，但是如果不写，会发生一种现象
		 // 会发生case穿透的现象。你可以利用这种想象。

		int num=200;
	
        switch(num){

			case 200:
              System.out.println("Hello World! 200");
			 //break;

			case 20:

				System.out.println("Hello World! 20");

			//1break;

			case 30:
				System.out.println("Hello World! 30");
			break;

			default:
				System.out.println("当所有case项，都没有匹配上时，就执行默认项");
				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

基本使用
定义固定值

A:整数(给定一个值输出对应的星期一，星期二，星期三…星期日)
B:字符(单选题)
  System.out.println(“我们开设了那些专业？”);
  System.out.println(“A 挖掘机专业”);
  System.out.println(“B 美容美发专业”);
  System.out.println(“C JAVA专业”);
  System.out.println(“D 机械及自动化”);
C:字符串(根据给定字符串输出对应值)

案例演示

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

class  SwitchDemo{
	public static void main(String[] args) {

		/*
		switch(值){
			case 常量值:
              执行的代码

			 break;

			 case 常量值:
              执行的代码

			 break;

			 default:

               break;

		}
		*/

		 int num=1000;
         
		  switch(num){

			  case 10:

                System.out.println("Hello World!  10");
		      break;

			   case 20:

                System.out.println("Hello World! 20");
		      break;


			   case 30:

                System.out.println("Hello World! 30");
		      break;

			  default:

                System.out.println("Hello World! 上面的case项，都没有匹配上，就执行默认项");

				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

练习

A:看程序写结果：
	int x = 2;
	int y = 3;
	switch(x){
		default:
			y++;
			break;
		case 3:
			y++;
		case 4:
			y++;
	}
	System.out.println("y="+y); 
	
B:看程序写结果：
	int x = 2;
	int y = 3;
	switch(x){
		default:
			y++;
			
		case 3:
			y++;
		case 4:
			y++;
	}
	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

运行结果：

A:
y=4

B:
y=6
1
2
3
4
5

if语句和switch语句的区别

案例演示

分别用switch语句和if语句实现下列需求：
  键盘录入月份，输出对应的季节

import java.util.Scanner;
class  SwitchDemo4{
	public static void main(String[] args) {
		//键盘录入月份，根据用户录入的月份输出不同的季节，用 if  和 switch 来做一下
		// 3 4 5 春季
		 // 6 7 8 夏季
		  // 9 10 11 秋季
		   // 12 1 2 冬季
           Scanner sc=new Scanner(System.in);
		    System.out.println("请输入月份 1--12");
			int month=sc.nextInt();

			

			/*
			if(month==3||month==4||month==5){
			 System.out.println("春季");
			
			}else if(month>=6&&month<=8){
				 System.out.println("夏季");
			
			}else if(month>=9&&month<=11){
			
			  System.out.println("秋季");
			}else if(month==12||month==1||month==2){
			  
                System.out.println("冬季");

			}else{
			   System.out.println("你乱输入");

			
			}

			*/
			//byte shrot int char String 枚举
			//case 后面只能是常量值
			switch(month){
				 case 12:
				 case 1:
				 case 2:
                    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("你乱输入");
					 break;
			
			}

	}
}


/*

三元表达式和if else

能用三元表达式写出来的，用 if else 一定能写出来
用 if else 能写出来的，三元表达式不一定能写出来

if和switch 

if的条件要个布尔类型的
switch 要的是值 

if 既可以对几个常量值进行选择判断，也可对范围进行选择。 

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

在做判断的时候，我们有两种选择，if语句和switch语句，那么，我们到底该如何选择使用那种语句呢?
if语句使用场景：
  针对结果是boolean类型的判断
  针对一个范围的判断
  针对几个常量值的判断
switch语句使用场景：
  针对几个常量值的判断

3.流程控制语句之循环语句

什么是循环结构

  循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环

分类

for循环
while循环

3.1for循环

格式：

for(初始化表达式语句;判断条件语句;控制条件语句) {
		循环体语句;
	}
1
2
3

执行流程：

a:执行初始化表达式语句
b:执行判断条件语句,看其返回值是true还是false
   如果是true，就继续执行
   如果是false，就结束循环
c:执行循环体语句;
d:执行控制条件语句
e:回到b继续。

注意事项:

初始化表达式语句只执行一次

案例演示1.获取数据

需求：请在控制台输出数据1-10
需求：请在控制台输出数据10-1

class ForDemo2 {
	public static void main(String[] args) {
		//A:案例演示
	    //需求：请在控制台输出数据1-10
		for(int n=1;n<=10;n++){
		  System.out.println(n);
		
		}

        System.out.println("-------------------------------");

		 for(int n=0;n<10;n++){
		  System.out.println(10-n);
		
		}

        System.out.println("-------------------------------");
			
			//如果循环体的语句只有一条，那么大括号可以省略不写，但是建议还是写上。
		 for(int n=10;n>=1;n--){
		  System.out.println(n);
		 }
        System.out.println("-------------------------------");
          for(int n=10;n>=1;n--){
		  System.out.println("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

在控制台输出10次"helloworld";

class ForDemo {
	public static void main(String[] args) {
		//输出10句helloWorld  CV程序员 码农 搬砖的  算法工程师 程序员
		
		
		//对于重复性代码，我们应该考虑使用循环来做。
		//1. int i=0; 循环的初始值
		//2. i<10 循环的条件，当条件为true时循环继续，为false时循环结束
		//3.{ System.out.println("Hello World!");} 循环体，需要重复执行的代码
		 //4. i++ 控制循环的语句

		//循环的执行流程
		//1. int i=0; 只在初始的时候，执行一次
		//2. i<10 为true 执行循环体
         //3. i++ 
		  // 回到2 继续 知道 i<10 为假时循环结束

    
              //1     2  4
		for(int i=0;i<10;i++){
			//3
		  System.out.println("Hello World!");
		
		}


	}
}

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:判断条件语句无论简单还是复杂结果是boolean类型。
  b:循环体语句如果是一条语句，大括号可以省略；如果是多条语句，大括号不能省略。建议永远不要省略。
  c:一般来说：有左大括号就没有分号，有分号就没有左大括号

案例演示2.求和思想

需求：求出1-10之间数据之和
需求：求出1-100之间偶数和
需求：求出1-100之间奇数和

class  ForDemo3{
	public static void main(String[] args) {
		//请1--10的数据之和
		//int sum=1+2+3+4+5+6+7+8+9+10;
		int sum=0;//定义一个变量，用来记录每次相加的结果
		for(int i=1;i<=10;i++){
			//sum=sum+i;
			sum+=i;
		}

		System.out.println("sum:"+sum);


		//需求：求出1-100之间偶数和
	    //需求：求出1-100之间奇数和

		int ji=0;//定义一个变量，用来记录每次相加的结果
		int ou=0;
		int s=0;
		for(int i=1;i<=100;i++){
			//判断偶数
			if(i%2==0){
				ou+=i;
			}else{
				ji+=i;
			}
			s+=i;
		}

		System.out.println("总和:"+s);
		System.out.println("奇数和:"+ji);

		System.out.println("偶数和:"+ou);


	}
}

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

案例演示3.水仙花

  需求：在控制台输出所有的”水仙花数”
  水仙花数是指一个三位数，其各位数字的立方和等于该数本身。统计”水仙花数”共有多少个
  举例：153就是一个水仙花数。
  153 = 111 + 555 + 333 = 1 + 125 + 27 = 153)

class  FlowerNumber{
	public static void main(String[] args) {
		/*
	分析：
	   153 难点在于，怎么把每个位上的数字获取出来
        
        153/1%10 取个位
        153/10%10 取十位
		153/100%10 取百位     
	*/		
		 //定义统计变量
		 int count=0;
		 for(int i=100;i<=999;i++){
			int ge=i/1%10;
			int shi=i/10%10;
			int bai=i/100%10;
			int num=ge*ge*ge+shi*shi*shi+bai*bai*bai;
            if(i==num){
			  System.out.println("水仙花数是："+i);
			  count++;

			}
	     }

		  System.out.println("水仙花数是："+count+"个");
	     
	}
}

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

3.2while语句

3.2.1while语句

基本格式：

while(判断条件语句) {
			循环体语句;
		}
1
2
3

完整格式：

初始化条件语句;
	    while(判断条件语句) {
			 循环体语句;
			 控制条件语句;
	   }
1
2
3
4
5

执行流程：

a:执行初始化条件语句;
b:执行判断条件语句,看其返回值是true还是false
  如果是true，就继续执行
  如果是false，就结束循环
c:执行循环体语句;
d:执行控制条件语句
e:回到b继续。

案例演示

需求：在控制台输出10次"helloworld"
需求：请在控制台输出数据1-10

class  WhileDemo{
	public static void main(String[] args) {

		/*
		while(条件){
		
			循环体
		}
		*/
		
		int i=1;
		while(i<=10){
			System.out.println("Hello World!");
			i++; //控制循环的语句，不要忘了
		}

        System.out.println("i="+i);

        System.out.println("------------------------------");
		int j;
		for(j=1;j<=10;j++){
		   System.out.println(j);
		    System.out.println("Hello World!");
		}

		System.out.println("j="+j);


		int h=1;
		while(h<=10){
			System.out.println(h);
			h++; //控制循环的语句，不要忘了
		}

	}
}

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

求和思想: 求1-100之和

统计思想: 统计”水仙花数”共有多少个

3.2.2do…while语句

格式

do {
		循环体语句;
	}while(判断条件语句);
	
1
2
3
4

完整格式：

初始化条件语句;
		do {
			循环体语句;
			控制条件语句;
		}while(判断条件语句);
1
2
3
4
5

执行流程：

a:执行初始化条件语句;
b:执行循环体语句;
c:执行控制条件语句;
d:执行判断条件语句,看其返回值是true还是false
  如果是true，就继续执行
  如果是false，就结束循环
e:回到b继续。

案例演示

需求：在控制台输出10次"helloworld"
需求：请在控制台输出数据1-10

class  DoWhileDemo{
	public static void main(String[] args) {

		//do while 先执行do大括号里面的代码一次，再去判断循环条件是否成立，如果成立，就继续循环，如果不成立就结束循环

		int i=1;
		do{
		    
		  System.out.println(i);

		 i++;

		}while(i<=10);

		//for while
		//一般，我知道了循环的次数，我会选for
		//我不知道循环多少次，才能满足我的要求，我就选while循环，但是得知道循环结束的条件
	}
}

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

三种循环语句的区别

  (1):do…while循环至少执行一次循环体。
而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。
  (2):A： 如果你想在循环结束后，继续使用控制条件的那个变量，用while循环，否则用for循环。不知道用for循环。
  因为变量及早的从内存中消失，可以提高内存的使用效率。

   B:建议优先考虑for循环，然后是while循环 ，最后是do…while循环
注意事项:死循环

A:一定要注意控制条件语句控制的那个变量的问题，不要弄丢了，否则就容易死循环。

B:两种最简单的死循环格式

	while(true){...}
	for(;;){...}
1
2

		//死循环的写法
		
		for(;;){
			System.out.println("死循环");


		}



		while(true){
		  System.out.println("死循环");
		  if(条件){
			结束调用死循环
		  }
		}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

循环嵌套输出
案例演示1.输出星星

需求：请输出一个4行5列的星星()图案。
  如图：
  *****
  *****
  *****
  *****
  注意：
  System.out.println("");和System.out.print("*");的区别

		//外层循环：控制行数
		//内层循环：控制列数
		for(int i=1;i<=4;i++){
		  for(int j=1;j<=5;j++){
		     System.out.print("*"); //打印不换行
		  }
		  System.out.println(); //仅仅只是换行
	    }

1
2
3
4
5
6
7
8
9

结论：

外循环控制行数，内循环控制列数

案例演示2.输出正三角形

需求：请输出下列的形状
*
**
***
****
*****

class  ForDemo8{
	public static void main(String[] args) {
       for(int i=1;i<=5;i++){
		  for(int j=1;j<=i;j++){
		     System.out.print("*"); //打印不换行
		  }
		  System.out.println(); //仅仅只是换行
	    }
		//循环的嵌套层数不宜过多，过多阅读性太差。
	}
}

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

案例演示3.输出九九乘法表

需求：在控制台输出九九乘法表。

代码优化
  注意：
  ‘\x’   x表示任意，这种做法叫转义字符。
  ‘\t’  tab键的位置
  ‘\n’  换行

class  MultiplicationTable{
	public static void main(String[] args){
		/*
		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	
		*/

		for(int i=1;i<=9;i++){
			for(int j=1;j<=i;j++){
				System.out.print(j+"*"+i+"="+(j*i)+"\t");  //\t 转义字符t 表示空一个table位
			}   
			System.out.print("\n");   // \n 转义字符 换行
		}
	}
}

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

4.流程控制之跳转语句

什么是控制跳转语句

  Java中的goto是保留字，目前不能使用。虽然没有goto语句可以增强程序的安全性，但是也带来很多不便，
  比如说，我想在某个循环执行到某一步的时候就结束，现在就做不了这件事情。
  为了弥补这个缺陷，Java就提供了break，continue和return来实现控制语句的跳转和中断。

分类

break 中断
continue 继续
return 返回

4.1break语句

使用场景

(1):在选择结构switch语句中
(2):在循环语句中
 注意：离开使用场景的存在是没有意义的

class ForDemo2 {
	public static void main(String[] args) {

		for(int i=1;i<=10;i++){
			if(i==5){
			  break; //中断循环，让循环结束，用在循环语句中，离开循环场景单独使用没有意义，break也在switch语句中用
			}
		   System.out.println(i);
		}
		
		int j=1;
        while(true){
			 System.out.println(j);
			 j++;
			 if(j>10){
			   break;
			 }
		}

		 System.out.println("==================================");
		/*如果有多层循环嵌套，我们可以给循环起个别名，那么你可以根据循环的别名，使用break来结束那个循环。*/
		 wc:for(int i=1;i<=9;i++){
			nc:for(int h=1;h<=9;h++){
			  System.out.print("*");
			  if(h==5){
			     break wc;
			  }
			}
			System.out.print("\n");
			/*
			if(i==5){
			     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

作用

a:退出单层循环
b:退出多层循环(几乎不使用)
  要想实现这个效果，就必须知道一个东西:带标签的语句；
  格式：标签名：语句

4.2continue语句

使用场景

(1):在循环语句中
(2):离开使用场景的存在是没有意义的

class  ForDemo{
	public static void main(String[] args) {

		for(int i=1;i<=10;i++){

          if(i==5){
			   //continue 用在循环语句当中，离开循环单独使用没有意义
			continue; //跳过或者说略过一次循环，继续下一次循环
		  }

		  System.out.println(i);


		}

        System.out.println("----------------------------------------");

		for(int i=1;i<=10;i++){

          if(i%2==1){
			   //continue 用在循环语句当中，离开循环单独使用没有意义
			continue; //跳过或者说略过一次循环，继续下一次循环
		  }

		  System.out.println(i);


		}
		
	}
}

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

作用

a:跳出一次循环，执行下一步操作

练习题

	for(int x=1; x<=10; x++) {
		if(x%3==0) {
			//在此处填写代码
		}
		System.out.println(“Java基础班”);
	}
	
	我想在控制台输出2次:“Java基础班“
	我想在控制台输出7次:“Java基础班“
	我想在控制台输出13次:“Java基础班“	
1
2
3
4
5
6
7
8
9
10

代码：

class  ForDemo3{
	public static void main(String[] args) {

	for(int x=1; x<=10; x++) {
		if(x%3==0) {
			//在此处填写代码
			//break;
			//continue; // 3 6 9
			System.out.println("Java基础班");
		}

	    System.out.println("Java基础班");
	}

		//1.我想在控制台输出2次:“Java基础班“
		//2.我想在控制台输出7次:“Java基础班“
		//3.我想在控制台输出13次:“Java基础班“

	}
}

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

4.3return语句

作用

return 就是退出一个方法。
跳转到上层调用的方法。这个在方法的使用那里会在详细的讲解。

案例演示

return: 结束当前方法
break: 结束单层循环
continue: 结束当前循环，执行下一次循环