Java的控制语句

最新推荐文章于 2024-02-28 15:41:06 发布

学无止路

最新推荐文章于 2024-02-28 15:41:06 发布

阅读量429

点赞数 1

分类专栏： JavaSe 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/weixin_40055163/article/details/122451241

版权

JavaSe 专栏收录该内容

58 篇文章 16 订阅

订阅专栏

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。
控制语句分为三类：顺序、选择和循环。“顺序结构”代表“先执行 a，再执行 b”的逻辑。
比如，先找个女朋友，再给女朋友打电话；先订婚，再结婚； “条件判断结构”代表“如果…，则…”的逻辑。
比如，如果女朋友来电，则迅速接电话；如果看到红灯，则停车； “循环结构”代表“如果…，则重复执行…”的逻辑。
比如，如果没打通女朋友电话，则再继续打一次；如果没找到喜欢的人，则再继续找。顺序结构即按照书写顺序执行每一条语句，比较简单，不是我们的重点。
本章研究的重点是“选择结构”和“循环结构”。很神奇的是，三种流程控制语句就能表示所有的事情！不信，你可以试试拆分你遇到的各种事情。
实际上，任何软件和程序，小到一个练习，大到一个操作系统，本质上都是由“变量、选择语句、循环语句”组成。
这三种基本逻辑结构是相互支撑的，它们共同构成了算法的基本结构，无论怎样复杂的逻辑结构，都可以通过它们来表达。上述两种结构组成的程序可以解决全部的问题，所以任何一种高级语言都具备上述两种结构。
因此，本章是大家真正跨入编程界的“门槛”，是成为“程序猿”的“门票”。本章后面会附加大量的练习，供大家提升自我。

1.1 条件判断结构

在还没有知道 Java 选择结构的时候，我们编写的程序总是从程序入口开始，顺序执行每一条语句直到执行完最后一条语句结束，但是生活中经常需要进行条件判断，根据判断结果决定是否做一件事情，这就需要选择结构。
选择结构用于判断给定的条件，然后根据判断的结果来控制程序的流程。主要的条件判断结构有：if 结构和 switch 结构。而 if 结构又可以分为 if 单分支结构、if-else 双分支结构、 if-else if-else 多分支结构。

1.1.1 if 单分支结构

语法结构:

  if(布尔表达式){
  		 语句块 
  }

if 语句对布尔表达式进行一次判定，若判定为真，则执行{}中的语句块，否则跳过该语句块。流程图所示。在这里插入图片描述

if 单分支结构（掷骰子游戏）的代码如下：

package com.txw;

/**
 * 掷骰子游戏
 * @author Adair
 * @qq:1578533828@qq.com
 */
@SuppressWarnings("all")   // 注解警告信息
public class DiceGame {
    public static void main(String[] args) {
        // 通过掷三个骰子看看今天的手气如何
        // 通过Math.random()产生随机数
        int i = (int) ((6 * Math.random()) + 1);
        int j = (int) ((6 * Math.random()) + 1);
        int k = (int) ((6 * Math.random()) + 1);
        int count = i + j + k;
        // 如果三个骰子之和大于 15，则手气不错
        if (count > 15){
            System.out.println("今天手气不错");
        }
        // 如果三个骰子之和在 10 到 15 之间，则手气一般
        if (count >= 10 && count <= 15){  // 错误写法：10<=count<=15
            System.out.println("今天手气一般");
        }
        // 如果三个骰子之和小于 10，则手气不怎么样
        if (count < 10){
            System.out.println("今天手气不怎么样");
        }
        System.out.println("第一个骰子："+ i + "，第二个骰子："+ j +"，第三个骰子："+ k +"，一共得了："+ count + "分。");
    }
}

如图所示：在这里插入图片描述

Math 类的使用：
1.java.lang 包中的 Math 类提供了一些用于数学计算的方法。 
2. Math.random()该方法用于产生 0 到 1 区间的 double 类型的随机数，但是不包括 1。 int i = (int) (6 * Math.random()); //产生：[0，5]之间的随机整数

新手雷区：
1.如果 if 语句不写{}，则只能作用于后面的第一条语句。
2. 强烈建议，任何时候都写上{}，即使里面只有一句话！

1.1.2 if-else 双分支结构

语法结构:

if(布尔表达式){ 
	语句块 1 
	}else{ 
	 语句块 2
	 }

当布尔表达式为真时，执行语句块1，否则，执行语句块 2。也就是else部分。流程图所示：在这里插入图片描述
1.if-else 双分支结构的代码如下：

package com.txw;

/**
 * 圆面积
 * @author Adair
 * @qq:1578533828@qq.com
 */
