DAY2

流程控制

顺序结构

例：

public static void main(String[] args){

//顺序执行 ，根据编写的顺序 ，从上到下运行

System.out.println(1);

System.out.println(2);

System.out.println(3);

}

---

判断语句

IF

例：

if(关系表达式) {

语句体;

}

执行流程

首先判断关系表达式看其结果是true还是false

如果是true就执行语句体

如果是false就不执行语句体

---

IF...ELSE

例：

if(关系表达式) {

语句体1;

}else {

语句体2;

}

执行流程

首先判断关系表达式看其结果是true还是false

如果是true就执行语句体1

如果是false就执行语句体2

---

IF...ELSE  IF...ELSE

例：

if (判断条件1) {

执行语句1;

} else if (判断条件2) {

执行语句2;

}

...

}else if (判断条件n) {

执行语句n;

} else {

执行语句n+1;

}

执行流程

首先判断关系表达式1看其结果是true还是false

如果是true就执行语句体1

如果是false就继续判断关系表达式2看其结果是true还是false

如果是true就执行语句体2

如果是false就继续判断关系表达式 …看其结果是true还是false

如果没有任何关系表达式为true ，就执行语句体n+1。

---

if语句和三元运算符的互换

例：

public static void main(String[] args) {

int a = 10;

int b = 20;

//定义变量 ，保存a和b的较大值

int c;

if(a > b) {

c = a;

} else {

c = b;

}

//可以上述功能改写为三元运算符形式

c = a > b ? a:b;

}

---

选择语句

SWITCH

例：

switch(表达式) {

case 常量值1:

语句体1;

break;

case 常量值2:

语句体2;

break;

...

default:

语句体n+1;

break;

}

执行流程

首先计算出表达式的值

其次 ，和case依次比较 ，一旦有对应的值 ，就会执行相应的语句 ，在执行的过程中 ，遇到break就会结束

最后 ，如果所有的case都和表达式的值不匹配 ，就会执行default语句体部分 ，然后程序结束掉。

注：switch语句中 ，表达式的数据类型 ，可以是byte ，short ，int ，char ，enum  (枚举)  ，JDK7后可以接收字符串。

---

case的穿透性

在switch语句中 ，如果case的后面不写break ，将出现穿透现象 ，也就是不会在判断下一个case的值 ，直接向后运行 ，直到遇到break ，或者整体switch结束。

循环语句

FOR

例：

for(初始化表达式① ; 布尔表达式② ; 步进表达式④ ){

循环体③

}

执行流程

执行顺序：①②③④>②③④>②③④ …②不满足为止。

①负责完成循环变量初始化

②负责判断是否满足循环条件 ，不满足则跳出循环

③具体执行的语句

④循环后 ，循环条件所涉及变量的变化情况

---

WHILE

例：

初始化表达式①

while(布尔表达式② ){

循环体③

步进表达式④

}

执行流程

执行顺序：①②③④>②③④>②③④ …②不满足为止。

①负责完成循环变量初始化。

②负责判断是否满足循环条件 ，不满足则跳出循环。

③具体执行的语句。

④循环后 ，循环变量的变化情况。

---

DO...WHILE

例：

初始化表达式①

do{

循环体③

步进表达式④

}while(布尔表达式② );

执行流程

执行顺序：①③④>②③④>②③④ …②不满足为止。

①负责完成循环变量初始化。

②负责判断是否满足循环条件 ，不满足则跳出循环。

③具体执行的语句

④循环后 ，循环变量的变化情况

---

循环语句的区别

FOR和WHILE的区别

控制条件语句所控制的那个变量 ，在for循环结束后 ，就不能再被访问到了 ，而while循环结束还可以继续使用 ，如果你想继续使用 ，就用while ，否则推荐使用for。原因是for循环结束 ，该变量就从内存中消 失 ，能够提高内存的使用效率。

在已知循环次数的时候使用推荐使用for ，循环次数未知的时推荐使用while。

跳出语句

break

使用场景：终止switch或者循环

在选择结构switch语句中

在循环语句中

离开使用场景的存在是没有意义的

---

continue

使用场景：结束本次循环 ，继续下一次的循环

---

方法

方法的定义和调用

例：

public class Method_Demo1 {

public static void main(String[] args) {

print();

}

private static void print() {

for (int i = 0; i < 5; i++) {

for (int j = 0; j < 8; j++) {

System.out.print("*");

}

System.out.println();

}

}

}

print方法被 main 方法调用后直接输出结果 ，而main方法并不需要 print 方法的执行结果 ，所以被定义为void

---

定义方法的格式

修饰符 返回值类型 方法名(参数列表){

//代码省略 ...

return 结果;

}

修饰符：   public static 固定写法

返回值类型：   表示方法运行的结果的数据类型 ，方法执行后将结果返回到调用者

参数列表：方法在运算过程中的未知数据 ，调用者调用方法时传递return

注：return 结果; 这里的"结果"在开发中 ，我们正确的叫法成为方法的返回值

---

定义方法的两个明确

需求：定义方法实现两个整数的求和计算。

