第五章、流程控制

5.1.流程控制的简介

5.1.1. 程序的执行结构

在Java中，程序的执行结构分为三种

• 顺序结构：代码从上往下，逐行依次执行，是程序执行的默认结构。

• 分支结构：程序在某一个节点遇到了多种向下执行的可能性，根据条件，选择一个分支继续执行。

• 循环结构：某一段代码需要被重复执行多次。

5.1.2. 流程控制的介绍

流程控制，就是通过指定的语句，修改程序的执行结构。 按照修改的不同的执行结构，流程控制语句可以分为：

• 分支流程控制语句：

  • 将程序，由顺序结构，修改为分支结构

• 循环流程控制语句：

  • 将程序，由顺序结构，修改为循环结构

5.2. 分支流程控制 - if

5.2.1. if 流程图

略

5.2.2. if 基础语法

if(condition){//代码块1
}else{//代码块2
}

逻辑: condition是一个boolean类型的变量, 或者一个boolean结果的表达式. 如果condition的值为true, 则代码段1执行, 否则, 代码段2执行

public class JavaSyntax {public static void main(String[] args) {int score = 99;if (score>=60){System.out.println("成绩及格！");}else {System.out.println("成绩不及格！");}}
}

5.2.3. if 语法进阶

if(condition1){//代码块1
}else if(condition2){//代码块2
}else{//代码块3
}

逻辑: 先判断condition1, 如果condition1成立, 执行代码段1; 如果condition1不成立, 再判断condition2, 如果condition2成立, 执行代码段2, 否则执行代码段3

public class JavaSyntax {public static void main(String[] args) {// 1. 定义一个成绩int score = 59;// 2. 将成绩划分成不同的等级//    < 0 || > 100 : 错误成绩//    [0, 60): 不及格//    [60, 80): 良//    [80, 90): 中//    [90, 100]: 优if (score < 0 || score > 100) {System.out.println("错误成绩");}else if (score < 60) {System.out.println("不及格");}else if (score < 80) {System.out.println("良");}else if (score < 90) {System.out.println("中");}else {System.out.println("优");}}
}

5.3. 分支流程控制 - switch

5.3.1. switch流程图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JuidFe04-1594201665245)(C:\Users\Ba-Ba\Desktop\wps156.jpg)]

5.3.2. switch的基础语法

switch(变量){case值1：//分支语句1case值2：//分支语句2......default:
}

程序逻辑：

• 检测某一个变量的值， 从上往下依次与每一个case进行校验、匹配
• 如果变量的值和某一个case后面的值相同，则执行这个case后的语句
• 如果变量的值和每一个case都不相同，则执行default后的语句

5.3.3. break

public class Switch1 {public static void main(String[] args) {// 1. 定义一个变量, 记录第几个季节int season = 1;// 2. 根据season的值, 输出不同的季节switch (season) {case 1:System.out.println("春天");case 2:System.out.println("夏天");case 3:System.out.println("秋天");case 4:System.out.println("冬天");default:System.out.println("这是一个适合学习的季节");}}
}

上述代码中， switch结构捕获变量season的值。 变量的值和第一个case是匹配的， 应该输出的结果是 “春天”。 但实际上的输出结果却是从春天开始的每一个输出。

因为在switch结构中有“穿透性”。

穿透性:

指的是， 当switch的变量和某一个case值匹配上之后， 将会跳过后续的case或者default的匹配，直接向后穿透。

为了杜绝穿透， 可以使用关键字 break:

这一段程序， season的值， 和case1匹配。 因此会输出“春天”， 然后向下穿透， 输出“夏天”。此时， 遇到了关键字 break。 将会结束穿透， 直接结束switch结构。

因此， 此时的输出结果是: 春天 夏天

5.4. 循环流程控制 - for

5.4.1. for循环流程图

略

5.4.2. for循环基础语法

for(循环初始部分；循环条件；循环迭代部分){循环体
}

执行逻辑：

• 循环开始后， 先执行循环初始部分， 这一部分的代码只会执行一次。 在初始部分， 常常用于定义循环控制变量。

• 循环初始部分结束后， 判断循环条件。

• 如果循环条件成立， 执行循环体。

• 循环体执行结束后， 执行循环迭代部分。 这里常常用于对循环控制变量进行修改。

• 循环迭代部分执行结束， 再回到第二步， 判断循环条件。

• 如果循环条件成立， 继续执行循环体。 如果循环条件不成立， 循环结束。

5.4.3. 特殊语法

1. 循环体中的代码如果只有一句， 大括号可以省略。 但是从语法角度出发， 可以省略， 实际写程序的时候， 出于规范， 一般不省略。