@SuppressWarnings("all")   // 注解警告信息
public class Circle {
    public static void main(String[] args) {
       // 随机产生一个[0.0, 4.0)区间的半径，并根据半径求圆的面积和周长
        double r = 4 * Math.random();
        // Math.pow(r, 2)求半径r的平方
        double area = 3.14 * r;
        double circle = 2 * Math.PI * r;
        System.out.println("半径为： " + r);
        System.out.println("面积为： " + area);
        System.out.println("周长为： " + circle);
        // 如果面积>=周长，则输出"面积大于等于周长"，否则，输出周长大于面积
        if(area >= circle) {
            System.out.println("面积大于等于周长");
        } else {
            System.out.println("周长大于面积");
        }
    }
}

如图所示：在这里插入图片描述
2.if-else 与条件运算符的比较：使用 if-else的代码如下:

package com.txw;

/**
 * if-else 与条件运算符的比较：使用 if-else
 * @author Adair
 * @date 2022/1/12 0012下午 2:32
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   // 注解警告信息
public class Test01 {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;
        int c2 = 0;
        if (a < b ){
            c2 = b;
        }else {
            c2 = a;
        }
        System.out.println(c2);
    }
}

如图所示：在这里插入图片描述
3.if-else 与条件运算符的比较：使用条件运算符的代码如下:

package com.txw;

/**
 * if-else 与条件运算符的比较：使用条件运算符
 * @author Adair
 * @date 2022/1/12 下午 2:40
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   // 注解警告信息
public class Test02 {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;
        // 返回a和b的最大值
        int c = a < b ? b : a;
        System.out.println(c);
    }
}

如图所示：在这里插入图片描述

1.1.3 if-else if-else 多分支结构

语法结构：
if(布尔表达式 1) {
	 语句块 1; 
   } else if(布尔表达式 2) {
     语句块 2; 
   }…… else if(布尔表达式 n){ 
     语句块 n; 
   } else { 
     语句块 n+1; 
}

当布尔表达式 1 为真时，执行语句块 1；否则，判断布尔表达式 2，当布尔表达式 2 为真时，执行语句块 2；否则，继续判断布尔表达式 3······；如果 1~n 个布尔表达式均判定为假时，则执行语句块 n+1，也就是 else 部分。流程图如图所示。
在这里插入图片描述
1.if-else if-else 多分支结构的代码如下：

package com.txw;

/**
 * if-else if-else 多分支结构
 * @author Adair
 * @date 2022/1/12 0012下午 3:14
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")    // 注解警告信息
public class Test03 {
    public static void main(String[] args) {
        int age = (int) (100 * Math.random());
        System.out.print("年龄是" + age + "， 属于");
        // 15 岁以下儿童；15-24 青年；25-44 中年；45-64 中老年；65-84 老年；85 以上老 寿星
        if (age < 15) {
            System.out.println("儿童， 喜欢玩！");
        } else if (age < 25) {
            System.out.println("青年， 要学习！");
        } else if (age < 45) {
            System.out.println("中年， 要工作！");
        } else if (age < 65) {
            System.out.println("中老年， 要补钙！");
        } else if (age < 85) {
            System.out.println("老年， 多运动！");
        } else {
            System.out.println("老寿星， 古来稀！");
        }
    }
}

如图所示：在这里插入图片描述

1.2 switch 语句

语法结构： 
switch (表达式) { 
	case 值 1: 
	  语句序列 1; 
	[break];
	case 值 2: 
	  语句序列 2; 
	[break]; 
	… … … … … [default: 
	默认语句;]
}

switch 语句会根据表达式的值从相匹配的 case 标签处开始执行，一直执行到 break 语句处或者是 switch 语句的末尾。如果表达式的值与任一 case 值不匹配，则进入 default 语句（如果存在 default 语句的情况）。
根据表达式值的不同可以执行许多不同的操作。switch 语句中 case 标签在 JDK1.5 之前必须是整数（long 类型除外）或者枚举，不能是字符串，在 JDK1.7 之后允许使用字符串(String)。
大家要注意，当布尔表达式是等值判断的情况，可以使用 if-else if-else 多分支结构或者 switch 结构，如果布尔表达式区间判断的情况，则只能使用 if-else if-else 多分支结构。
switch 多分支结构的流程图如图所示:
在这里插入图片描述
练习一的代码如下：

package com.txw.witch;

/**
 * 练习一
 * @author Adair
 * @date 2022/1/12 下午 4:02
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   // 注解警告信息
public class Test01 {
    public static void main(String[] args) {
        // grade 表示大学年级
        int grade = 1 ;
        if (grade == 1){
            System.out.println("大学一年级，可以放松一下，学着谈谈恋 爱");
        }else if (grade == 2){
            System.out.println("大学二年级，少玩点游戏，不空虚，不慌 嘛？");
        }else  if (grade == 3){
            System.out.println("大学三年级，专业课开始了，好好学，找 份好工作");
        }else{
            System.out.println("大四了，要毕业了。因为跟着大佬学习， 好工作搞定！");
        }
        switch (grade){
            case 1:
                System.out.println("大学一年级");
                break;
            case 2:
                System.out.println("大学二年级");
                break;
            case 3:
                System.out.println("大学三年级");
                break;
            default:
                System.out.println("大四了，要毕业了");
                break;
        }
    }
}

如图所示：在这里插入图片描述
练习二的代码如下：

package com.txw.witch;

/**
 * 练习二
 * @author Adair
 * @date 2022/1/12 下午 4:15
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   // 注解警告信息
public class Test02 {
    public static void main(String[] args){
        int month = 2;  // 1 表示 1 月，2 表示 2 月，....
        if(month == 1 || month == 2 || month == 3){
            System.out.println("春季");
        }else if( month == 4 || month == 5 || month == 6){
            System.out.println("夏季");
        }else if( month == 7 || month == 8 || month == 9){
            System.out.println("秋季");
        }else{
            System.out.println("冬季");
        }
        System.out.println("========使用 switch 改造上面的代码，switch 特别适合多值判断 =============");
        switch (month){
            case 1:
            case 2:
            case 3:
                System.out.println("春季");
            break;
            case 4:
            case 5:
            case 6:
                System.out.println("夏季");
            break;
            case 7:
            case 8:
            case 9:
                System.out.println("秋季");
            break;
            default:
                System.out.println("冬季");
        }
    }
}

如图所示：在这里插入图片描述
练习三的代码如下：

package com.txw.witch;

/**
 * 练习三
 * @author Adair
 * @date 2022/1/12 下午 4:32
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   // 注解警告信息
public class Test03 {
    public static void main(String[] args) {
        String str = "audi";
        switch (str){
            case "audi":
                System.out.println("我买了个奥迪车");
                break;
            case "benz":
                System.out.println("我买了个奔驰车");
                break;
            default:
                System.out.println("比亚迪，挺好！");
        }
    }
}

如图所示：在这里插入图片描述

1.3 循环结构(while)

循环结构分两大类，一类是当型，一类是直到型。
1.当型：当布尔表达式条件为 true 时，反复执行某语句，当布尔表达式的值为 false 时才停止循环，比如：while 与 for 循环。 2.直到型：先执行某语句，再判断布尔表达式，如果为 true，再执行某语句，如此反复，直到布尔表达式条件为 false 时才停止循环，比如 do-while 循环。

1.3.1 while 循环

语法结构：

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

在循环刚开始时，会计算一次“布尔表达式”的值，若条件为真，执行循环体。而对于后来每一次额外的循环，都会在开始前重新计算一次。
语句中应有使循环趋向于结束的语句，否则会出现无限循环–––"死"循环。 while 循环结构流程图如图所示: 在这里插入图片描述
while 循环结构：求 1 到 100 之间的累加和的代码如下：

package com.txw.hile;

/**
 * 练习一
 * @author Adair
 * @date 2022/1/13 下午 8:52
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   // 注解警告信息
public class Test01 {
    public static void main(String[] args) {
        int i = 1;
        int sum = 0;
        // 1+2+3+...+100
        while (i <= 100){
            sum += i;   // 相当于 sum = sum + i;
            i ++;
        }
        System.out.println(sum);
    }
}

如图所示：在这里插入图片描述

1.3.2 do-while 循环

语法结构：

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

do-while 循环结构会先执行循环体，然后再判断布尔表达式的值，若条件为真，执行循环体，当条件为假时结束循环。do-while 循环的循环体至少执行一次。do-while 循环结构流程图如图所示：在这里插入图片描述
do-while 循环结构：求 1-100 之间的累加和的代码如下：

package com.txw.hile;

/**
 * do-while 循环结构：求 1-100 之间的累加和
 * @author Adair
 * @date 2022/1/13 上午 9:02
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   // 注解警告信息
public class Test02 {
    public static void main(String[] args) {
        int i = 1;
        int sum = 0;
        do{
            sum += i;
            i ++;
        }while (i <= 100);   // 此处的；不能省略
        System.out.println("sum= " + sum);
    }
}

如图所示：在这里插入图片描述
while 与 do-while 的区别的代码如下：

package com.txw.hile;

/**
 * while 与 do-while 的区别
 * @author Adair
 * @date 2022/1/13 上午 9:06
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   // 注解警告信息
public class Test03 {
    public static void main(String[] args) {
        // while 循环：先判断再执行
        int i = 0;
        while (i < 0){
            System.out.println(i);
            i ++;
        }
        System.out.println("-----");
        // do-while 循环：先执行再判断
        i = 0;
        do {
            System.out.println(i);
            i ++;
        }while (i < 0);
    }
}

如图所示：在这里插入图片描述
练习一的代码如下：

package com.txw.hile;

/**
 * 练习题
 * @author Adair
 * @date 2022/1/13 下午 2:50
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   // 注解警告信息
public class test18 {
    public static void main(String[] args) {
        /**
         * 1.使用while循环：计算1-100之间所有数字的和，所有偶数的和，所有奇数的和。
         */
        int i = 0;
        int sun = 0;
        // 奇数的和
        int sunOld = 0;
        // 偶数的和
        int sunEven = 0;
        while (i <= 100){
            sun =  sun + i;
            if (i % 2 ==0){
                sunOld +=sun;
            }else{
                sunEven += sun;
            }
            i ++;
        }
        System.out.println("1-100的和是" + sun);
        System.out.println("1-100偶数的和是" + sunEven);
        System.out.println("1-100奇数的和是" + sunOld);
    }
}

