【Java】第二章_Java基本语法（下）

第二章 Java基本语法（下）

本次笔记就是对上结理论知识的巩固，主要是对流程控制部分的代码练习。

一、如何从键盘获取不同类型的变量

1.1 实现步骤

（1）导包：import java.util.Scanner;

（2）Scanner的实例化：Scanner scan = new Scanner(System.in);

（3）调用Scanner类的相关方法，来获取指定类型的变量

以下是代码示例

/*
如何从键盘获取不同类型的变量，需要使用Scanner类

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

*/

import java.util.Scanner;

public class ScannerTest {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);

        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 agree = scan.nextBoolean();
        System.out.println(agree);

        //对于char型的获取，Scanner没有提供相关的方法，只能获取一个字符串
        System.out.println("请输入你的性别:(男/女)");
        String gender = scan.next();//"男"
        char genderChar = gender.charAt(0);//获取索引为0位置上的字符
        System.out.println(genderChar);


    }
}

二、if语句

例题1：

岳小鹏参加Java考试，他和他父亲岳不群达成承诺
如果：

成绩为100分时，奖励一台BMW；

成绩为(80,99]时，奖励一台iphone 12

当成绩为[60，80]时，奖励一个ipad

其他时就没有奖励

请从键盘输入岳小鹏的成绩，并加以判断

/*
说明：
1.else 结合是可选的
2.针对于条件表达式
    >如果对个条件表达式之间是“互斥”关系（或没有交集的关系），哪种判断和执行语句声明在上面或者在下面，无所谓
    >如果对个条件表达式之间有交集的关系，需要根据实际情况，考察清楚应该那个结构声明在上面
    >如果是包含关系，我们要把小的那部分写在上面。如果把范围大的写在上面，范围小的就没有机会执行了

 */


import java.util.Scanner;

class IfTest1 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入岳小鹏期末成绩：（0-100）");
        int score = scan.nextInt();

        if (score == 100){
            System.out.println("奖励一辆BMW");
        }else if (score > 80 && score <= 99){
            System.out.println("奖励奖励一台iphone 12");
        }else if (score >= 60 && score <= 80){
            System.out.println("奖励一个ipad");
        }
//        这个结构可写可不写，根据实际需求
//        else{
//            System.out.println("什么也没有");
        }
}

例题2：

编写程序，由键盘输入三个整数num1、num2、num3

对他们进行排列顺序，(使用 if-else if-else)，并且从小到大输出

/*
说明：
1.if-else结合是可以相互嵌套的
2.如果if-else结构中的执行语句只有一行时，对应的一对{}可以省略，但是，不建议省略
 */

import java.util.Scanner;
class IfTest2 {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入第一个整数：");
        int num1 = scanner.nextInt();
        System.out.println("请输入第二个整数：");
        int num2 = scanner.nextInt();
        System.out.println("请输入第三个整数：");
        int num3 = scanner.nextInt();

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

        }
    }
}

例题3：

我家的狗5岁了，五岁的狗相当于人类多大呢？其实狗的前两年每年增长相当于人类的10.5岁之后每增加一年就增加四岁，那么5岁的狗狗相当于人类的多大年龄呢？

编写一个程序，获取用户输入狗的年龄，通过程序显示相当于人类的年龄，

如果用户输入的是负数，则显示一个提示

class IfTest3 {
    public static void main(String[] args) {
        int dogAge = 6;
        if(dogAge >= 0 && dogAge <= 2){
            System.out.println("相当于人的年龄：" + dogAge * 10.5);
        }else if (dogAge > 2){
            System.out.println("相当于人类的年龄：" + (2 * 10.5 + (dogAge - 2) * 4));
        }else {
            System.out.println("狗狗还没有出生呢");
        }
    }
}

例题4：

假设你是想开发一个玩彩票的游戏，程序随机产生一个两位数的彩票，提示用户输入一个两位数；，然后按照下面的游戏规则判定用户是否能赢

1）如果用户输入的数匹配彩票的实际顺序，奖金10000美金

