流行控制与数组

一 、顺序结构

1. 不论哪一种语言,都会提供两种基本流程控制结构:分支结构和循环结构。其中分支结构用于实现根据条件来选择性得执行某段代码,循环结构则用于实现根据循环条件重复执行代码,Java设计者同样提供了这两种流程控制结构语法,设计者提过了if和switch两张分支语句,并提供了while,do while,和for三种循环语句.Java 1.5提供了 foreach循环更能简单方便的遍历.还提供了break和continue来控制程序循环结构.
2. 数组也是大部分编程语言都支持的数据结构,Java数组类型是一种引用类型的变量,设计者通过操作引用变量来操作数组,例如数组初始化,访问数组元素,获取数组长度.

1.1 介绍

1. 任何编程语言最常见得程序结构就是顺序结构.顺序结构就是程序从上到下逐行执行,中间没有任何判断和跳转.
2. 如果main方法得多行代码之间没有任何流程控制,则程序总是从上向下依次执行,排在前面的代码先执行,排在后面代码后执行.着意味着如果没有流行控制则代码从上到下

1.2 代码演示

public static void main(String[] args) {
	System.out.println("1")
	System.out.println("2");
}

// 控制台输出
1
2

二、if 分支语句

2.1 介绍

1. if 语句 使用布尔表达式或者布尔值作为分支条件来进行分支控制,通常有三种表示形式

2.2 语法格式

// 第一种简单if语句
if (expression) {
    //消息体
}
// 第二种形式
if (expression) {
    //消息体
} else {
    //消息体
}
// 第三种形式
if (expression) {
    //消息体
}else if (expression) {
    //消息体
}else if(expression){
    //消息体
}else {
   //消息体 
}
//可以有多个else if

2.3代码解释

1. 第一种最简单,如果(expression)里为true则执行消息体内容
2. 第二种如果()里为true则执行消息体,否则执行else里内容
3. 第三种如果()里为true则执行第一个消息体内容,接下来回去判断第二个else if如果第二个为true则执行第二个消息体,后面同理,如果最后都没有则执行else内容
4. 通常来说使用if else 最先处理 范围数据范围最小的

2.4代码演示

 if (4 > 2) {
     System.out.println("我是pain1")
 }else {
     System.out.println("我是pain2")
 }
// 打印输出我是pain1 因为表达式结果为true.


int pain = 2+3;
if (pain==1) {
    System.out.println("我是pain1")
}else if (pain==2) {
     System.out.println("我是pain2")
}else if(pain==3) {
    System.out.println("我是pain3")
}else if(pain==5) { //很明显2 + 3= 5
    System.out.println("我是pain5")
}else {
    System.out.println("不知道") // 执行这块代码
}
// 输出-> 我是pain5 

三、switch 分支语句

3.1 介绍

1. switch语句由一个控制表达式和多个case组成,和 if 语句不同的是,switch语句后面的控制表达式只能是byte,short,char,int四种整数类型,枚举类型和java.lang,string类型,不能是boolean类型

3.2 语法格式

switch (expression) {
    case condition1: {
        // 消息体
        break;
    }
   case condition2: {
        // 消息体
        break;
    }
   case condition3: {
        // 消息体
        break;
    }
   case condition4: {
        // 消息体
        break;
    }
   default: {
        
  }
}

3.2 代码解释

1. 这种分支结构执行先对expression求值,然后依次匹配condition1,condition2...,conditionN等值遇到匹配的值即执行对应得消息体,如果所有case 标签后的值都不予expression值匹配则执行default标签后面的代码

3.3 代码演示

// 省略main方法

char score = ‘C‘;
switch (score) {
    case ‘A‘: {
       System.out.println("优秀")
           break;
    }
    case ‘B‘: {
        System.out.println("良好")
            break;
    }
    case ‘C‘: {
        System.out.println("中")
            break;
    }
    case ‘D‘: {
        System.out.println("及格")
            break;
    }
}
// 最终输出-> 中

3.4 注意事项

1. break必须加,不然会造成代码穿透,什么是代码穿透就是.会接着往下执行,程序不会结束返回
2. switch语句表达式,如果是String类型,则必须是 java.lang.String类型 ,不能是StringBuffer或者StringBuffilder这两种类型

四、while 循环

1. 4-6章节将会讲解循环,什么是循环?就是重复的做某一事情.当然java设计者也提供了循环条件的支持,循环也是java基础的难点和重点,一些初入编程的都是在循环这里栽跟头,所以需要多加思考..循环学完也就基本有了编程思想..
2. 循环初学者不要把他想太难,其实本质上就是为我们重复完成任务.只不过Java通过某种变量控制,可以操作循环而已

