java初学者第四天笔记

流程控制

① 分支：当程序执行到某个状态的时候，可能会发生多种情况，编程人员就需要将可能的情况尽数表示出来，就利用分支的结构来进行描述；这个种结构会让代码量写得较多，真正执行程序的时候执行的会比较少

if

switch

② 循环：当程序执行到某个状态的时候，可能需要重复的执行某段代码，可以利用循环的结构来处理；写得少，执行多

for

while

 分支结构 - if

第一种格式

if(条件表达式){

代码块

}

 格式说明

如果表达式成立（true）,就执行代码块，否则啥也不干。这种结构适合做一种情况的判断

案例：键盘录入两个整数，输出较大的那个

import java.util.Scanner;
public class Demo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个整数：");
        int i = sc.nextInt();
        System.out.println("请输入第二个整数：");
        int i1 = sc.nextInt();
        if(i > i1){
            System.out.println(i);
       }
        if(i <= i1){
            System.out.println(i1);
       }
   }
}

第二种格式

if(条件表达式){

代码块；

}else{

代码块2；

}

 格式说明

如果表达式成立（true）,就执行代码块，否则执行代码块2；始终有代码会被执行；一旦有代码执行，整个结构就结束

 案例：键盘录入两个整数，输出较大的那个

import java.util.Scanner
;public class Demo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个整数：");
        int i = sc.nextInt();
        System.out.println("请输入第二个整数：");
        int i1 = sc.nextInt();
        if(i > i1){
            System.out.println(i);
       }else{
            System.out.println(i1);
       }
   }
}

第三种结构

if(表达式1){

代码块1；

}else if(表达式2){

代码块2；

}else if(表达式3){

代码块3；

}········else if(表达式n){

代码块n;

}else{ 代码块n+1;

}

 结构说明

首先进行表达式1的判断，如果为true，就执行代码块1，结构结束；

每一次的条件在做判断的时候，都会将前一个表达式默认为已知条件

整个结构只会执行其中某一个代码块，任意的一个代码块被执行，整个结构就会结束；

如果没有else，整个结构可能都不会执行

 案例：键盘录入一个成绩，输出该成绩对应的等级（A - 90以上，B - 80以上，C - 70以上，D - 60以上，E - 60以下 

import java.util.Scanner;
public class Demo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个成绩：");
        int score = sc.nextInt();
        if(score >= 90){
            System.out.println("A");
       }else if( score >= 80){
           System.out.println("B");
       }else if( score >= 70){
            System.out.println("C");
       }else if( score >= 60){ 
           System.out.println("D");
       }else{
            System.out.println("E");
       }
   }
}

练习

定义一个类 Test02

定义 main 方法

键盘录入一个整数赋值给变量 price

当 price > 1000；输出折扣金额（5%）；

当 price > 800;输出折扣金额（4%）;

当 price > 600；输出折扣金额（3%）；

当 price >= 500;输出折扣金额（2%）;

当 price < 500;没有折扣

 分支结构 - switch

① Switch 是另一种用于分支的表示方式，它的运行效率比 if 要高一些，但是结构上要复杂一些；可以简单的把 switch 当做是钥匙，把每一种情况看作是一扇门，如果钥匙能够打开这扇门，那么就进去执行代码；否则继续开下一扇门，如果所有门都打不开，就去打开那扇默认的门；

② 结构

switch(变量){

case 常量1：

代码块1；

break;

case 常量2：

代码块2；

break;

case 常量3：

代码3；

break;

·········

default:

代码块n;

break;

}

③ 执行流程

a. 计算switch后面小括号内的变量值

b. 从上往下，将变量的值依次和case后面的常量值进行比较

c. 如果变量值和常量1相等，就执行代码块1，再执行break,switch结束；如果没有break，就出case 穿透。

d. 如果变量值和常量1不相等，继续和常量2进行比较，以此类推

e. 如果变量值和所有的常量值都不等，就执行default 内的代码，如果default内部有break语句，switch结束

f. 如果default内部没有break语句，需要看 default 所在位置

g. 如果default 处于switch 结构的最底层，swithc 结束，否则出现 case 穿透

④ case 穿透 不再去判断变量值与后面紧挨着的 case 常量值是否相等，直接进入到后面紧挨着的 case 内部去执行代码；一直到遇见了break 或者是 switch的右大括号才会停止；

case 穿透不一定就是坏事；当我们不同情况有相同的处理方式的时候就可以利用这个特点来节省代码

⑤ 注意事项

a. switch后面小括号内的变量只能是（int / short / btye / char / String / 枚举）这些类型

b. 建议在写 default 的时候都写在结构的最底层

c. switch 是一个分支结构，不要当做是循环结构

d. switch 想要结束，只有碰到了 break 或者是 switch 的右大括号

 案例：键盘录入一个成绩，输出该成绩对应的等级（A - 90以上，B - 80以上，C - 70以上，D - 60以上，E - 60以下 ）

public class Demo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个成绩：");
        int score = sc.nextInt();
        switch (score / 10){
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                System.out.println("E");
                break;
            case 6:
                System.out.println("D");
                break;
            case 7:
                System.out.println("C");
                break;
            case 8:
                System.out.println("B");
                break;
            case 9:
            default:
                System.out.println("A");
       }
   }
}

do while

结构

do{

代码块；

}while(条件表达式);

 结构说明

① 先执行代码块，在进行条件的判断，至少执行一次代码

② while 小括号的后面需要加上一个分号

 执行流程

① 先执行代码块