如图所示：在这里插入图片描述
练习二的代码如下：

package com.txw.hile;

/**
 * @author Adair
 * @date 2022/1/13 上午 11:33
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   // 注解警告信息
public class Test15 {
    public static void main(String[] args) {
        /**
         * 2.使用while循环0-120之间的数字，打印出能被5整除的数字。
         */
        int i = 0;
        while (i <= 120){
            if (i % 5 ==0){
                System.out.println("能被5整除的数字是"+ i);
            }
            i ++;
        }
    }
}

如图所示：在这里插入图片描述
练习三的代码如下：

package com.txw.hile;

/**
 * @author Adair
 * @date 2022/1/13 下午 1:44
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   // 注解警告信息
public class Test16 {
    public static void main(String[] args) {
        /**
         * 3.使用while循环0-130之间的数字，每行显示7个数字。
         */
        int i = 0;
        while (i <= 130){
            System.out.print(i + "\t");
            if ((i + 1) % 7 == 0){
                System.out.println();
            }
            i ++;
        }
    }
}

如图所示：在这里插入图片描述

1.4 循环结构(for)

语法结构：

for (初始表达式; 布尔表达式; 迭代因子) { 
	循环体;
}

第一次反复之前要进行初始化，即执行初始表达式；随后，对布尔表达式进行判定，若判定结果为 true，则执行循环体，否则，终止循环；最后在每一次反复的时候，进行某种形式的“步进”，即执行迭代因子。
1.初始化部分设置循环变量的初值。
2.条件判断部分为任意布尔表达式。
3.迭代因子控制循环变量的增减 for 循环在执行条件判定后，先执行的循环体部分，再执行步进。
for 循环结构的流程图如图所示：在这里插入图片描述
for 循环的代码如下：

