Java入门第一章——编程语言基础：控制语句

咖啡加Ice

已于 2023-05-25 16:41:40 修改

阅读量240

点赞数

分类专栏：咖啡ice的Java学习记录文章标签： java 开发语言

于 2023-05-25 12:27:51 首次发布

本文链接：https://blog.csdn.net/weixin_46016581/article/details/130864670

版权

咖啡ice的Java学习记录专栏收录该内容

25 篇文章 0 订阅

订阅专栏

控制语句

*选择结构：if，if…else；switch

*循环结构：for；while；do…while

*控制循环的语句：break；continue

1.分支语句/条件控制语句：if，if…else

（1）if的语法结构：

第一种：


if(布尔表达式){
    //布尔表达式为true进入到这个分支
    java语句;
    java语句;
    java语句;
    ……
}

第二种：

if(布尔表达式){
    //布尔表达式true进入到这个分支
    java语句;
    ……
}else{
    //布尔表达式false进入到这个分支
    java语句;
    ……
}

第三种：

if(布尔表达式1){
    //布尔表达式1为true进入到这个分支
    java语句;
    ……
}else if(布尔表达式2){
    //布尔表达式2为true进入到这个分支
    java语句;
    ……
}else if(布尔表达式3){
    //布尔表达式3为true进入到这个分支
    java语句;
    ……
}……

第四种：

if(布尔表达式1){
    //布尔表达式1为true进入到这个分支
    java语句;
    ……
}else if(布尔表达式2){
    //布尔表达式2为true进入到这个分支
    java语句;
    ……
}else if(布尔表达式3){
    //布尔表达式3为true进入到这个分支
    java语句;
    ……
}……else{
    //所有if分支进不去，进入到这个分支
    java语句;
    ……
}

（2）对于java中的if语句来说，只要有一个分支执行，整个if语句全部结束。

（3）带有else分支可以保证一定会有分支执行。

（4）所有控制语句都是可以在合理情况下嵌套使用的。

if(){
    if(){……}
}else{
    if(){……}else{……}
}

注意：嵌套使用时候代码格式要保证完美，该缩进时候必须缩进。（方便看）

（5）当分支中只有一个语句时候，可以省略大括号，但是有多个语句的时候不能省略。

//写法一：if(布尔表达式) java语句; else java语句；
if(布尔表达式)
    java语句；
else 
    java语句；

练习需求1：所在位置的五公里范围内有肯德基的话，去KFC吃午饭

public class IfTest{
    public static void main(String[] args){
        
        //公里数
        double distance = 6.0;//单位km
        //判断
        if(distance < 5 ){
            System.out.println("去KFC吃午饭");
        }else{
            System.out.println("不去");
        }
    }
}

练习需求2：给一个成绩，成绩可能带小数点，根据学生成绩给等级[90-100]A；[80-90)B；[70-80)C；[60-70)D；[0-60)E。使用if语句完成

public class IfTest{
    public static void main(String[] args){
        double grade = 60; //成绩
        if(grade<0 || grade >100){
            System.out.println("您输入的成绩超出范围");
        }else if(grade>=90) {
            System.out.println("A");
        }else if(grade>=80){
            System.out.println("B");
        }else if(grade>=70){
            System.out.println("C");
        }else if(grade>=60){
            System.out.println("D");
        }else if(grade <60){
            System.out.println("E");
        }else{
            System.out.println("成绩输入错误");
        }
    }
}

练习需求3：给定一个人的年龄[0-150]，根据年龄判断人处于生命哪个阶段。[0-5]幼儿；[6-10]少儿；[11-18]青少年；[19-35]青年；[36-55]中年；[56-150]老年

写法1

import java.uitl.Scanner;
public class IfTest{
    public static void main(String[] args){
         Scanner sc = new Scanner(System.in);
        int age = sc.nextInt();
        if(age<0 ||age>150){
            System.out.println("提供的年龄不合法，要在[0-150]之间");
        }else if(age>=56){
            System.out.println("老年");
        }else if(age >= 36){
            System.out.println("中年");
        }else if(age >=19){
            System.out.println("青年");
        }else if(age >=11){
            System.out.println("青少年");
        }else if(age >=6){
            System.out.println("少儿");
        }else{
            System.out.println("幼儿");
        }
    }
}