   public class For1 {public static void main(String[] args) {// 基础案例: 输出数字 1~100// for (int number = 1; number <= 100; number++) {//     System.out.println(number);// }// 基础案例: 输出[1,100]范围内的奇数// for (int num = 1; num <= 100; num++) {//     if (num % 2 != 0) {//         System.out.println(num);//     }// }// for (int num = 1; num <= 100; num += 2) {//     System.out.println(num);// }// 基础案例: 计算 1+2+3+4+...+100 = ?// 思路:// 定义一个变量, 用来记录累加的结果// 再将所有的数字依次累加到这个和里面int sum = 0;for (int n = 1; n <= 100; n++) {sum += n;}System.out.println(sum);}
   }
   

2. for循环小括号中的每一部分都可以省略不写， 但是分号不能省略。

    for (int n = 1; n <= 100; n++) System.out.println(n);
   

5.5. 循环流程控制 - while

5.5.1. while循环基础语法

while(循环条件){//循环体
}

程序逻辑：

• 如果循环条件条件成立， 循环体循环执行。 直到循环条件不成立。

5.5.2. 示例代码

public class JavaSyntax {public static void main(String[] args) {int n = 1;while (n < 100) {System.out.println(n);}}
}

5.5.3. do-while循环

do-while循环基本与while循环是一致的， 只是在执行逻辑上稍微有点区别:

public class JavaSyntax {public static void main(String[] args) {int n = 1;do {System.out.println(n);} while (n < 100);}
}

执行逻辑:

• 先执行循环体， 再判断循环条件是否成立。

• 如果循环条件成立， 继续执行循环体。

• 如果循环条件不成立， 结束循环。

5.6. 两个关键字

5.6.1. break

break用在循环中， 表示无论循环条件是否成立， 立即结束循环。

public class JavaSyntax {public static void main(String[] args) {for (int i = 0; i < 10; i++) {if (i == 5) {break;}System.out.println(i);}}
}

上述代码中， 如果i的值为5， 结束循环。 所以， 程序输出结果是

0

1

2

3

4

5.6.2. continue

continue用在循环中， 表示立即停止本次循环， 开始下次循环。

public class JavaSyntax {public static void main(String[] args) {for (int i = 0; i < 10; i++) {if (i == 6) {continue;}System.out.println(i);}}
}

当i的值是5的时候， 停止当次的循环， 立即进入下次循环。 所以， 程序输出的结果是

0

1

2

3

4

6

7

8

9

5.7. 循环标签

循环的实际使用中， 有些情况下， 需要使用到嵌套循环。 在嵌套循环中， 如果内层循环写了break或者continue， 此时只能作用于内层的循环。

public class Loop {public static void main(String[] args) {for (int i = 0; i < 3; i++) {for(int j = 0;j<3;j++){if (j == 2){break;}System.out.println("i="+i+",j="+j);}}}
}

上述代码中， 当内层循环j的值为2的时候， 结束内层循环。 所以， 程序的输出结果是

i = 0, j = 0

i = 0, j = 1

i = 1, j = 0

i = 1, j = 1

i = 2, j = 0

i = 2, j = 1

如果在内层循环中， 需要使用break或者continue关键字作用于外层的循环， 需要配合循环标签使用。

循环标签是一个标识符， 常写成全大写。 在循环的前面直接写标签， 添加一个冒号即可。

public class Loop {public static void main(String[] args) {loop:for (int i = 0; i < 3; i++) {for(int j = 0;j<3;j++){if (j == 2){break loop;}System.out.println("i="+i+",j="+j);}}}
}

上述代码中， break OUTER; 使得break关键字作用于指定的循环。 此时， 程序的输出结果是

i = 0, j = 0

i = 0, j = 1

第六章、方法

6.1.方法的简介

6.1.1. 方法的概念

在程序中， 有些情况下， 有些代码是需要被多次执行的。 如果需要在每次使用到这些逻辑的时候， 都去写代码实现， 此时代码将会非常的冗余， 不利于维护。

此时， 我们可以将这些需要被多次执行的逻辑单独包装起来， 在需要的时候直接调用即可。

方法， 就是为了实现这个需求而存在的。

方法， 其实就是一个实现特定功能的代码段， 方法中的逻辑可以被重复使用。

6.1.2. 为什么要使用方法

可以使用方法， 将需要多次执行的逻辑封装起来， 哪里需要，哪里直接调用即可。

降低了代码的冗余， 提高了代码的复用性与维护性。

6.2. 方法的定义与调用

6.2.1. 方法的定义

[访问权限修饰符][其他修饰符]返回值类型 方法名字([参数列表]){方法体
}

• 访问权限修饰符： 定义了方法的访问权限。

• 其他的修饰符： 定义了方法的其他的修饰。

• 返回值类型： 定义了方法返回的值的类型。

• 方法名字： 遵循小驼峰命名法的标识符。

• 方法体： 需要封装起来的， 可以被重复执行的代码段。

6.2.2. 第一个方法

//这个方法中，封装了一个九九乘法表
//哪里需要乘法表，哪里调用即可
public static void diaplay(){for (int line = 1;line<=9;line++){for (int colume = 1;colume<=9;colume++){System.out.println(colume+"x"+line+"="+colume*line+"\t");}}
}

6.2.3. 方法的调用

方法写完后，其中的逻辑并不会立即执行。如果想让程序中的逻辑执行，需要调用方法。

调用方法， 直接使用方法的名字即可。

public class Test {public static void main(String[] args) {//方法的调用diaplay();}//这个方法中，封装了一个九九乘法表//哪里需要乘法表，哪里调用即可public static void diaplay(){for (int line = 1;line<=9;line++){for (int colume = 1;colume<=9;colume++){System.out.println(colume+"x"+line+"="+colume*line+"\t");}}}
}

6.3. 方法的参数

6.3.1. 参数的概念

多数情况下， 方法与调用者之间需要进行数据的交互。 调用者必须提供必要的数据， 才能使用方法完成相应的功能。

例如:

ATM取款机， 封装了取钱的功能。 用户在使用ATM取款的时候， 需要插入银行卡。 此时， 就是使用者与功能集的数据交互。

自动贩卖机， 封装了贩卖的功能。 用户在使用自动贩卖机的时候， 需要选择购买的物品。 此时， 也是使用者与功能集的数据交互。

调用方法的时候， 需要将一些数据传入到方法中， 实现调用方与方法的数据交互。 这个被传入到方法中的数据， 被称为是 参数。

6.3.2. 参数的定义

参数定义在方法的小括号中， 与变量的定义类似， 使用 [ 数据类型 标识符 ] 的方式定义。

//定义了一个打印若干分隔符的方法，数量由参数count定义
public static void diaplay(int count) {for (int i = 0; i < count; i++) {System.out.println("-");}System.out.println();
}

定义参数的注意事项：

• 参数定义在方法的参数列表中， 使用 [ 数据类型 标识符 ] 的形式定义。

• 如果需要定义多个参数， 多个参数之间以逗号分隔。

• 参数在定义的时候， 不允许赋初始值。

• 即便多个参数的类型都是相同的， 每一个参数也必须显式的定义类型。

6.3.3. 有参方法的调用

在调用有参方法的时候， 必须给每一个参数进行赋值。 直接将这些值写入到小括号里面即可。

public class Test {public static void main(String[] args) {//方法的调用diaplay(5);}//定义了一个打印若干分隔符的方法，数量由参数count定义public static void diaplay(int count) {for (int i = 0; i < count; i++) {System.out.println("-");}System.out.println();}
}

6.3.4. 几个概念

• 形参:

  • 定义在方法的参数列表中， 这样的参数只是一个形式。 在方法中并不知道这个参数的值是什么， 只有在调用的时候才知道具体的值是多少。
  • 这样的参数被称为 形式参数， 简称 形参

• 实参:

  • 定义在方法调用时候的小括号中。 这个参数是形参实际的值。
  • 这样的参数被称为 实际参数， 简称 实参

• 传参:

  • 在调用方法的时候， 实参给形参进行赋值。 这个过程被称为 传参

6.4. 方法的返回值

6.4.1. 返回值的概念

在进行方法调用的时候， 有些情况下是需要有逻辑执行结果的。

例如

ATM取款机， 用户在取完钱之后， 一定是要能够得到实际的钱的。 此时就是调用功能集得到的结果。

6.4.2. 返回值的定义

在前面定义方法的时候， 返回值类型部分， 写的是void。

void: 表示无，没有返回值。表示这个方法没有执行结果。

static int add(int a, int b){return a+b;
}

注意事项

如果一个方法的返回值类型不是void， 则方法在执行结束之前， 必须要有return关键字返回一个结果。

6.4.3. return关键字

• 表示方法的执行结果。

  return关键字后面跟上方法的执行结果， 这个值的类型， 必须和方法定义中的返回值类型一致。