package com.txw.hile;

/**
 * for循环
 * @author Adair
 * @date 2022/1/13 上午 9:15
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   // 注解警告信息
public class test04 {
    public static void main(String[] args) {
        int sum = 0;
        // 1.求 1-100 之间的累加和
        for (int i = 0; i <= 100; i ++) {
            sum += i;
        }
        System.out.println("Sum= " + sum);
        // 2.循环输出9-1之间的数
        for(int i = 9;i > 0;i --){
            System.out.print(i + "、");
        }
        System.out.println();
        // 3.输出90-1之间能被3整除的数
        for( int i = 90;i > 0;i -= 3){
            System.out.print(i + "、");
        }
        System.out.println();
    }
}

如图所示：
在这里插入图片描述
Java 里能用到逗号运算符的地方屈指可数，其中一处就是 for 循环的控制表达式。在控制表达式的初始化和步进控制部分，我们可以使用一系列由逗号分隔的表达式，而且那些表达式均会独立执行。
逗号运算符的代码如下：

package com.txw.hile;

/**
 * 逗号运算符
 * @author Adair
 * @date 2022/1/13 上午 9:21
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   // 注解警告信息
public class test05 {
    public static void main(String[] args) {
        for (int i = 1, j = i + 10; i < 5; i ++, j = i * 2){
            System.out.println("i= " + i + " j= " + j);
        }
    }
}

如图所示：在这里插入图片描述
1.无论在初始化还是在步进部分，语句都是顺序执行的。
2.尽管初始化部分可设置任意数量的定义，但都属于同一类型。
3.约定:只在 for 语句的控制表达式中写入与循环变量初始化，条件判断和迭代因子相关的表达式。
初始化部分、条件判断部分和迭代因子可以为空语句，但必须以“;”分开。
无限循环的代码如下:

package com.txw.hile;

/**
 * 无限循环
 * @author Adair
 * @date 2022/1/13 上午 9:25
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   // 注解警告信息
public class Test06 {
    public static void main(String[] args) {
        for (;;){   // 死循环 相当于 while(true)
            System.out.println("学无止路");
        }
    }
}

如图所示：在这里插入图片描述
编译器将 while(true)与 for(;;)看作同一回事，都指的是无限循环。
在 for 语句的初始化部分声明的变量，其作用域为整个 for 循环体，不能在循环外部使用该变量。
初始化变量的作用域的代码如下：

package com.txw.hile;

/**
 * 初始化变量的作用域
 * @author Adair
 * @date 2022/1/13 上午 9:28
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   // 注解警告信息
public class Test07 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i ++) {
            System.out.println(i + "、");
        }
      // System.out.println(i);  // 编译错误，无法访问在 for 循环中定义的变量 i
    }
}

如图所示：在这里插入图片描述
练习题的代码如下：

package com.txw.hile;

/**
 * 1.使用for循环，倒序打印出1-100之间的数字
 * 2.使用for循环，打印出从a-z的26个字母。
 * @author Adair
 * @date 2022/1/13 0013下午 3:33
 * @email 1578533828@qq.com
 */