写法2

import java.util.Scanner;
public class IfTest{
        Scanner sc = new Scanner(System.in);
        int age = sc.nextInt();
        String str;
        if(age<0 ||age>150){
            str = "没有这个年龄段";
        }else if(age>=56){
            str = "老年";
        }else if(age >= 36){
            str ="中年";
        }else if(age >=19){
            str ="青年";
        }else if(age >=11){
            str ="青少年";
        }else if(age >=6){
            str ="少儿";
        }else{
            str ="幼儿";
        }
        System.out.println(str);
}

接收用户键盘输入的方法：

*System.out.println(); 负责想控制台输出【从内存到控制台，输出的过程，这是从内存中出来了】

*接收用户键盘输入，从“键盘”到“内存”。【输入过程，到内存中去】

public class KeyInputTest{
    public static void main(String[] args){
        //创建键盘扫描器对象
        java.util.Scanner s = new java.util.Scanner(System.in);
        //调用Scanner对象的next方法开始接收用户键盘输入
        //程序执行到这里会停下来，等待用户输入，用户输入完成按Enter(回车)时，键入的信息会自动赋值给定义的变量。
        //语法格式：String userInputContent = s.next();
        int num = s.nextInt();
    }
}

另一种写法：

import java.util.Scanner;
public class KeyInputTest{
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        String userInputContent = s.next();
        //int num = s.nextInt();
    }
}

练习需求4：判断当前天气，当时下雨时候—>带雨伞—>判断性别？男带一把大黑伞：女带一把小花伞。

当晴天时候—>当天气温度在30度以上—>判断性别？男带墨镜：女擦防晒霜。

要求：天气状况、温度、性别从键盘输入。

import java.util.Scanner;
public class IfTest{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        String weather = sc.next();
        int temperature = sc.nextInt();
        String sex = sc.next();
        if(weather.equals("雨天")){
            if(sex.equals("男")){
                System.out.println("请带一把大黑伞");
            }else if(sex.equals("女")){
                System.out.println("请带一把小花伞");
            }else {
                System.out.println("性别有误");
            }
        }else if(weather.equals("晴天")){
            if(temperature >= 30){
                if(sex.equals("男")){
                    System.out.println("天气炎热，请戴墨镜");
                }else if(sex.equals("女")){
                    System.out.println("天气炎热，请擦防晒霜");
                }else {
                    System.out.println("性别有误");
                }
            }else {
                System.out.println("天气没有30度");
            }
        }else {
            System.out.println("输入的天气有误");
        }
    }
}

判断字符串相等办法：

由于String字符存储的是字面值的地址，直接用==来判断直接判断两个字符串的地址，这是错误的。如果要比较两个字符串中的值，需要用equals方法。

String a = "abc";
boolean b = a.equals("abc");
System.out.println(b); //true 这里是相等的

2.switch语句：switch属于选择结构，也是分支语句。

（1）语法规则（结构）：

switch("int"或"String"类型的字面值或变量){
    case "int"或"String"类型的字面值或变量:
        java语句;
        ……
        break;
    case "int"或"String"类型的字面值或变量:
        java语句;
        ……
        break;
     case "int"或"String"类型的字面值或变量:
        java语句;
        ……
        break;
     case ……
     default:
       java语句; 
       …… 
}

（2）switch后面小括号当中的"数据"与case后面的"数据"按照从上到下进行匹配，匹配成功的分支执行。

（3）分支当中最后有"break；"语句的话，整个switch语句终止。如果没有直接进入下一个分支执行（不进行匹配）。这种叫case穿透现象。

（4）所有分支都没有匹配成功，当有default语句，会执行default分支当中的程序。

（5）switch后面和case后面只能是int或者String类型，不能是其他类型。

*当然，byte，short，char也可以直接写到switch和case后面，因为它们可以进行自动类型转换为int类型。

（6）case可以合并

int i = 10;
switch(i){
     case1:case2:case3:case10:
        System.out.println("Test Code!");
}

（7）注意long类型不能直接使用到Switch后面