2）如果用户输入的所有数字匹配彩票的所有数字，但顺序不一致，奖金3000美金

3）如果用户输入的一个数字仅满足顺序情况下匹配彩票的一个数字，奖金1000美金

4）如果用户输入的一个数字仅满足非顺序情况下匹配彩票的一个数字，奖金500美元

5）如果用户输入的数字没有匹配任何一个数字，则彩票作废。

// 如何获取一个随机数
class IfTest4 {
    public static void main(String[] args) {
         int value = (int)(Math.random() * 90 + 10);// [0.0,1.0) --> [0.0,90.0) --> [0.0,90.0) --> [10.0,100.0) --> [10,99)
// 公式：[a,b] :(int)(Math.random() * (b - a + 1) + a)
        System.out.println(value);
    }
}

例题5：

大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，当然要提出一个条件:

高：180cm以上，富：财富1千万以上，帅：是

如果上面三个条件同时满足，则：我一定要嫁给他！

如果三个条件有为真的情况，则：嫁吧，比上不足，比下有余。

如果三个条件都不满足，则：不嫁！

注：例题而已，请勿当真，树立正确的三观！

import java.util.Scanner;


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

 方式一：
        Scanner scan = new Scanner(System.in);

        System.out.println("请输入你的身高：（cm）");
        int height = scan.nextInt();
        System.out.println("请输入你的财富：（千万）");
        double rich = scan.nextDouble();
        System.out.println("请输入你是否帅：（true/false）");
        boolean appearance = scan.nextBoolean();

        if (height >= 180 && rich >= 1000 && appearance){
            System.out.println("我一定要嫁给他！！");
        }else if(height >= 180 ||  rich >= 1000 || appearance){
            System.out.println("嫁吧，比上不足，比下有余");
        }else{
            System.out.println("不嫁！");
        }
    }


 方式二


        System.out.println("请输入你是否帅：（是/否）");
        String appearance = scan.next();
//  注意：equals 方法是判断括号内的字符串是否匹配的一种方法
        if (appearance.equals("是")) {
            System.out.println("我一定要嫁给他！！");
        } else {
            System.out.println("不嫁！");
        }
    }
}

三、switch-case语句

3.1 说明：

① 根据switch 表达式中的值，依次匹配各个case中的常量，一旦匹配成功，则进入相应case中
调用其执行语句。当调用完执行语句以后，则继续往下执行其他case结构中执行语句，真到遇到break
关键字或者switch - case结构末尾结束为止

② break，可以使用在switch - case 结构中，表示一旦执行到此关键字，就跳出switch-case结构

③ switch结构中的表达式，只能是如下的6种数据类型之一
（byte、short、char、int、枚举类型（JDK 5.0新增）string类型（JDK 7.0新增））

④ case之后只能声明常量，不能声明范围

⑤ break 关键字是可选的

⑥ default：相当于 if - else结构中的else
default结构是可选的。位置是灵活的

3.2 语句格式

switch(表达式){
case 常量1;
    执行语句1;
    break;

case 常量2;
    执行语句2;
    break;

default:
    执行语句n;
   

举例代码：

class SwitchCaseTest {
    public static void main(String[] args) {
        String season = "summer";
        switch (season) {

        case "spring":
            System.out.println("穿暖花开");
            break;
        case "summer":
            System.out.println("夏日炎炎");
            break;
        case "autumn":
            System.out.println("秋高气爽");
            break;
        case "winter":
            System.out.println("冬雪皑皑");
            break;
        default:
            System.out.println("输入有误");
        }
    }
}

例题1：

使用switch把小写类型的char型转换为大写，只转换a、b、c、d、e

其他的输出为“other”

提示：

String word = scan.next();

char c = word.charAt(0);

switch(c){}

import java.util.Scanner;          //导入从键盘输入的包

class SwitchCaseTest1 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in); //实例化

        System.out.println("请输入：");
        String name = scan.next();  // 调用方法来获取键盘输入的值
        char c = name.charAt(0);

        switch(c){
            case 'a':
                System.out.println("A");
                break;
            case 'b':
                System.out.println("B");
                break;
            case 'c':
                System.out.println("C");
                break;
            case 'd':
                System.out.println("D");
                break;
            case 'e':
                System.out.println("E");
                break;
            default:
                System.out.println("other");

        }
    }
}