public class Test19 {
    public static void main(String[] args) {
        for (int i = 100; i >= 1; i--) {
            System.out.println(i);
        }

        char cc='a';
        for(int i = 0; i < 26; i ++) {
            // 强制类型转化
            char dd=(char)(cc + i);
            System.out.println(dd +"\t");
        }
    }
}

如图所示：在这里插入图片描述

1.5 嵌套循环

在一个循环语句内部再嵌套一个或多个循环，称为嵌套循环。while、do-while 与 for 循环可以任意嵌套多层。一般工作中多见的就是两层。
嵌套循环的代码如下：

package com.txw.hile;

/**
 * 嵌套循环
 * @author Adair
 * @date 2022/1/13 上午 9:33
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all") // 注解警告信息
public class Test08 {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                System.out.print(i + " ");
            }
            System.out.println();
        }
    }
}

如图所示：在这里插入图片描述
使用嵌套循环实现九九乘法表的代码如下：

package com.txw.hile;

/**
 * 使用嵌套循环实现九九乘法表
 * @author Adair
 * @date 2022/1/13 上午 9:36
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   // 注解警告信息
public class Test09 {
    public static void main(String[] args) {
        for (int i = 1; i < 10; i ++) {
            for (int j = 1; j <= i; j ++){
                System.out.print(j + "*" + i + "=" + (i * j < 10 ? (" " + i * j) : i * j) + " ");
            }
            System.out.println();
        }
    }
}

如图所示：在这里插入图片描述

1.6 break 语句和 continue 语句

在任何循环语句的主体部分，均可用 break 控制循环的流程。break 用于强行退出循环，不执行循环中剩余的语句。
break 语句的代码如下：

package com.txw.hile;

/**
 * 产生100以内的随机数，直到随机数为88时终止循环
 * @author Adair
 * @date 2022/1/13 上午 9:41
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   // 注解警告信息
public class Test10 {
    public static void main(String[] args) {
        // 定义计数器
        int total = 0;
        System.out.println("Begin");
        while (true) {
            total ++;   // 每循环一次计数器加1
            int i = (int) Math.round(100 * Math.random());
            // 当i等于88时，退出循环
            if (i == 88) {
                break;
            }
        }
        // 输出循环的次数
        System.out.println("Game over， used " + total + " times.");
    }
}

如图所示：在这里插入图片描述
continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

注意事项：
1.continue 用在 while，do-while 中，continue 语句立刻跳到循环首部，越过了当前循 环的其余部分。 
2.continue 用在 for 循环中，跳到 for 循环的迭代因子部分。

continue 语句的代码如下：

package com.txw.hile;

/**
 * 把100~150之间不能被3整除的数输出，并且每行输出5个
 * @author Adair
 * @date 2022/1/13 上午 9:48
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")  // 注解警告信息
public class Test11 {
    public static void main(String[] args) {
        // 定义计算器
        int count = 0;
        for (int i = 100; i < 150; i++) {
            // 如果是3的倍数，则跳过本次循环，继续进行下一次循环
            if (i % 3 == 0){
                continue;
            }
            // 否则（不是3的倍数），输出该数
            System.out.print(i + "、");
            count++; // 没输出一个数，计数器加1
            // 根据计数器判断每行是否已经输出了5个数
            if (count % 5 == 0) {
                System.out.println();
            }
        }
    }
}

如图所示：在这里插入图片描述
带标签的 break 语句和 continue 语句 goto 关键字很早就在程序设计语言中出现。尽管 goto 仍是 Java 的一个保留字，但并未在 Java 语言中得到正式使用；Java 没有 goto 语句。然而，在 break 和 continue 这两个关键字的身上，我们仍然能看出一些 goto 的影子—带标签的 break 和 continue。 “
标签”是指后面跟一个冒号的标识符，例如：“label:”。对 Java 来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于 break 和 continue 关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。
在 “goto 有害”论中，最有问题的就是标签，而非 goto，随着标签在一个程序里数量的增多，产生错误的机会也越来越多。但 Java 标签不会造成这方面的问题，因为它们的活动场所已被限死，不可通过特别的方式到处传递程序的控制权。由此也引出了一个有趣的问题：通过限制语句的能力，反而能使一项语言特性更加有用。
带标签的 break 和 continue的代码如下：

package com.txw.hile;

/**
 * 控制嵌套循环跳转(打印101-150之间所有的质数)
 * @author Adair
 * @date 2022/1/13 上午 9:54
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   // 注解警告信息
public class Test12 {
    public static void main(String[] args) {
        outer: for (int i = 101; i < 150; i ++) {
        for (int j = 2; j < i / 2; j ++) {
            if (i % j == 0){
                continue outer;
            }
        }
        System.out.print(i + " ");
       }
    }
}

如图所示：在这里插入图片描述
练习一的代码如下：

package com.txw.hile;

import java.util.Scanner;
/**
 * 1.薪水计算器（学会思考，学会如何百度：尽量将上下文中相关的关键词都输入）：
 * (1) 通过键盘输入用户的月薪，每年是几个月薪水。
 * (2) 输出用户的年薪
 * (3) 输出一行字“如果年薪超过10万，恭喜你超越90%的国人”，“如果年薪超过20万，恭喜你超越98%的国人”。
 * (4) 直到键盘输入”exit”（也可以用数字 88 代替），则退出程序（使用 break 退出 循环）
 * (5) 输入中途，键盘输入“next”（也可以用数字 66 代替），则这个用户退出计算不 显示“恭喜..”，直接显示“重新开始计算...”，然后算下一个用户的年薪。
 * @author Adair
 * @date 2022/1/13 下午 4:24
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   // 注解警告信息
public class Test20 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("我的年薪计算器小软件");
        System.out.println("exit[88]退出程序;next[66]计算下一个年薪");
        while (true){
            System.out.println("请输入月薪：");
            int monthSalary = scanner.nextInt();
            System.out.println("请输入一年多少个月薪资：");
            int months = scanner.nextInt();
            int yearSalary = monthSalary*months;
            System.out.println("请输入命令(exit[88],next[66]. 其他任意数字表示 继续执行):");
            int commondNum = scanner.nextInt();
            if(88 == commondNum){
                System.out.println("退出软件");
                break;
            }
            if(66 == commondNum){
                System.out.println("重新输入新的数据...");
                continue;
            }
            if(yearSalary > 100000 && yearSalary < 200000){
                System.out.println("恭喜你，超过了 90%的国人！");
            }
            if(yearSalary >= 200000){
                System.out.println("恭喜你，超过了 98%的国人！");
            }
            System.out.println("年薪是："+yearSalary);
        }
    }
}

如图所示：在这里插入图片描述
练习二的代码如下：

package com.txw.hile;

import java.util.Scanner;
/**
 * 2.个税计算器：
 * (1) 通过键盘输入用户的月薪。
 * (2)百度搜索个税计算的方式，计算出应缴纳的税款。
 * (3)直到键盘输入“exit”，则退出程序（使用 break 退出循环）
 * @author Adair
 * @date 2022/1/13 下午 4:36
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")    // 注解警告信息
public class Test21 {
    public static void main(String[] args) {
        /*
        应纳税所得额=工资收入金额－各项社会保险费－起征点(5000 元)
        应纳税额=应纳税所得额x税率－速算扣除数
        级数        应纳税所得额                                税率(%) 速算扣除数
         1       不超过3,000元的部分                              3       0
         2       超过3,000元至12,000元的部分                      10      210
         3       超过12,000元至 25,000元的部分                    20      1410
         4       超过25,000元至 35,000元的部分                    25      2660
         5       超过35,000元至 55,000元的部分                    30      4410
         6       超过55,000元至 80,000元的部分                    35      7160
         7       超过80,000元的部分                              45      15160
          */
        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.println("请输入月薪：");
            double slary = scanner.nextInt();    // 月薪
            double jiao = slary-5000;   // 应纳税所得额（各项社会保险费=0）
            double shui = 0;  // 应纳税额
            if (jiao < 0){
                System.out.println("个税起征点为 5000 元，不需要纳税");
             }else if(jiao <= 3000){
                shui = jiao * 0.03;
                slary -= shui;
            }else if (jiao <= 12000){
                shui= jiao * 0.1-210;
                slary -= shui;
            }else if (jiao <= 25000){
                shui = jiao * 0.2 - 1410;
                slary -= shui;
            }else if (jiao <= 35000){
                shui = jiao * 0.25 - 2660;
                slary -= shui;
            }else if (jiao <= 55000){
                shui = jiao * 0.3 - 4410;
                slary -= shui;
            } else if (jiao <= 80000){
                shui = jiao * 0.35 - 7160;
                slary -= shui;
            }else {
                shui = jiao * 0.45 - 15160;
                slary -= shui;
            }
            System.out.println(" 应 纳 税 所 得 额 ： "+jiao+" 元 \t"+" 纳 税 税 额 "+shui+"元\t"+"实发工资"+slary+"元");
            System.out.println("输入 exit 退出程序！其他继续计算！");
            String cmd =scanner.next();
            if(cmd.equals("exit")){
                System.out.println("程序结束，退出！");
                break;
                }else{
                continue;
            }
        }
    }
}