public class SwitchTest{
    public static void main(String[] args){
        long x = 100L;
        //switch(x){}  编译报错，跟 int a = x;类似，需要进行强制类型转换
        //解决编译错误
        switch((int)x){}
        
        byte a = 10;
        switch(a){}  //可以编译，byte，short，char都可以
        
        //编译报错
        //switch(true){}
        
        String username = "coffee add ice";
        switch(username){} //可以编译
        
    }
}

练习需求1：写一个较完整的switch语句。接收用户输入：1表示星期一，2表示星期二……7表示星期日。

import java.util.Scanner;
public class SwitchTest{
    public static void main(String[] args){
       Scanner sc = new Scanner(System.in);
       int weekday = sc.nextInt();
       switch (weekday){
           case 1:
               System.out.println("周一");
               break;
           case 2:
               System.out.println("周二");
               break;
           case 3:
               System.out.println("周三");
               break;
           case 4:
               System.out.println("周四");
               break;
           case 5:
               System.out.println("周五");
               break;
           case 6:
               System.out.println("周六");
               break;
           case 7:
               System.out.println("周日");
               break;
           default:
               System.out.println("输入有误");
       }
    }
}

练习需求2：反过来，用户输入星期一返回1，输入星期二返回2……输入星期日返回7

public class SwitchTest{
    public static void main(String[] args){
        java.util.Scanner sc = new java.util.Scanner(System.in);
       String dayOfWeek = sc.next();
       switch (dayOfWeek){
           case "周一": case "星期一":
               System.out.println(1);
               break;
           case "周二": case "星期二":
               System.out.println(2);
               break;
           case "周三": case "星期三":
               System.out.println(3);
               break;
           case "周四": case "星期四":
               System.out.println(4);
               break;
           case "周五": case "星期五":
               System.out.println(5);
               break;
           case "周六": case "星期六":
               System.out.println(6);
               break;
           case "周日": case "星期日":
               System.out.println(7);
               break;
           default:
               System.out.println("输入非法");
       }
    }
}

练习需求3：时间计算器中+，-，*，/，%。实现思路：数据从键盘输入，需要从控制台输入三次：第一个数字，运算符，第二个数字。

import java.util.Scanner;
public class SwitchTest{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("欢迎使用简单的计算机系统");
        System.out.print("请输入第一个数字：");
       int number1 = sc.nextInt();
        System.out.print("请输入运算符");
       String c = sc.next();
        System.out.print("请输入第二个数字：");
       int number2 = sc.nextInt();
       switch (c){
           case "+":
               System.out.println(number1 + c + number2 + "=" + (number1+number2));
               break;
           case "-":
               System.out.println(number1 + c + number2 + "=" + (number1-number2));
               break;
           case "*":
               System.out.println(number1 + c + number2 + "=" + (number1*number2));
               break;
           case "/":
               System.out.println(number1 + c + number2 + "=" + (number1/number2));
               break;
           case "%":
               System.out.println(number1 + c + number2 + "=" + (number1%number2));
               break;
           default:
               System.out.println("输入非法");
       }
    }
}

练习需求4：系统给定考生成绩，判断考生成绩等级。根据学生成绩[0-100]，成绩可能带小数：等级[90-100]A；[80-90)B；[70-80)C；[60-70)D；[0-60)E。采用switch语句完成。

import java.util.Scanner;
public class SwitchTest{
    public static void main(String[] args){
         Scanner sc = new Scanner(System.in);
       double score = sc.nextDouble();
       if(score>= 0 && score<=100){
           int scoreTen = (int) (score / 10);
           switch (scoreTen){
               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: case 10:
                   System.out.println("成绩为A");
           }
       }else {
           System.out.println("输入不合法");
       }
    }
}

3.for循环语句

*循环结构：将需要反复执行/重复执行的代码放到“循环体”中，联合计数器共同控制这段需要反复执行的代码。

*基本上所有编程语言支持的循环：for循环；while循环；do…while循环

（1）for循环的语法结构：

for( 初始表达式; 布尔表达式; 更新表达式 ){
    //需要重复执行的代码片段【循环体】
}

（2）for循环的执行过程/原理：

①初始化表达式、布尔表达式、更新表达式都不是必须的【但是两个分号是必须的】

②初始化表达式最先执行，并且在整个for循环当中只执行一次

③布尔表达式只能是true/false，不能是其他值

