java基本语法三

1 程序流程控制

• 流程控制语句是用来控制程序中各语句执行顺序的语句，可以将语句组合完成能完成一定功能的小逻辑模块。
• 流程控制方式采用结构化程序设计中规定的三种基本流程，即：
• ①顺序结构：
  • 程序从上到下逐行地执行，中间没有任何判断和跳转。　　
• ②分支结构：
  • 根据条件，选择性的执行某段代码。
  • 有if--else和switch--case两种分支语句。　　
• ③循环结构：
  • 根据循环条件，重复性的执行某段代码。
  • 有while、do...while、for循环三种循环语句。
  • JDK1.5提供了foreach循环，方便遍历集合、数组元素。　　

1.1 if-else语句

• 格式1：

if(条件表达式){
  //执行代码块;
}

• 格式2：

if(条件表达式){
  //执行代码块1;
}else{
  //执行代码块2;
}

• 格式3：

if(条件表达式1){
  //执行代码块1;
}else if(条件表达式2){
  //执行代码块2;
}
...
else{
  //执行代码块n;
}

• 示例：

package day04;

public class IfTest {
    public static void main(String[] args) {
        int heartBeats = 70;
        if (heartBeats < 60 || heartBeats > 100) {
            System.out.println("需要去医院做检查");
        }
    }
}

• 示例：

package day04;

public class IfTest {
    public static void main(String[] args) {
        boolean flag = true;
        if(flag){
            System.out.println("周末出去玩");
        }else{
            System.out.println("天气不好，周末在家睡觉");
        }
    }
}

• 示例：

package day04;

public class IfTest {
    public static void main(String[] args) {
        int age = 50;
        if (age > 0 && age <= 0.6) {
            System.out.println("婴儿");
        } else if (age > 0.6 && age <= 2) {
            System.out.println("幼儿");
        } else if (age > 2 && age <= 6) {
            System.out.println("儿童");
        } else if (age > 6 && age <= 14) {
            System.out.println("少年");
        } else if (age > 14 && age <= 35) {
            System.out.println("青年");
        } else if (age > 35 && age <= 60) {
            System.out.println("中年");
        } else if (age > 60) {
            System.out.println("老年");
        }
    }
}

• 示例：

package day04;

import java.util.Scanner;

public class IfTest {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("请输入分数：");
        int score = in.nextInt();
        if (score == 100) {
            System.out.println("奖励一辆BMW");
        } else if (score > 80 && score <= 99) {
            System.out.println("奖励一台iphone xr");
        } else if (score > 60 && score <= 80) {
            System.out.println("奖励一个ipad");
        } else {
            System.out.println("什么奖励也没有");
        }

    }
}

• 示例：

package day04;

import java.util.Scanner;

/**
 * 从键盘输入三个整数，对他们进行排序，并且按照从小到大排序
 */
public class IfTest {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("请输入第一个整数");
        int num1 = in.nextInt();
        System.out.println("请输入第二个整数");
        int num2 = in.nextInt();
        System.out.println("请输入第三个整数");
        int num3 = in.nextInt();

        if (num1 >= num2) {
            //num2 num1 num3
            if (num3 >= num1) {
                System.out.println(num2 + "<=" + num1 + "<=" + num3);
            } else if (num3 <= num2) { //num3 num2 num1
                System.out.println(num3 + "<=" + num2 + "<=" + num1);
            } else {//num2 num3 num1
                System.out.println(num2 + "<=" + num3 + "<=" + num1);
            }
        }else if(num1 < num2){
            //num1 num2 num3
            if(num3 >= num2){
                System.out.println(num1 + "<=" + num2 + "<=" + num3);
            }else if(num3 <= num1){ //num3 num1 num2
                System.out.println(num3 + "<=" + num1 + "<=" + num2);
            }else{ // num1 num3 num2
                System.out.println(num1 + "<=" + num3 + "<=" + num2);
            }

        }
    }
}

1.2 switch-case语句

• 格式：