例题2：

对学生成绩大于60分的，输出“合格”；低于60分的，输出“不合格”

/*
说明：如何switch - case 结构中的多个case的执行语句相同，则可以考虑进行合并(但是这不是新的知识)

这道题最优解是 score除60
*/
class SwitchCaseTest2 {
    public static void main(String[] args) {

        int score = 78;   //这里假设分数为78分
        
        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;
    }
  }
}

例题3：

根据用于指定月份，打印月份所属季节

3 4 5春季

6 7 8夏季

9 10 11秋季

12 1 2冬季

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

        int month = 4;
        switch (month){
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;
            case 12:
            case 1:
            case 2:
                System.out.println("冬季");
                break;
        }
    }
}

例题4：

输入年月日，计算这是当年的第几天。

import java.util.Scanner;

public class SwitchCaseTest5 {



        public static void main(String[] args) {
            Scanner scan = new Scanner(System.in);
            System.out.println("请输入year：");
            int year = scan.nextInt();
            System.out.println("请输入month：");
            int month = scan.nextInt();
            System.out.println("请输入day：");
            int day = scan.nextInt();


            int sumDays = 0;
            switch (month){
                case 12:
                    sumDays += 30;
                case 11:
                    sumDays += 31;
                case 10:
                    sumDays += 30;
                case 9:
                    sumDays += 31;
                case 8:
                    sumDays += 31;
                case 7:
                    sumDays += 30;
                case 6:
                    sumDays += 31;
                case 5:
                    sumDays += 30;
                case 4:
                    sumDays += 31;
                case 3:
                    // sumDays += 28;
                    //判断是否是闰年
                    if((year % 4 == 0 && year % 100 != 0) || year % 400 == 0){
                        sumDays +=29;
                    }else {
                        sumDays +=28;
                    }
                case 2:
                    sumDays += 31;
                case 1:
                    sumDays += day;
            }
            
           
            System.out.println(year + "年"  + month + "月" + day + "日是当年的第" + sumDays + "天"); 
   }
}

四、For循环语句

4.1 循环结构的四个要素

① 初始化条件

② 循环条件—（是boolean类型的）

③ 循环体

④ 迭代条件

4.2 for循环的结构

for(①;②;④){
    ③
}

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

例题1：

遍历100以内的偶数

记录所有偶数的和

输出偶数的个数

class ForTest1{
  public static void main(String[] args){
  
        int sum = 0
        int count = 0;
        for (int i = 1;i <= 100;i++){
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
                count ++;
            }
        }
        
        System.out.println("总数和为：" + sum);
        System.out.println("总个数为：" + count);
  }
}

例题2：

编写程序从1循环到150，并在每行打印一个值，

另外在每个3的倍数行上打印出“foo”，

在每个5的倍数行上打印“biz”，

在每个7的行数上打印“baz”

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

        for(int i = 1; i <= 150; i++){
            System.out.println(i + "");

            if (i % 3 == 0){
                System.out.print("foo");
            }
            if (i % 5 == 0){
                System.out.print("biz");
            }
            if(i % 7 == 0){
                System.out.print("baz");
            }

        }
    }
}

例题3：

输入两个正整数m和n，求其最大公约数和最小公倍数，

比如：12和20的最大公约数是4，最小公倍数是60

import java.util.Scanner;

class ForTest3 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);

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

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

        //获取最大公约数
        //1.获取两个数中较小的值
        int min = (m <= n)? m : n;
        //2.遍历
        for (int i = min;i >=1;i--){

            if(m % i == 0 && n % i == 0){

                System.out.println("最大公约数为："+ i);
                break;// 一但在循环中执行到break，就跳出循环

            }
        }
        //获取最小公倍数
        //1.获取两个数中的最大值
        int max = (m >= n) ? m : n;
        //2.遍历
        for(int i = max; i <= m * n; i++ ){

            if (i % m ==0 && i % n == 0){

                System.out.println("最小公倍数为："+ i);
                break;
            }
        }

    }
}