④for执行过程：先执行初始化表达式【只执行一次】

执行布尔表达式

若为true执行循环体，执行完循环体再执行更新表达式。再执行布尔表达式。

若为false结束。

public class ForTest{
    public static void main(String[] args){
        //打印输出1到10
        //写法一
        for(i=1;i<=10;i = i+1){
            System.out.println(i);
        }
        //写法二
        for(i=1;i<=10;i+=1){
            System.out.println(i);
        }
        //写法三
        for(i=1;i<=10;i++){
            System.out.println(i);
        }
        
        //死循环
        for(;;){
            System.out.println("死循环");
        }
    }
}

例子1：for循环中 “ i ” 【变量】的作用域

public class ForTest{
    public static void main(String[] args){
        //一下所有for循环中"i"变量作用域仅限于当前for循环内部使用
        for(int i = 0;i<10;i++){
            System.out.println("i->" + i);//打印了0到9
        }
         for(int i = 0;i<=10;i++){
            System.out.println("i-->" + i);//打印了0到10
        }
        //变量i作用域是for，在main方法中就不可访问
        //System.out.println("i=" + i);  这句在这里就会编译错误，找不到i
        
        //也可以在main方法中定义
        int i =0;
        for(;i<10;i++){
            System.out.println("i=" + i);//打印了0到9
        }
        System.out.println("i===>" + i);  //在经过循环后，i为10
    }
}

例子2：for循环常规写法

public class FortTest{
    public static void main(String[] args){
        //输出1~10中奇数
        for(int i=1;i<=10;i+=2){
            System.out.println(i);//1 3 5 7 9
        }
        //输出1~10中偶数
        for(int i=2;i<=10;i+=2){
            System.out.println(i);//2 4 6 8 10
        }
        //倒着写
        for(int i=10;i>0;i--){
            System.out.println(i);//10 9 8 7 6 5 4 3 2 1
        }
         for(int i=100;i>=50;i-=10){
            System.out.println(i);//100 90 80 70 60 50
        }
        //把i++【更新表达式】写到for循环里边
        for(int i=0;i<10;){
            System.out.println(i);//0 1 2 3 4 5 6 7 8 9
            i++;
        }
        
        //死循环
         for(int i=0;i<10;){
            System.out.println(i);
        }
    }
}

例子3：循环语句和条件判断语句嵌套使用【for和if嵌套】

public class ForTest{
    public static void main(String[] args){
        //需求：找出1~100所有奇数
        //方案一：从1开始，每次递增2
        for(int i =1;i<=100;i+=2){
            System.out.println(i);
        }
        //方案二：从1开始，以1递增，每个数据都进行判断【判断标准：数字对2求余数】
        for(int i =1;i<=100;i++){
            //判断i是否为奇数，是奇数输出
            //i%2 == 0为偶数
            //i%2 == 1为奇数
            //i%2 != 0为奇数
            if(i % 2 == 1){
                System.out.println(i);
            }
        }
    }
}

练习需求1：计算1~100所有奇数的和

public class ForTest{
    public static void main(String[] args){
        //运算符+=
        //定义一个变量【盒子】，初始值为0；
        int num = 0;
        for(int i =1;i<=100;i+=2){
            num = num +i;
            //也可以写成： num += i;
        }
        System.out.println(num);
    }
}

练习需求2：for循环嵌套for循环

public class ForTest{
    public static void main(String[] args){
        for(int i =1;i<=10;i++){
            //循环体重可以编写其他的控制语句
            //控制语句可以嵌套使用：if,if...else，switch,for……
            //for(int i =1;i<=10;i++){}  这里会编译错误，在for里边已经定义了i，不能在这里再定义一个i。
            for(int j =1 ;j<=10;j++){
                System.out.println(i*j);//执行了10【i】*10【j】= 100次
            }
        }
    }
}

练习需求3：使用for循环输出一个九九乘法表

public class ForTest{
    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('\n');
        }
    }
}

4.while和do…while循环

（1）while语法结构

while(布尔表达式){  //布尔表达式结果为true进入循环体，false循环结束
    循环体;
}

（2）while执行原理

先判断布尔表达式：

*true：执行循环体，重新判断布尔表达式

*false：循环结束