switch(表达式){
case 常量1:
  语句1;
  //break;
case 常量2:
  语句2;
  //break;
……
default:
  语句n;
  //break;
}

• switch语句的有关规则：
• ①switch(表达式)中的表达式中的值必须是byte、short、char、int、枚举（JDK5.0）、String（JDK7.0）之一。
• ②case自己中的值必须是常量，不能是变量名或不确定的表达式值。
• ③同一个switch语句，所有case子句中的常量值互不相同。
• ④break语句用来执行完一个case分支后使程序跳出switch语句块；如果没有break，程序会顺序执行到switch结尾。
• ⑤default子句是可任选的。同时，位置也是灵活的。当没有匹配的case时，执行default。

• 示例：

package day04;

import java.util.Scanner;

/**
 * 如果成绩>=60分,则输出"合格";如果成绩<60分,则输出"不及格"。
 */
public class SwitchTest {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入分数:");
        int score = input.nextInt();
        switch (score / 10) {
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                System.out.println("不及格");
                break;
            case 6:
            case 7:
            case 8:
            case 9:
            case 10:
                System.out.println("及格");
                break;
        }

    }
}

• switch和if语句的对比：
• ①如果判断的具体数值不多，而且符号byte、short、char、int、String、枚举等几种类型。虽然两个语句都可以使用，建议使用switch语句，因为效率稍高。
• ②其他情况，对区间判断，对结果为boolean类型判断，使用if语句。换言之，使用switch-case语句的，都可以改写为if-else语句，反之，不成立。

1.3 循环结构

• 循环结构：在某些条件满足的条件下，反复执行特定代码的功能。

• 循环的分类：
• ①for循环。
• ②while循环。
• ③do-while循环。

1.3.1 循环语句的四个组成部分

• ①初始化条件。
• ②循环条件部分。
• ③循环体部分。
• ④迭代部分。

1.3.2 for循环

• 格式：

 for (①初始化条件;②循环条件部分;④迭代部分){
            ③循环体部分;
 }

• 说明：
• ②循环条件部分为boolean类型的表达式，当值为false的时候。退出循环。
• ①初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔。
• ④可以有多个变量更新，用逗号隔开。　　

• 执行过程：①-->②-->③-->④-->②-->③-->……-->②。

• 示例：

package day04;

public class ForTest {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println("helloworld!!!");
        }
    }
}

• 示例：

package day04;

/**
 * 100以内的偶数
 */
public class ForTest {
    public static void main(String[] args) {
        for (int i = 1; i <= 100; i = i + 1) {
            System.out.println(i);
        }
    }
}

• 示例：

package day04;

/**
 * 编写程序从1循环到150，并在每行打印一个值，另外在每个3的倍数行上打印"foo"，在每个5的倍数行上打印“biz”，在每个7的倍数行上打印输出“baz”。
 */
public class ForTest {
    public static void main(String[] args) {
        for (int i = 1; i <= 150; i++) {
            System.out.print(i);
            if (i % 3 == 0) {
                System.out.print("\t" + "foo");
            }
            if (i % 5 == 0) {
                System.out.print("\t" + "biz");
            }
            if (i % 7 == 0) {
                System.out.print("\t" + "baz");
            }
            System.out.println();
        }
    }
}

• 示例：

package day04;

import java.util.Scanner;

/**
 * 输入两个正整数m和n，求其最大公约数和最小公倍数。
 * 例如：12和20的最大公约数是4，最小公倍数是60。
 */
public class ForTest {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入第一个正整数：");
        int m = input.nextInt();
        System.out.println("请输入第二个正整数：");
        int n = input.nextInt();

        //求最大公约数：先求最小正整数，比如12和20的最小正整数是12，然后拿12和20和12、11、10取模，如果都能取模等于0，即最大公约数。
        int highestCommonDivissor = 0;
        int min = (m >= n) ? n : m;
        for (int i = min; i >= 1; i--) {
            if (m % i == 0 && n % i == 0) {
                highestCommonDivissor = i;
                break;
            }
        }
        System.out.println("最大公约数是：" + highestCommonDivissor);