五、While循环语句

5.1 循环体的4个要素

① 初始化条件

② 循环条件 -->是boolean类型

③ 循环体

④ 迭代条件

5.2 while循环的结构

①
while(②){
    ③;
    ④;

执行过程：1-2-3-4-2-3-4-…-2

例题1：

遍历100 以内的所有偶数，计算总和及个数

/*
说明：
1.写while循环千万小心别丢了循环条件，一但丢了，就可能导致死循环
2.我们写程序，要避免出现死循环
3.for循环和while循环是可以互相转换的


算法：程序要有 有限性
 */



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

     // 遍历100 以内的所有偶数，计算总和及个数
         int sum = 0;
         int count = 0;
         int i= 1;
         while(i <= 100){

             if (i % 2 == 0){
                 System.out.println(i);
                 sum += i;
                 count ++;
             }
             i++;
         }
         System.out.println("总和为" + sum);
         System.out.println("个数为" + count);

     }
}

六、do-while循环语句

6.1 循环体的4个要素

① 初始化条件

② 循环条件 -->是boolean类型

③ 循环体

④ 迭代条件

6.2 do-while 循环结构

①
do{
    ②;
    ④;
}while(③);

执行顺序; 1-3-4-2-3-4-2-3-…-2

6.3 while循环和do-while循环的差异

class Test1{
    public static void main(String[] args){
        // while循环是先判断符不符合条件，再执行；但执行多次就没有区别了
        // int number1 = 10;
        int number1 = 15;
        while (number1 > 10){
            System.out.println("Hello While!");
            number1--;

        }

        // do-while是先执行一次do再判断while符不符合条件；但执行多次就没有区别了
        // int number2 = 10;
        int number2 = 15;
        do{
            System.out.println("Hello Do-While!");
            number2--;
        }while (number2 > 10);
    }
}

例题1：

遍历100以内的偶数，并计算所有偶数的和及个数

说明
/*
1.do-while至少会执行一次循环体
2.在开发中使用for 和 while循环更多一些，较少使用 do-while
 */