4.1 while循环语法

while(expression) {
    // 消息体
}
// 如果expression得值为true则执行消息体否则不执行,如果一直为true则进行死循环

4.2代码演示

// 胜率main方法
int count = 0;
// 当count小于10进行循环
while (count < 10) {
    System.out.print(count);
    count++;
}
// 执行结果
0123456789

4.3 代码解释

4.2代码流程解释

1. 首先count初始化为0, 0确实小于10.此时打印0 ,然后count++了,那么此时count=1
2. 因为是循环,所以又开始执行了,此时1,1确实小于10打印1,此时count++,此时count=2
3. 下面依次执行...
4. 最后count=10,10不小于10条件为false.结束循环.
5. while循环虽好,但一定要控制表达式expression 如果逻辑错误就一直进入死循环!!

五、do while循环

5.1 do while循环语法

do {
    // 消息体
}while(expression);
// 首先执行消息体内容,在判断expression.如果expression值为true,继续执行消息体

5.2 do while和while区别:

 1. while是先判断expression,再执行消息体内容.
 2. do while 是不管你expression值是true还是false我先执行消息体内容最后判断expression

5.3 代码演示

// 胜率main方法

int count = 1;
do {
    System.out.print(count);
    count++;
}while(count < 10);
// 最终输出
123456789

5.4代码解释

1. 首先初始化count,把count值赋值为1;
2. 先执行打印1
3. cout++,此时cout=2
4. 又因为cout<10条件成立,又开始执行do里面的消息体
5. 最终当cout得值为10时,10<10 为false,循环结束.
6. 最终展示123456789

六、for循环

6.1 简介

1. for循环是更加简洁的循环语句,大部分情况下,for循环可以代替while循环、do while循环、for循环基本语法如下

6.2 语法格式

for([init_statement];[test_expression];[iteration_statement]) {
    //消息体
}

6.3语法定义

1. init_statement:初始化语句，每次都会先执行 (类似上面while里面的int count=0)
2. test_expression:表达式结果为true或者false(类似上面while里面count < 10)
3. 迭代值:即每次循环完初始化值要做的操作(类似上面while消息体里面的count++)

6.4代码演示

// 胜率main方法
for(int i =0;i <5;i++) {
    System.out.println("老鼠爱上猫");
}
// 打印结果->
老鼠爱上猫
老鼠爱上猫
老鼠爱上猫
老鼠爱上猫
老鼠爱上猫

6.5代码执行流程

1. 首先初始化int i = 0;
2. 此时会去判断0<5;因为结果为true
3. 去打印"老鼠爱上猫";
4. 然后i++ 此时i=2
5. 然后还再会去判断 2 <5 此时结果为true
6. 去打印"老鼠爱上猫";
7. 此时i++,此时i=3
8. 依次循环2-4操作...
9. 到最后i=5,结果为false
10. 不执行消息体

七、嵌套循环

7.1 介绍

1. 什么是嵌套循环?嵌套循环就是把一个循环,放在另外一个循环里.
2. 嵌套循环相较于循环更加绕,如果是第一次接触则会很陌生代码流程我会详细讲解执行顺序

7.2 代码演示

// 省略main方法
for(int i = 0; i < 2; i++) {
    for(int j = 0; j < 3;j++) {
        System.out.println("我是内层循环");
    }
    System.out.println("我是外层循环");
}
我是内层循环
我是内层循环
我是内层循环
我是外层循环
我是内层循环
我是内层循环
我是内层循环
我是外层循环

7.3 代码流程分析

1. 嵌套循环只需要记着,外层循环一次.内层循环一轮即可.秉着这个观念可以看7.2

2. 首先 初始化i,此时i=0,

3. 0 小于2 结果为true,下一步进入内层循环 (此时不打印我是外层循环)

4. 此时j =0 ;

5. 0<3,结果为true

6. 打印我是内层循环

7. j++此时j=1

8. 接着比较1 ??

9. 打印我是内层循环

10. j++此时i=2

11. 接着比较2 ??

12. 打印我是内层循环

13. j++此时3

14. 接着比较3<3,结果为false

15. 注意此时跳出内层循环,打印我是外层循环,

16. ---

17. 重复以上操作.因为外层循环两次,就打印了两回.

7.4 嵌套循环注意

1. 嵌套循环只需要谨记,外层循环一次,内涵循环一周.

八、控制循环结构

8.1 什么是控制循环结构