（3）while的循环次数

*0~N次，while循环的循环体可能一次都不执行

public class WhileTest{
    public static void main(String[] args){
        //死循环
        while(true){
            System.out.println("a");
        }
        System.out.println("coffee add ice"); //编译错误。由于上面的循环是死循环，编译到不了这一句
        
        //————————————分割线——————————————————————————————————————
        //下面重新起一个
        int i =10;
        int j = 3;
        while(i>j){//这个也是死循环
            Sysetm.out.println("a");/
        }
        System.out.println("coffee add ice");//上面是死循环，这里也编译不到这一句
    }
}

例子1：使用while循环输出1~10

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

例子2：比较while不同写法

public class WhileTest{
    public static void main(String[] args){
        int i =10;
        while(i>0){
            System.out.print(i-- + " "); //10 9 8 7 6 5 4 3 2 1

        }
        System.out.print('\n');
        System.out.println(i); //0
        System.out.println("---------");

        int j =10;
        while(j >=0){
            System.out.print(--j + " "); //9 8 7 6 5 4 3 2 1 0 -1
        }
        System.out.print('\n');
        System.out.println(j); //-1
        }
    }
}

（3）do…while

语法结构

do{
    循环体
}while(布尔表达式);

循环次数1~N次，至少一次。do…while最终有分号。也就是do会先做再循环。

public class DoWhileTest{
    public static void main(String[] args){
        int i = 10;
        do{
            System.out.println(i);
        }while(i>100);//这里会输出一个10再结束
        
        while(i>100){//这里直接结束
            System.out.println(i);
        }
        
        int j = 1;
        do{
            System.out.println(j);//1 2 3 4 5
            ++j;
        }while(j <=5);
    }
}

5.控制循环语句break

（1）break：在java中的关键字，翻译为“中断”。语法规则：break;

（2）break可以使用在switch语句中，用来终止switch语句执行，也可以使用在循环语句中，终止循环执行。

（3）break：使用在for,while，do…while循环语句用来跳出循环，终止循环执行。当程序循环到某个条件时，后续没必要继续执行。

（4）默认情况下，break语句终止它最近的循环语句

例子1：for循环

public class BreakTest{
    public static void main(String[] args){
        for(int i =0;;i++){ //这里布尔表达式不写表示这是个死循环
            if(i==5){
                break;
            }
            System.out.println(i); //0 1 2 3 4 
        }
        
        System.out.println("coffee add ice");//由于i=5就break，所以这句话能打印。
    }
}

例子2：嵌套for

public class BreakTest{
    public static void main(String[] args){
        for(int i=0;i<3;i++){
           for(int j=0;j<10;j++){
               if(j==5){
                   break;
               }
               System.out.print(j + " "); //0 1 2 3 4 0 1 2 3 4 0 1 2 3 4
           }
       }
    }
}

例子3：给for起名字

public class BreakTest{
    public static void main(String[] args){
        for1:for(int i=0;i<3;i++){
           for2:for(int j=0;j<10;j++){
               if(j==5){
                   break for1;
               }
               System.out.print(j + " "); //0 1 2 3 4
           }
       }
    }
}

6.控制循环语句continue

（1）continue表示：继续/go on /下一个

（2）continue也是一个关键字加一个分号，语法规则：continue;

（3）break和continue区别：

*break：所有循环终止，直接跳出循环。

*continue：本次循环终止，进行下一次循环。

public class ContinueTest{
    public static void main(String[] args){
        for(int i =1;i<=10;i++){
           if(i == 5){
               break;
           }
           System.out.print(i + " ");  // 1 2 3 4
       }
        System.out.println("\n-----------------");
       for (int j =1;j<=10;j++){
           if(j == 5){
               continue; //跳过当前的本次循环，进入下一次循环“继续”执行
           }
           System.out.print(j + " "); // 1 2 3 4 6 7 8 9 10
       }
    }
}

例子1：continue也可制定for循环名称

public class ContinueTest{
    public static void main(String[] args){
        for1:for(int i=1;i<=3;i++){
            for2:for(int j =1;j<=5;j++){
                if(j == 3){
                    continue for1;
                }
                System.out.print(j + " ");//1 2 1 2 1 2
            }
        }
    }
}