如图所示：在这里插入图片描述

1.7 方法

语句块（有时叫做复合语句），是用花括号扩起的任意数量的简单 Java 语句。块确定了局部变量的作用域。块中的程序代码，作为一个整体，是要被一起执行的。块可以被嵌套在另一个块中，但是不能在两个嵌套的块内声明同名的变量。语句块可以使用外部的变量，而外部不能使用语句块中定义的变量，因为语句块中定义的变量作用域只限于语句块。
语句块的代码如下：

package com.txw.hile;

/**
 * 语句块
 * @author Adair
 * @date 2022/1/13 上午 9:59
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   // 注解警告信息
public class Test13 {
    public static void main(String[] args) {
        int n; 
        int a; 
        {
            int k;
            // int n; // 编译错误：不能重复定义变量n
        } // 变量k的作用域到此为止
    }
}

如图所示：在这里插入图片描述
方法(method)就是一段用来完成特定功能的代码片段，类似于其它语言的函数 (function)。
方法用于定义该类或该类的实例的行为特征和功能实现。方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。
方法声明格式：

[修饰符 1 修饰符 2 …] 返回值类型 方法名(形式参数列表){ 
	Java 语句；… … … 
}

方法的调用方式：

对象名.方法名(实参列表)

方法的详细说明：
1.形式参数：在方法声明时用于接收外界传入的数据。
2.实参：调用方法时实际传给方法的数据。
3.返回值：方法在执行完毕后返还给调用它的环境的数据。
4.返回值类型：事先约定的返回值的数据类型，如无返回值，必须指定为void。
方法的声明及调用的代码如下：

package com.txw.hile;

/**
 * 方法的声明及调用
 * @author Adair
 * @date 2022/1/13 上午 10:04
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")  // 注解警告信息
public class Test14 {
    /**
     * main方法：程序的入口
     */
    public static void main(String[] args) {
        int num1 = 10; int num2 = 20;
        // 调用求和的方法：将num1与num2的值传给add方法中的n1与n2
        // 求完和后将结果返回，用sum接收结果
        int sum = add(num1, num2);
        System.out.println("sum = " + sum);     // 输出：sum = 30
        // 调用打印的方法：该方法没有返回值
        print();
    }
    /** 
     * 求和的方法
     */
    public static int add(int n1, int n2) {
        int sum = n1 + n2;
        return sum;   // 使用return返回计算的结果
    }
    /** 
     * 打印的方法 
     */
    public static void print() {
        System.out.println("学无止路...");
    }
}