  static int add(int a, int b){return a+b; //将a+b的运算结果，作为整个方法的执行结果。
  }
  

• 表示结束方法的执行

  在一个返回值类型为void的方法中， 也可以使用return关键字。 此时， return后面什么都不要写。

  return写在方法中， 表示结束方法的结束。

  static int add(int a, int b){return a+b;//return执行后，后面的所有代码都不执行。//方法结束。
  }
  

6.5. 方法的重载

6.5.1. 重载的概念

在一个类的方法中， 如果多个方法满足如下条件， 则他们之间的关系就是重载

• 方法名相同

• 参数不同

  • 参数不同， 体现在参数的数量不同或者参数的类型不同。

注意： 方法的重载， 与返回值没有关系！

6.5.2. 重载方法的定义

public class Test {public static void calculate() {}public static void calculate(int a) {}public static void calculate(int a, int b) {}public static String calculate(String x, String y) {return x + y;}
}

6.5.3. 重载方法的调用

调用重载方法的时候， 使用实参区分调用不同的方法。

public class Test {public static void calculate() {}public static void calculate(int a) {}public static void calculate(int a, int b) {}public static String calculate(String x, String y) {return x + y;}public static void main(String[] args) {calculate();//无参方法调用calculate(3);//一个参数方法调用calculate(3, 4);//两个整型参数方法调用calculate("a", "b");//两个字符串型参数方法调用}
}

第七章、数组

7.1. 数组的概念

7.1.1. 一个案例

• 如何存储100名学生的成绩

  • 办法：使用变量存储，重复声明100个double类型的变量即可。
  • 缺点：麻烦，重复操作过多。

• 如何让100名学生成绩全部+1