明确返回值类型：方法计算的是整数的求和 ，结果也必然是个整数 ，返回值类型定义为int类型。

明确参数列表：计算哪两个整数的和 ，并不清楚 ，但可以确定是整数 ，参数列表可以定义两个int类型的变量 ，  由调用者调用方法时传递

定义方法的注意事项

定义位置 ，类中方法外面。

返回值类型 ，必须要和return语句返回的类型相同 ，否则编译失败 。

不能在return后面写代码，return意味着方法结束 ，所有后面的代码永远不会执行，属于无效代码。

调用方法的三种形式

直接调用：直接写方法名调用

例：

public static void main(String[] args) {

print();

}

public static void print() {

System.out.println("方法被调用");

}

---

赋值调用：调用方法 ，在方法前面定义变量 ，接收方法返回值

例：

public static void main(String[] args) {

int sum = getSum(5,6);

System.out.println(sum);

}

public static int getSum(int a,int b) {

return a + b;

}

---

输出语句调用，在输出语句中调用方法，System.out.println(方法名（）)

例：

public static void main(String[] args) {

System.out.println(getSum(5,6));

}

public static int getSum(int a,int b) {

return a + b;

}

---

方法重载

方法重载：指在同一个类中 ，允许存在一个以上的同名方法 ，只要它们的参数列表不同即可 ，与修饰符和返 回值类型无关。

参数列表：个数不同 ，数据类型不同 ，顺序不同。

重载方法调用：JVM通过方法的参数列表 ，调用不同的方法。

---

数组定义和访问

数组概念

数组概念：   数组就是存储数据长度固定的容器 ，保证多个数据的数据类型要一致

数组的定义

方式一

格式：数组存储的数据类型[] 数组名字  = new 数组存储的数据类型[长度];

例：int[] arr = new int[3];

方式二

格式：数据类型[] 数组名  = new 数据类型[]{元素1,元素2,元素3...};

例：int[] arr = new int[]{1,2,3,4,5};

方式三

格式：数据类型[] 数组名  = {元素1,元素2,元素3...};

例：int[] arr = {1,2,3,4,5};

数组的访问

索引：   每一个存储到数组的元素 ，都会自动的拥有一个编号 ，从0开始 ，这个自动编号称为数组索引 (index) ，可以通过数组的索引访问到数组中的元素。

格式：数组名[索引]

例：

public static void main(String[] args) {

int[] arr = new int[]{1,2,3,4,5};

//打印数组的属性 ，输出结果是5

System.out.println(arr.length);

}

索引访问数组中的元素：

数组名[索引]=数值 ，为数组中的元素赋值

变量=数组名[索引] ，获取出数组中的元素

---

数组遍历

 数组遍历：就是将数组中的每个元素分别获取出来 ，就是遍历。遍历也是数组操作中的基石。

例：

public static void main(String[] args) {

int[] arr = { 1, 2, 3, 4, 5 };

System.out.println(arr[0]);

System.out.println(arr[1]);

System.out.println(arr[2]);

System.out.println(arr[3]);

System.out.println(arr[4]);

}

数组获取最大值元素

最大值获取：从数组的所有元素中找出最大值。

实现思路：

定义变量 ，保存数组0索引上的元素

遍历数组 ，获取出数组中的每个元素

将遍历到的元素和保存数组0索引上值的变量进行比较

如果数组元素的值大于了变量的值 ，变量记录住新的值

数组循环遍历结束 ，变量保存的就是数组中的最大值

---

例：

public static void main(String[] args) {

int[] arr = { 5, 15, 2000, 10000, 100, 4000 };

//定义变量 ，保存数组中0索引的元素

int max = arr[0];

//遍历数组 ，取出每个元素

for (int i = 0; i < arr.length; i++) {

//遍历到的元素和变量max比较

//如果数组元素大于max

if (arr[i] > max) {

//max记录住大值

max = arr[i];

}

}

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

}

数组反转

数组的反转：   数组中的元素颠倒顺序 ，例如原始数组为1,2,3,4,5 ，反转后的数组为5,4,3,2,1

实现思想：数组最远端的元素互换位置。

实现反转 ，就需要将数组最远端元素位置交换

定义两个变量 ，保存数组的最小索引和最大索引

两个索引上的元素交换位置

最小索引++ ，最大索引-- ，再次交换位置

最小索引超过了最大索引 ，数组反转操作结束

---

例：

public static void main(String[] args) {

int[] arr = { 1, 2, 3, 4, 5 };

/*

循环中定义变量min=0最小索引

max=arr.length ‐1最大索引

min++,max ‐ ‐

*/

for (int min = 0, max = arr.length ‐ 1; min <= max; min++, max ‐‐ ) {

//利用第三方变量完成数组中的元素交换

int temp = arr[min];

arr[min] = arr[max];

arr[max] = temp;

}

// 反转后 ，遍历数组

for (int i = 0; i < arr.length; i++) {

System.out.println(arr[i]);

}

}

数组作为方法参数和返回值

数组作为方法参数

数组作为方法参数传递 ，传递的参数是数组内存的地址。

数组作为方法返回值

 数组作为方法的返回值 ，返回的是数组的内存地址