3.java基本语法(程序流程控制)

程序流程控制

1.顺序结构
2.分支结构
3.循环结构

分支结构

if_else

说明;
1.else结构是可选的
2.针对条件表达式：

• 如果多个条件表达式之间是“互斥”关系（或没有交集的关系），哪个判断和执行语句生命在上面还是下面，无所谓。
• 如果多个表达式之间有交集的关系，需要根据实际情况，考虑清楚应该将哪个结构声明在上面。
• 如果多个表达式之间有包含的关系，通常情况下，需要将范围小的声明在范围大的上面。否则范围小的就没有机会执行了。
  3.if-else结构是可以相互嵌套的
  4.如果if-else结构中的执行语句只有一行时，对应的一对{}可以省略。（不建议）

/*
第一种：
if(条件表达式){
    执行表达式1
}

第二种：二选一
if(条件表达式){
    执行表达式1
}else{
    执行表达式2
}

第三种：多选一
if(条件表达式){
    执行表达式1
}else if(条件表达式){
    执行表达式2
}else if(条件表达式){
    执行表达式3
}
……
else{
    执行表达式n
}
*/

class IfTest{
    public static void main(String[] args){
        //举例1
        int heartBeats = 79;
        if(heartBeats <60 || heartBeats > 100){
            System.out.println("需要做进一步检测");
        }
        System.out.println("检查结束");

        //举例2
        int age = 23;
        if(age < 18){
            System.out.println("你还小");
        }else{
            System.out.println("你已经成年了");
        }

        //举例3
        if(age < 0){
            System.out.println("输入数据非法");
        }else if(age < 18){
            System.out.println("青少年时期");
        }else if(age < 35){
            System.out.println("青壮年时期");
        }else if(age < 60){
            System.out.println("中年时期");
        }else{
            System.out.println("老年时期");
        }
    }
}

如何从键盘获取不同数据类型的变量：需要使用Scanner类
具体实现步骤：
1.导包: import java.util.Scanner
2.Scanner的实例化：Scanner scan = new Scanner(System.in);
3.调用Scanner类的相关方法，来获取指定类型的变量

注意：需要根据相应的方法，来输入指定类型的数据值。如果输入的数据类型与要求的类型不匹配时，会报异常：InputMismatchExceprion导致程序终止。

//1.导包: import java.util.Scanner
import java.util.Scanner;

class ScannerTest{
    public static void main(String[] args){
        //2.Scanner的实例化
        Scanner scan = new Scanner(System.in);
        
        //3.调用Scanner类的相关方法
        System.out.println("请输入你的姓名：");
        String name = scan.next();
        System.out.println(name);

        System.out.println("请输入你的年龄：");
        int age = scan.nextInt();
        System.out.println(age);

        System.out.println("请输入你的体重：");
        double weight = scan.nextDouble();
        System.out.println(weight);

        System.out.println("你吃饭了吗？（true/false）");
        boolean isEat = scan.nextBoolean();
        System.out.println(isEat);

        //对于char型获取，Sacnner没有提供相关的方法。之恶能获得一个字符串
        System.out.println("请输入你的性别（男/女）：");
        String gender = scan.next();
        char genderChar = gender.charAt(0);
        System.out.println(genderChar);
    }
}

获取一个随机数

class RandomTest{
    public static void main(String[] args){
        double value = (int)(Math.random() * 90 + 10);//[10,100)
        System.out.println(value);
        //公式:[a,b]:(int)(Math.random() * (b-a+1) + a)
    }
}

switch-case结构