② 计算条件表达式；如果条件成立，继续执行代码块；

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

 案例：假设有10000块钱本金，银行的年利率为5%；每年利息自动结算为本金，请问几年后，本金超过20000；

public class Demo {
 public static void main(String[] args) {
 double money = 10000;
 boolean flag = true;
 int count = 0;
 do{
 money = money + money * 0.05;
 count ++;
 if(money >= 20000){
 flag = false;
 }
 }while(flag);
 System.out.println(count);
 }
}

while

结构

初始化变量；

while(条件表达式){

循环体；

变量的改变

}

 结构说明

① 当需要循环处理某段代码，且不知道循环次数时，选择while循环

② 条件表达式必须是一个boolean 类型的表达式，或者就是 true （false）

③ 初始化变量在循环外部执行，变量的改变在循环的内部，条件表达式同事有初始化变量参与的表达式

④ 变量的改变往往是让条件表达式为false的方向进行，目的就是让循环能够在未来某一个时间点结束

 执行流程

① 计算条件表达式

② 如果表达式结果为false，整个循环结束

③ 如果表达式结果为true，执行循环体，进行变量的改变，回到第①步

 案例：猜数字游戏

public class Demo {
 public static void main(String[] args) {
     // 1- 100之间随机生成一个整数
     int rand = (int)(Math.random()*100 + 1);
     Scanner sc = new Scanner(System.in);
     boolean flag = true; while(flag) {
     System.out.println("请输入一个 1 - 100 之间的数字：");
     int guess = sc.nextInt();
     if (guess > rand) {
    System.out.println("猜大了");
     } else if (guess < rand) { 
    System.out.println("猜小了");
     } else { 
    System.out.println("猜对了"); 
    flag = false; }
 }
 }
}

练习：假设有10000块钱本金，银行的年利率为5%；每年利息自动结算为本金，请问几年后，本金超过20000；

public class Demo {
 public static void main(String[] args) {
     double money = 10000;
     boolean flag = true;
     int count = 0;
     while(flag){
     money = money + money * 0.05;
     count ++;
     if(money >= 20000){
     flag = false;
 }
 } 
    System.out.println(count);
 }
}

嵌套的for循环

结构

for(初始化化变量1；条件表达式1；变量1的改变){

for(初始化变量2；条件表达式2；变量2的改变){

循环体；

}

}

 结构说明

① 在for循环的内部，不在是普通的代码，而是一段需要再次重复执行的内容

② 外层的循环每执行一次，内层的循环会将满足条件的所有情况都执行完（外层执行一次，内层执行一轮）

执行流程 

① 初始化化变量1；只会执行一次

② 计算条件表达式1；

③ 如果条件表达式1结果为 false，整个循环结束

④ 如果条件表达式1结果为true，进入外层循环内部，初始化变量2；

⑤ 计算条件表达式2；

⑥ 如果条件表达式2结果为false，进行变量1的改变，回到第②步

⑦ 如果条件表达式2结果为true，执行循环体，执行变量2的改变，回到第⑤步

 案例：打印99乘法表

public class Demo {
 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.println();
 }
 }
}

普通for循环

结构

for(初始化变量；条件表达式；初始化变量的改变){

循环语句；

}

 结构说明

① 当程序执行到某个状态时需要多次的执行某部分代码，这个时候就可以使用上述结构来处理

② 初始化变量：声明一个变量用来表示循环的起始点，或者在某些时候可以用来记录循环次数；只会初始化一次

③ 条件表达式：用于判断循环是否能够继续进行

④ 初始化变量的改变：通常使用自增、自减；让循环可以向着结束的方向发展

 使用的场景

当需要重复执行代码，并且知道循环的次数时，建议选择该循环

 执行流程

① 初始化变量，只会在循环第一次开始的时候执行，往后都不会再初始化

② 计算条件表达式，因为条件表达式是一个 boolean 类型表达式，结果要么是true,要么是false

③ 如果表达式的结果为 false，循环结束

④ 如果表达式的结果为 true，执行循环体，再进行初始化变量的改变

⑤ 回到第②步

 案例：打印 1 - 100 之间所有的自然数

public class Demo {
 public static void main(String[] args) {
 for(int i = 1; i <= 100; i++ ){
 System.out.println(i);
 }
 }
}

 循环总结

小结

① 当知道循环次数的时候，建议使用for循环；不知道次数的时候建议使用while循环

② while是先判断条件，条件成立才会执行循环体；

③ do···while是先执行循环体，在判断条件；它会至少执行一次循环体

④ 嵌套循环普遍使用的是for循环嵌套，主要应用于二维图案的打印。或者是二维数组的处理

 循环的跳转

① 当循环执行到某个状态时，不想让循环再继续执行，这个时候就可以使用跳转语句

② 跳转语句通常应用在死循环中（格式上的死循环）

for(；true；){

}

while(true){

实际上在内部往往会有破坏循环的语句 --- 跳转语句

}

 跳转语句

① continue：强制结束当前正在执行的循环，并且进入下一次循环是否进行的条件判断

② break：直接破坏当前层次的循环，不会进入下次循环是否进行的条件判断

 案例：打印 1- 100之间所有的偶数

public class Demo {
  public static void main(String[] args) {
 for(int i = 1;i <= 100; i++){ if(i % 2 == 1){
 // break; 直接强制破坏循环，整个程序啥也不会输出
 // continue; 会将所有的奇数跳过，只打印偶数
 }
 System.out.println(i);
 }
 }
}