如图所示：
在这里插入图片描述

注意事项：
1.实参的数目、数据类型和次序必须和所调用的方法声明的形式参数列表匹配。 
2.return 语句终止方法的运行并指定要返回的数据。 
3.Java 中进行方法调用中传递参数时，遵循值传递的原则(传递的都是数据的副本)： 
3.1基本类型传递的是该数据值的copy值。
3.3引用类型传递的是该对象引用的 copy 值，但指向的是同一个对象。

方法的重载(overload)
方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。调用时，会根据不同的参数自动匹配对应的方法。

 新手雷区：重载的方法，实际是完全不同的方法，只是名称相同而已！

构成方法重载的条件：

不同的含义：形参类型、形参个数、形参顺序不同。
只有返回值不同不构成方法的重载如：int a(String str){}与 void a(String str){}不构成方法重载。
只有形参的名称不同，不构成方法的重载如：int a(String str){}与 int a(String s){}不构成方法重载。
方法重载的代码如下：

package com.txw.hile;

/**
 * 方法重载
 * @author Adair
 * @date 2022/1/13 上午 11:33
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   // 注解警告信息
public class Test15 {
    public static void main(String[] args) {
        System.out.println(add(3, 5));      // 8
        System.out.println(add(3, 5, 10));       // 18
        System.out.println(add(3.0, 5));        // 8.0
        System.out.println(add(3, 5.0));        // 8.0
        // 我们已经见过的方法的重载
        System.out.println();       // 0个参数
        System.out.println(1);      // 参数是1个int
        System.out.println(3.0);    // 参数是1个double
    }

    /**
     * 求和的方法
     */
    public static int add(int n1, int n2) {
        int sum = n1 + n2;
        return sum;
    }

    // 方法名相同，参数个数不同，构成重载
    public static int add(int n1, int n2, int n3) {
        int sum = n1 + n2 + n3;
        return sum;
    }

    // 方法名相同，参数类型不同，构成重载
    public static double add(double n1, int n2) {
        double sum = n1 + n2;
        return sum;
    }
    // 方法名相同，参数顺序不同，构成重载
    public static double add(int n1, double n2) {
        double sum = n1 + n2;
        return sum;
    }
    // 编译错误：只有返回值不同，不构成方法的重载
  /*  public static double add(int n1, int n2) {
        double sum = n1 + n2;
        return sum;
    }*/

    // 编译错误：只有参数名称不同，不构成方法的重载
   /* public static int add(int n2, int n1) {
        double sum = n1 + n2;
        return sum;
    }*/
}