说明：
1.根据switch表达式中的值，一次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。当调用玩执行语句以后，则仍然继续向下执行其他case结构中的执行语句，知道遇到break关键字或switch-case结构结束为止。
2.break，可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构
3.switch结构中的表达式，只能是如下的6中数据类型之一：byte、short、char、int、枚举类型（JDK 5.0新增)、String(JDK 7.0新增)
4.case之后只能声明常量。不能声明范围。
5.break关键字可选。
6.default:相当于if-else中的else.(可选，且位置灵活)
7.如果switch-case结构中的多个case的执行语句相同，则可以考虑合并
8.凡是可以用switch-case的结构，都可以转换为if-else。反之，不成立。
9.我们写分支结构时，当发现既可以使用switch-case（同时，switch中表达式的取值情况不太多）,又可以使用if-else时，有限选择使用switch-case.原因：switch-case执行效率稍高。

/*
switch(表达式){
    case 常量1:
        执行语句1;
        //break;
    case 常量2:
        执行语句2;
        //break;
    ...
    default:
        执行语句n;
        //break;
}
*/
class SwitchCaseTest{
    public static void main(String[] args){
        int number = 2;
        switch(number){
            case 0:
                System.out.println("zero");
                break;
            case 1:
                System.out.println("one");
                break;
            case 2:
                System.out.println("two");
                break;
            case 3:
                System.out.println("three");
                break;
            default:
                System.out.println("other");
                break;
        }
    }
}

循环结构

循环结构的4个要素
1.初始化条件
2.循环条件 --> boolean型
3.循环体
4.迭代条件

for循环结构的使用
1.for循环的结构
for(①;②;④){
③
}
执行过程：① - ② - ③ - ④ - ② - ③ - ④ - … - ②

import java.util.Scanner;

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

        //练习
        int num = 1;
        for(System.out.println('a');num <= 3;System.out.println('c'),num++){
            System.out.println('b');
        }
        //输出结果：abcbcbc

        //计算两个数的最大公约数和最小公倍数
        Scanner scan = new Scanner(System.in);

        System.out.println("输入第一个正整数：");
        int n = scan.nextInt();

        System.out.println("输入第二个正整数：");
        int m = scan.nextInt();
        int min = (m <= n)? m : n;
        for(int i = min;i >= 1 ;i--){
            if(m % i == 0 && n % i == 0){
                System.out.println("最大公约数为 ：" + i);
                break;
            }
        }

        int max = (m >= n)? m : n;
        for(int i = max;i <= m * n; i++){
            if(i % m == 0 && i % n == 0){
                System.out.println("最小公倍数为：" + i);
                break;
            }
        }

        //gcd求最大公约数和最小公倍数
        System.out.println("最大公约数为：" + gcd(n , m));
        System.out.println("最小公倍数为："+ n * m / gcd(n , m));
    }

    static int gcd(int a, int b){
        return b == 0? a : gcd(b, a%b);
    }
}

While循环的使用
1.while循环的结构
①
while(②){
③;
④;
}
执行过程：① - ② - ③ - ④ - ② - ③ - ④ - … - ②

2.说明

• 写while循环千万小心不要丢了迭代条件。一旦丢了，就可能导致死循环！
• 我们写程序，要避免出现死循环
• for循环和while循环可以相互转换

class WhileTest{
    public static void main(String[] args){
        //遍历100以内的所有偶数
        int i = 1;
        while(i <= 100){
            if(i % 2 == 0){
                System.out.println(i);
            }
            i++;
        }
    }
}

do-while循环
1.do-while循环结构
①
do{
③;
④;
}while(②);

执行过程：① - ③ - ④ - ② - ③ - ④ - … - ②

2.说明

• do-while循环至少会执行一次循环体
• 开发中，使用for和while更多一些

class DoWhileTest{
    public static void main(String[] args){
        //遍历100以内的偶数
        int num = 1;
        do{
            if(num % 2 == 0){
                System.out.println(num);
            }
            num++;
        }while(num <= 100);
    }
}

嵌套循环的使用

1.将一个循环结构A声明在另一个循环结构B的循环体中，就构成了嵌套循环
2.
外层循环：循环结构B
内层循环：循环结构B
3.说明