1. 控制循环结构,循环结构已经知道了就是循环,控制就代表控制循环语句的走向
2. 那是通过什么控制的呢?可以通过break,continue关键字来进行控制循环的走向
3. 有了这些就使循环,更加强大扩展性更加强大

8.2 代码演示break

1. break:退出当前循环.
2. 演示两种情况,第一种当普通循环使用break场景

// 省略main方法

for(int i = 0; i < 2; i++) {
    System.out.println("我是pain"); 
}
// 正常来说即打印
 System.out.println("我是pain"); 
 System.out.println("我是pain"); 
// 如果此时我打一个break
for(int i = 0; i < 2; i++) {
    System.out.println("我是pain"); 
    break;
}
//则打印
System.out.println("我是pain"); 

8.3 代码执行流程

1. 进入循环判断i<0
2. 输出我是pain
3. i++,此时i=1
4. 此时遇到break,退出当前循环

8.4 嵌套循环的控制使用方法break

1. 如果想退出嵌套循环得方法,即可以在break:XXX ,在需要退出嵌套循环的上面加这个xx:标签即可

8.5 代码演示

// 省略main方法
outer://这里的outer代替xx
for(int i = 0; i < 5; i++) {
    for (int j = 0; j < 3; j++) {
         System.out.println("i的值为:"+i + "j的值为" + j);
        if (j == 1){
            //跳出outer标签标示的循环
            break outer;
        }
    }
}
//打印输出->
i得值为0,j得值为0
i得值为0,j得值为1    

8.6 代码分析

1. 进入外层循环,i=0,0小于5结果true,
2. 之后进入内层循环,j=0;j<3,结果为true,打印->i得值为0,j得值为0
3. 此时j++,j=1
4. 判断1 ??,结果true,打印输出i得值为0,j得值为1
5. 又因为判断了,这里遇到了break,此时标签outer,在最外层循环
6. 最终退出最外层循环

8.7 细节分析

1. 通常紧跟break之后的标签,必须在break所在循环的外层循环之前定义才有意义,因为breka,默认就是退出当前循环

8.8 循环控制continue

1. continue是什么意思?他有何作用?
2. continue中文翻译过来就是继续的意思.
3. 大家只需要,在这里表达的含义就是:当代码里使用了continue,则代表跳出当前循环,开始下次循环,与break不同的是,break退出整个循环,而continue是退出当前循环.

8.9 代码演示

// 省略main方法
for(int i = 0; i < 2; i++) {
    if (i == 1) {
        continue;
    }
    System.out.println("我是pain");
}
// 最终打印
 System.out.println("我是pain");

8.9代码执行分析

1. 首先初始化i=0,判断0确实小于2,
2. 又因为此时i=0结果为false则不进
3. 打印我是pain
4. 此时i++,i=1
5. 之后1确实小于2结果true
6. 进入循环,之后判断1==1结果true,执行continue,
7. 此时i++,此时i=2
8. 又进入循环2<2,结果为false.
9. 退出循环程序结束
10. 最终打印即->我是pain

8.91 嵌套循环中使用continue

// 省略main方法
outher:
for(int i = 0; i < 2; i++) {
    for (int j = 0; j < 2; j++) {
         System.out.println("i的值为:"+i + "j的值为" + j);
        if(j == 1) {
            continue outher;
        }
    }
}
// 最终输出
i的值为0,j得值为0
i的值为0,j得值为1
i的值为1,j得值为0
i的值为1,j得值为1

8.92代码执行顺序分析

1. 初始化外层循环,i=0,i小于2结果为true,进入内层循环
2. 初始化内层循环,j=0,j小于2结果为true,执行方法体打印i得值为0,j得值为0
3. 之后j++,此时j得值为1
4. 初始化内层循环,j=1,j小于2结果为true,执行方法体打印i得值为0,j得值为1
5. 之后判断后,1=1,进入continue.所以就放弃此次循环,进入下次循环,跳到外层循环
6. 外层循环,i=1,i小于2结果为true,进入内层循环
7. 内层循环,j=0,j小于2结果为true,执行方法体打印i得值为1,j得值为0
8. 之后j++,此时j得值为1
9. 内层循环,j=1,j小于2结果为true,执行方法体打印i得值为1,j得值为1
10. 之后判断后,1=1,进入continue.所以就放弃此次循环,进入下次循环,跳到外层循环
11. 此时i=2,2小于2结果为false,程序终止..
12. 最终打印如下
13. i的值为0,j得值为0
    i的值为0,j得值为1
    i的值为1,j得值为0
    i的值为1,j得值为1

测试单

原文：https://www.cnblogs.com/jiaowoxiaofeng/p/14392134.html