  • 办法：100个变量重复相同操作，直到全部完毕。
  • 缺点：无法进行统一的操作。

7.1.2. 数组是什么

数组， 是一个数据容器。 可以存储若干个相兼容的数据类型的数据。

在上述案例中， 存储100名学生的成绩， 可以用数组来完成。 将这100个成绩存入一个数组中。 此时对这些数据进行统一操作的时候， 直接遍历数组即可完成。

7.1.3. 数组的特点

• 数组中可以存储基本数据类型的数据， 也可以存储引用数据类型的数据。
• 数组的长度是不可变的。 一个数组一旦实例化完成， 长度不能改变。

7.2. 数组的声明

7.2.1. 声明数组

double[] arrar1;
int[] array2;
String[] array3

7.2.2. 数组的实例化

实例化数组： 其实就是在内存中开辟空间， 用来存储数据。

public class Test {public static void main(String[] args) {// 实例化了一个数组， 可以存储5个数据// 此时数组中的元素就是默认的5个0int[] array1 = new int[5];// 实例化了一个数组， 默认存储的是 1, 2, 3, 4, 5// 此时数组的长度， 由这些存储的数据的数量可以推算出来为5int[] array2 = new int[] { 1, 2, 3, 4, 5 };// 实例化了一个数组， 默认存储的是 1， 2， 3， 4， 5// 相比较于第二种写法， 省略掉了 new int[]int[] array3 = { 1, 2, 3, 4, 5 };}
}

7.2.3. 数组引用

数组的实例化的时候，需要使用到关键字new

数组， 其实是在堆上开辟的连续的空间。 例如 new int[5]，就是在堆上开辟5个连续的4字节空间。

然后， 将堆上的内存地址， 给栈上的引用进行赋值。

7.3. 数组的下标

7.3.1. 下标的概念

下标， 就是数组中的元素在数组中存储的位置索引。

注意： 数组的下标是从0开始的， 即数组中的元素下标范围是 [0, 数组.length - 1)

7.3.2. 访问数组元素

访问数组中的元素， 需要使用下标访问。

public class Test {public static void main(String[] args) {//实例化一个数组int[] array = { 1, 2, 3, 4, 5 };//访问数组中的元素array[2] = 300;//将数组中的第2个元素修改为300System.out.println(array[2]);//此时输出的是300}
}

7.3.3. 注意事项

在访问数组中的元素的时候， 注意下标的问题！

如果使用错误的下标访问数组中的元素， 将会出现 ArrayIndexOutOfBoundsException 异常！

public class Test {public static void main(String[] args) {//实例化一个数组int[] array = { 1, 2, 3, 4, 5 };//访问数组中的元素array[10] = 300;//访问数组中下标为10的元素，此时数组的最大下标为4,会出现异常}
}

7.4. 数组的遍历

数组遍历： 其实就是按照数组中元素存储的顺序， 依次获取到数组中的每一个元素。

7.4.1. 下标遍历

思路： 循环依次获取数组中的每一个下标， 再使用下标访问数组中的元素

public class Test {public static void main(String[] args) {//实例化一个数组int[] array = {1, 2, 3, 4, 5};//使用下标遍历数组for (int i = 0; i < array.length; i++) {System.out.println(array[i]);}}
}

7.4.2. 增强for循环

思路： 依次使用数组中的每一个元素， 给迭代变量进行赋值。

public class Test {public static void main(String[] args) {//实例化一个数组int[] array = {1, 2, 3, 4, 5};//使用下标遍历数组for (int ele : array) {System.out.println(ele);}}
}

7.4.3. 两种方式的对比

• 如果需要在遍历的同时， 获取到数组中的元素下标， 需要使用下标遍历法。

• 如果需要在遍历的同时， 修改数组中的元素， 需要使用下标遍历法。

• 如果仅仅是想要获取数组中的每一个元素， 不需要下标， 也不需要修改数组中的元素， 使用增强for循环。 因为这种方式， 遍历的效率比下标遍历法高。

7.5. 数组的排序

排序，即排列顺序，将数组中的元素按照一定的大小关系进行重新排列。

在Java中， 常见的排序有:

• 选择排序：固定值与其他值依次比较大小，互换位置。

• 冒泡排序：相邻的两个数值比较大小，互换位置。

• JDK排序：java.util.Arrays.sort(数组); // JDK提供默认的升序排序

…

有兴趣的可自行百度。

7.6. 可变长参数

7.6.1. 概念

可以接收多个类型相同的实参，个数不限，使用方式与数组相同。

在调用方法的时候， 实参的数量可以写任意多个。

7.6.2. 语法

数据类型…形参名（必须放到形参列表的最后位，且只能有一个）

ststic void show(int...parameters){//方法体
}

7.6.3. 使用

public class Test {public static void main(String[] args) {// int[] array = { 1, 2, 3 };// showArray(array);// 如果一个方法的参数，使用 ... 来定义，可以将这个数组中的元素，直接写到实参列表中// 注意事项:// 1. 在形参列表中，可变长度的参数，必须在形参列表的最后位// 2. 一个形参列表中，只能存在一个...修饰的可变长度参数showArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 0);}public static void showArray(int a, int... array) {for (int i : array) {System.out.println(i + ",");}}
}

7.7. 二维数组

7.7.1. 概念

二维数组， 其实就是数组中嵌套数组。

二维数组中的每一个元素都是一个小的数组。

理论上来讲, 还可以有三维数组、四维数组， 但是常用的其实就是二维数组。

7.7.2. 定义与使用

public class Array {public static void main(String[] args) {// 1. 实例化一个二维数组// 第一个中括号中的3: 二维数组中包含了三个一维数组// 第二个中括号中的5: 二维数组中的每一个一维数组长度为5 int[][] array = new int[3][5];// 使用双下标访问数组中的元素array[0][3] = 10;// 这里得到的，是二维数组的长度，3 System.out.println(array.length);// 2. 实例化一个二维数组// 第一个中括号中的3: 二维数组中包含了三个一维数组//  第二个中括号中什么都没有，代表现在二维数组中的三个元素是 null int[][] array2 = new int[3][];array2[0] = new int[]{1, 2, 3};// 3. 通过初始值实例化一个二维数组int[][] array3 = {{1, 2, 3}, {1, 2, 3, 4, 5}, {2, 3, 4}};}
}

7.8. Arrays工具类

7.8.1. 常用方法

方法	描述
copyOf(int[] array, int newLength)	从原数组中拷贝指定数量的元素，到一个新的数组中，并返回这个新的数组
copyOfRange(int[] array, int from, int to)	从原数组中拷贝指定范围 [from, to) 的元素，到一个新的数组中，并返回这个新的数组
equals(int[] array1, int[] array2)	判断两个数组是否相同
fill(int[] array, int element)	使用指定的数据，填充数组
sort(int[] array)	对数组进行排序（升序）
binarySearch(int[] array, int element)	使用二分查找法，到数组中查询指定的元素出现的下标
toString(int[] array)	将数组中的元素拼接成字符串返回