• 内层循环结构遍历一遍，只相当于外层循环体执行一次
• 假设外层循环需要执行m次。内层循环需要执行n次。此时内层循环的循环体一共执行了n * m次。

4.技巧

• 外层循环控制行数，内层循环控制列数

class ForForTest{
    public static void main (String[] args){
        /*
        *****
        *****
        *****
        *****
        */
        for(int i = 0; i < 4; i++){
            for(int j = 0; j < 5; j++){
                System.out.print('*');
            }
            System.out.println();
        }
        
        /*
        *
        **
        ***
        ****
        *****
        */
        for(int i = 1; i <= 5; i++){
            for(int j = 0; j < i; j++){
                System.out.print('*');
            }
            System.out.println();
        }
        
        /*
        *
        **
        ***
        ****
        *****
        ****
        ***
        **
        *
        */
        for(int i = 1; i <= 5; i++){
            for(int j = 0; j < i; j++){
                System.out.print('*');
            }
            System.out.println();
        }
        for(int i = 4; i > 0; i--){
            for(int j = 0; j < i; j++){
                System.out.print('*');
            }
            System.out.println();
        }
    }
}

输出100000以内所有质数
质数：素数，只能被1和它本身整除的自然数 --> 从2开始，到这个数-1结束为止，都不能被这个数本身整除
最小的质数是2

class PerimeNumberTest{
    public static void main(String[] args){

        int maxNum = 100001;
        long start = System.currentTimeMillis();

        boolean ifFlag = true;
        for(int i = 2;i <= maxNum;i++){
            ifFlag = true;
            for(int j = 2;j <= Math.sqrt(i); j++){
                if(i % j == 0){
                    ifFlag = false;
                    break;
                }
            }
            if(ifFlag){
                System.out.println(i);
            }
        }

        long end1 = System.currentTimeMillis();

        //方法二,快速计算素数表
        int[] perimeNumberList = new int[maxNum];
        for(int i = 0;i < maxNum; i++){
            perimeNumberList[i] = 1;
        }
        perimeNumberList[0] = perimeNumberList[1] = 0;
        for(int i = 2; i * i < maxNum; i++){
            if(perimeNumberList[i] == 1){
                for(int j = i * 2;j < maxNum; j += i){
                    perimeNumberList[j] = 0;
                }
            }
        }
        for(int i = 0; i < maxNum; i++){
            if(perimeNumberList[i] == 1){
                System.out.println(i);
            }
        }

        long end2 = System.currentTimeMillis();

        System.out.println("方法一所用时间为；" + (end1 - start));//36

        System.out.println("方法一所用时间为；" + (end2 - end1));//17
    }
}

特殊关键字的使用
break和continue关键字的使用

关键字	使用范围	循环中使用的作用	相同点
break	switch-case 循环结构中	结束当前循环	关键字后不能声明执行语句
continue	循环结构中	结束当次循环	关键字后不能声明执行语句

class BreakContinueTest{
    public static void main(String[] args){
        for(int i = 1;i <= 10;i++){
            if(i % 4 == 0){
                //break;//123
                continue;//123567910
            }
            System.out.print(i);
        }

        //*****************************
        System.out.println();
        label:for(int i = 1;i <= 4;i++){
            for(int j = 1;j <= 10;j++){
                if(j % 4 ==0){
                    //break label;//结束指定标识的一层循环结构
                    continue label;//结束指定标识的一层循环结构当次循环
                }
                System.out.print(j);
            }
            System.out.println();
        }
    }
}

class PerimeNumberTest2{
    public static void main(String[] args){

        int maxNum = 100001;
        long start = System.currentTimeMillis();

        label:for(int i = 2;i <= maxNum;i++){
            for(int j = 2;j <= Math.sqrt(i); j++){
                if(i % j == 0){
                    continue label;
                }
            }
            System.out.println(i);
        }

        long end = System.currentTimeMillis();

        System.out.println("所用时间为；" + (end - start));

    }
}