如图所示：在这里插入图片描述
练习一的代码如下：

package com.txw.hile;

/**
 * 练习题
 * @author Adair
 * @date 2022/1/14 上午 9:36
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")  // 注解警告信息
public class Test22 {
    public static void main(String[] args) {
        late(45,42000);
    }

    /**
     * (1)输入参数：迟到时间，月薪。
     * (2)处理逻辑： 
     * ①迟到1-10分钟，警告。
     * ②迟到11-20分钟，罚款100元。
     * ③迟到21分钟-30分钟，罚款200元。
     * ④迟到30分钟以上，扣除半日工资。
     * ⑤迟到1小时以上，按照旷工计算，扣除3日工资。
     * (3)输出罚款金额。
     */
    public static int late(int lateMinute,double salary) {
        int fakuan = 0;             // 罚款
        if(lateMinute < 11){
            System.out.println("警告！！不能迟到！！");
         }else if(lateMinute < 21){
            fakuan = 100;
        }else if(lateMinute < 31){
            fakuan = 200;
        }else if(lateMinute < 61){
            fakuan = (int)(salary / (21.75 * 2)); // 21.75指的是月平均工作日
        }else{
            fakuan = (int)(salary * 3 / (21.75));
        }
        System.out.println("迟到时间："+lateMinute+",罚款： "+fakuan);
        return fakuan;
    }
}

如图所示：在这里插入图片描述

1.8 递归结构

递归是一种常见的解决问题的方法，即把问题逐渐简单化。递归的基本思想就是“自己调用自己”，一个使用递归技术的方法将会直接或者间接的调用自己。
利用递归可以用简单的程序来解决一些复杂的问题。比如：斐波那契数列的计算、汉诺塔、快排等问题。
递归结构包括两个部分：
1 . 定义递归头。解答：什么时候不调用自身方法。如果没有头，将陷入死循环，也就是递归的结束条件。
2.递归体。解答：什么时候需要调用自身方法。
使用递归求n!的代码如下：

package com.txw.hile;

/**
 * 使用递归求n!
 * @author Adair
 * @date 2022/1/13 下午 1:44
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   // 注解警告信息
public class Test16 {
    public static void main(String[] args) {
        long d1 = System.currentTimeMillis();
        System.out.printf("%d 阶乘的结果:%s%n", 10, factorial(10));
        long d2 = System.currentTimeMillis();
        System.out.printf("递归费时：%s%n", d2-d1);  // 耗时：32ms
    }
    /**
     * 求阶乘的方法
     */
    public static int factorial(int n){
        if(n == 1) {      // 递归头
            return  1;
        }else{
            return n * factorial(n - 1);        // n! = n * (n-1)!
        }
    }
}

如图所示：在这里插入图片描述
执行结果如图所示：
递归的缺陷简单的程序是递归的优点之一。但是递归调用会占用大量的系统堆栈，内存耗用多，在递归调用层次多时速度要比循环慢的多，所以在使用递归时要慎重。
使用循环求 n!的代码如下：

package com.txw.hile;

/**
 * 使用循环求n!
 * @author Adair
 * @date 2022/1/13 下午 1:44
 * @email 1578533828@qq.com
 */
@SuppressWarnings("all")   // 注解警告信息
public class Test16 {
    public static void main(String[] args) {
        long d1 = System.currentTimeMillis();
        int a = 10;
        int result = 1;
        while (a > 1) {
            result *= a * (a - 1);
            a -= 2;
        }
        long d2 = System.currentTimeMillis();
        System.out.println(result);
        System.out.printf("普通循环费时：%s%n", d2 - d1);
    }
}

如图所示：在这里插入图片描述

注意事项：
1任何能用递归解决的问题也能使用迭代解决。当递归方法可以更加自然地反映问题，并 且易于理解和调试，并且不强调效率问题时，可以采用递归。 
2.在要求高性能的情况下尽量避免使用递归，递归调用既花时间又耗内存。

学无止路

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java的控制语句

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。控制语句分为三类：顺序、选择和循环。“顺序结构”代表“先执行 a，再执行 b”的逻辑。比如，先找个女朋友，再给女朋友打电话；先订婚，再结婚； “条件判断结构”代表“如果…，则…”的逻辑。比如，如果女朋友来电，则迅速接电话；如果看到红灯，则停车； “循环结构”代表“如果…，则重复执行…”的逻辑。比如，如果没打通女朋友电话，则再继续打一次；如果没找到喜欢的人，则再继续找。顺序结构即按照书写顺序执行
复制链接

扫一扫