class DoWhileTest1 {
    public static void main(String[] args) {
    // 遍历100以内的偶数，并计算所有偶数的和及个数
        int sum = 0; // 记录总和
        int count = 0; // 记录个数
        int num = 1;
        do{
            if(num % 2 == 0){
                System.out.println(num);
                sum += num;
                count++;
            }
            num++;
        }while (num <= 100);

        System.out.println("总和为" + sum);
        System.out.println("个数为" + count);

七、特殊关键字

7.1 break 和 continue关键字的使用 ，

break：

适用范围：Switch - case 循环结构中；
在循环中使用：结束当前循环
关键字后面不能直接有执行语句的(两者相同)

continue ：

适用范围 循环结构中
在循环中使用：结束当次循环
关键字后面不能直接有执行语句的(两者相同)

public class BreakContinueTest {

    public static void main(String[] args) {
        for(int i = 1;i <= 10;i++){

            if(i % 4 == 0){
                //break;   // 用break 结束当前循环，所以结果为1 2 3
                continue;  // 用continue 结束本次循环，所以结果为 1 2 3 5 6 7 8 9 10

            }
            System.out.println(i);

        }
        System.out.println("\n");




        // ************************************
        for (int i = 1; i <= 4;i ++){

            label:for (int j = 1;j <= 10;j++){

                if (j % 4 == 0){
                   // break; // 这里break的跳出循环取得是就近原则
                   // continue;
                   // break label; // 结束指定标识的一层循环结构
                   // continue label: // 结束指定标识的一层循环结构的当次循环
                }
                System.out.print(j);
            }
            System.out.println();
        }
    }
}

八、嵌套循环

8.1嵌套循环要点

（1）
嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中，就构成了嵌套循环

（2）
外层循环：循环结构B
内层循环：循环结构A

（3）
①内层循环结构遍历一遍，只相当于外层循环的循环体执行一次。
②假设外层循环需要执行M次，内层循环需要执行N次，此时内层循环的循环体一共执行了M × N 次

（4）
外层循环控制行数，内层循环控制列数

    public static void main(String[] args) {
        /*
        1.输出：
        ******
        */
        for (int i = 1; i <= 6; i++){
            System.out.print("*");
        }
        System.out.println("\n");


        /*
        2.输出：
        ******
        ******
        ******
        ******
         */
    for (int j = 1; j <= 4; j++){
        for(int i = 1; i <= 6;i++){
            System.out.print("*");
        }
        System.out.println();   // 充当换行的作用

        }
        System.out.println("\n");



    /*
        3.输出
        *
        **
        ***
        ****
        *****
     */
    for (int i = 1;i <=5; i++){ // 控制行数
        for(int j = 1;j <= i;j++){ // 控制行数
            System.out.print("*");
        }
        System.out.println();
    }
        System.out.println("\n");



    /*
        4.输出
        *****
        ****
        ***
        **
        *
     */

    for (int i = 1;i <= 5; i++){
        for (int j = 1;j <= (6-i);j++){
            System.out.print("*");
        }
        System.out.println();

        }
    }

例题1

从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时的结果

/*
提示：
1.不在循环条件部分限制次数的结构； for(;;) 或者 while(true)
2.结束循环有几种方式？
    方式一：循环条件部分返回 false
    方式二：在循环体中执行break

 */


import java.util.Scanner;

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

        Scanner scan = new Scanner(System.in);

        System.out.println("请输入数字，中间用空格隔开：");

        int posttiveNumber = 0; // 记录正数的个数
        int negativeNumber = 0; // 记录负数的个数
        for (;;){
    //  while(true){

            int number = scan.nextInt();

            // 判断number的正负情况
            if(number > 0){
                posttiveNumber++;
            }else if(number < 0){
                negativeNumber++;
            }else {
                // 当两个数不大于，不小于，等于零时，就break，跳出循环
                break;
            }
        }
            System.out.println("正数有"+posttiveNumber+"个");
            System.out.println("负数有"+negativeNumber+"个");
    }
}

例题2

输出十万以内的质数的输出

方式一：

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

        int count = 0;

    boolean isFlag = true; // 标识i 是否被j除尽，一旦除尽，修改其值

    long start = System.currentTimeMillis(); //当前时间距离1970年的毫秒数

    for(int i = 2; i <= 100000;i++){ // 遍历100以内的自然数

        for (int j = 2; j <= Math.sqrt(i);j++){  // j:被i去除 优化二：给i开根号，优化后又减少10倍时间

            if(i % j == 0){ // i被j除尽
                isFlag = false;
               break; // 优化一：只对本身非质数的自然数是有效的。优化和不优化之间的运行时间相差10倍
            }
        }
        //
        if (isFlag == true){
            System.out.println(i);
            count ++;
        }
        //重置isFlag
        isFlag = true;


    }
        // 获取运行结束的毫秒数
        long end = System.currentTimeMillis();

        System.out.println("质数的个数为：" + count);

        System.out.println("所花费的时间是：" + (end - start) + "毫秒");
    }
}

方式二：

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

        int count = 0;

        long start = System.currentTimeMillis(); //当前时间距离1970年的毫秒数

        label:for(int i = 2; i <= 100000;i++){ // 遍历100以内的自然数

            for (int j = 2; j <= Math.sqrt(i);j++){  // j:被i去除 优化二：给i开根号，优化后又减少10倍时间

                if(i % j == 0){ // i被j除尽
                    continue label;
                    }
                }
            count++;

            }


        // 获取运行结束的毫秒数
        long end = System.currentTimeMillis();

        System.out.println("质数的个数为：" + count);

        System.out.println("所花费的时间是：" + (end - start) + "毫秒");
    }
}