        //求最小公倍数：先求最大值，这是循环的起始值；循环的终止条件是两个数相乘的结果
        int lowestCommonMultiple = 0;
        int max = (m >= n) ? m : n;
        for (int i = max; i <= m * n; i++) {
            if (i % m == 0 && i % n == 0) {
                lowestCommonMultiple = i;
                break;
            }

        }
        System.out.println("最小公倍数是：" + lowestCommonMultiple);

    }
}

1.3.3 while循环

• 格式：

①初始化条件;
while(②循环条件部分){
      ③循环体部分;
      ④迭代部分;
}

• 说明：
• ①注意不要忘记④迭代部分。否则，循环将变为死循环。
• ②for循环和while在某种程序上是可以相互转换的。

• 执行过程：①-->②-->③-->④-->②-->③-->④-->……。

• 示例：

package day04;

public class WhileTest {
    public static void main(String[] args) {
        int result = 0;
        int i = 1;
        while (i <= 100) {
            result += i;
            i++;
        }
        System.out.println("1-100的整数和是：" + result);
    }
}

1.3.4 do-while循环

• 格式：

①初始化条件;
do{
      ③循环体部分;
      ④迭代部分;
}while (②循环条件部分);

• 说明：do-while循环至少会执行一次。

• 执行过程：①-->③-->④-->②-->③-->④-->……。

• 示例：

package day04;

public class DoWhileTest {
    public static void main(String[] args) {
        int result = 0;
        int i = 1;
        do {
            result += i;
            i++;
        } while (i <= 100);
        System.out.println("1-100之内的整数和是：" + result);
    }
}

1.3.5 循环嵌套

• 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for、while、do...while均可以作为外层循环或内层循环。
• 实际上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false的时候，才会完全跳出内层循环，才可结束外层循环的当次循环，开始下一次循环。
• 如果外层循环次数为m次，内层循环为n次，那么内层循环体实际上需要执行m*n次。

• 示例：

package day04;

public class NestedLoop {
    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 + "=" + (j * i) + "\t");
            }
            System.out.println();
        }
    }
}

• 示例：

package day04;

/**
 * 100以内的所有质数的输出。
 * 质数：素数，只能被1和其本身整数的自然数。
 * 思路：从2开始，到这个数-1结束为止，都不能被这个数本身整数。
 * 最小的质数是2。
 */
public class PrimeNumber {
    public static void main(String[] args) {

        for (int i = 2; i <= 100; i++) {
            boolean flag = false;//表示质数
            for (int j = 2; j <= i - 1; j++) {
                if (i % j == 0) {//不是质数
                    flag = true;
                }
            }
            if (!flag) {
                System.out.println(i);
            }

        }
    }
}

• 示例：

package day04;

/**
 * 100以内的所有质数的输出。
 * 质数：素数，只能被1和其本身整数的自然数。
 * 思路：从2开始，到这个数-1结束为止，都不能被这个数本身整数。
 * 最小的质数是2。
 */
public class PrimeNumber {
    public static void main(String[] args) {

        for (int i = 2; i <= 100; i++) {
            boolean flag = false;//表示质数
            for (int j = 2; j <= i - 1; j++) {
                if (i % j == 0) {//不是质数
                    flag = true;
                    break;//优化1
                }
            }
            if (!flag) {
                System.out.println(i);
            }

        }
    }
}

• 示例：

package day04;

/**
 * 100以内的所有质数的输出。
 * 质数：素数，只能被1和其本身整数的自然数。
 * 思路：从2开始，到这个数-1结束为止，都不能被这个数本身整数。
 * 最小的质数是2。
 */
public class PrimeNumber {
    public static void main(String[] args) {

        for (int i = 2; i <= 100; i++) {
            boolean flag = false;//表示质数
            //优化2
            for (int j = 2; j <= Math.sqrt(i); j++) {
                if (i % j == 0) {//不是质数
                    flag = true;
                    break;//优化1
                }
            }
            if (!flag) {
                System.out.println(i);
            }

        }
    }
}