5.java流程控制

已于 2023-10-04 21:44:58 修改
阅读量154 收藏
点赞数
文章标签： java 开发语言 servlet
于 2022-09-20 19:16:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57206092/article/details/126959666
版权

JAVA流程控制

1. Scanner使用步骤

  • 1导包：
    import java.util.Scanner;//导包的动作必须出现在类定义上边
  • 2创建对象：
    Scanner scanner = new Scanner (System.in);//只有sc是变量名，其他都不可变
  • 3.判断数据是否还有输入
    if (scanner.hasNext==ture()){
   
}
  • 4.接收数据：
  •  	String str = scanner.next();
    System.out.printlin("输出的内容为："+ str)；
    • 使用Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。
    • 1.next();
      • 一定要读取到有效字符后才可以结束输入
      • 对输入有效字符之前遇到的空白，next();方法会自动将其去掉
      • 只有输入有效字符后才能将其后面输入的空白作为分割符或结束符
      • next();不能得到有空格的字符串
    • 2.nextLine()
      • 以Enter为结束符，也就是说nextLine()方法返回的是输入回车键之前的所有字符
      • 可以获得空白
  • 5.关闭Scanner,节省资源
    scanner.close();

package Scanner;

import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
		//创建一个扫描对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用next方式接收");
		//判断用户有没有输入字符串
        if (scanner.hasNext() == true) {	//此处也可以用hasNextLine()判断是否输入
            String str = scanner.next();	//接受就需要用nexrLine()接收
            System.out.println("输出的内容为："+ str);
        }
        //凡是IO流的类如果不关闭会一直占用资源
        scanner.close();
    }
}

2.顺序结构

  • JAVA的基本结构，除非特别指明，否则就按照顺序一句一句的执行
  • 顺序结构是最简单的算法结构
  • 语句和语句之间，框与框之间是按从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构。

3.选择结构

1.if单选择结构

格式：
if（关系表达式）{
	语句体;
	}

2.if双选择结构

格式：
      if（关系表达式）{
       语句体1;
   } else {
       语句体2;
   }
执行流程：
      1. 首先计算关系表达式的值
      2. 如果关系表达式的值为true就执行语句体
      3. 如果关系表达式的值为false就不执行语句体
      4. 继续执行后面的语句内容

3.if多选择结构

格式:
	if(关系表达式1){
		语句体1;
	}	else if(关系表达式2){
		语句体2;
	}
	....
		else{
		语句体n+1;
		}

4.嵌套的if结构

任何语句对外都可以看成一句话，一句代码

分支语句中包含分支语句称为分支嵌套循环

语句中包含循环语句称为循环嵌套

5.switch多选择结构

格式:
    switch(表达式) {
        case 值1:
         语句体1;
         break;
         case 值2:
         语句体2;
         break;
        ……
        default;
        语句体n+1;
        [break;]
        }

格式说明:
   表达式:取值为byte,short,int,char,JDK5以后可以枚举，JDK7以后可以String,
   case: 后面跟的是要和表达式进行比较的值
   break: 表示中断，结束的意思，用来结束switch语句。
   default: 表示所有情况都不匹配的的时候，就会执行该处的内容，和if语句的else相似。

执行流程:
   首先计算表达式的值。
   依次和case后面的值进行比较，如果对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
   如果所有的case后面的值和表达式的值都不匹配，就会执行default里面的语句体，然后程序结束掉。

4.循环语句

1.循环结构的特征

  • 重复做某件事情
  • 具有明确的开始和停止标志

2.循环结构的组成

  1. 初始化语句:用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样
  2. 条件判断语句: 用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去
  3. 循环体语句: 用于表示循环反复执行的内容，简单说就是循环反复执行的事情
  4. 条件控制语句: 用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去

3.循环结构对应的语法

  • 初始化语句: 这里可以是一条或者多条语句，这些语句可以完成一些初始化操作
  • 条件判断语句：这里使用一个结果值为boolean类型的表达式，这个表达式能决定是否执行循环体。例如：a<3
  • 循环体语句：这里可以是任意语句，这些语句将反复执行
  • 条件控制语句：这里通常是使用一条语句来改变变量的值，从而达到控制循环是否继续向下执行的效果。常见的i++，i–这样的操作

5.for 循环语句

格式:
     for(初始化语句;条件判断语句;条件控制语句）{
         循环体语句;
     }
执行流程:
     1:执行初始化语句
     2:执行条件判断语句，看其结果是true还是false
         如果是false，循环结束
         如果是true，继续运行
     3:执行循环体语句
     4：执行条件控制语句
     5:回到2继续
/*
   for语句

   格式:
        for(初始化语句;条件判断语句;条件控制语句）{
            循环体语句;
        }

   执行流程:
        1:执行初始化语句
        2:执行条件判断语句，看其结果是true还是false
            如果是false，循环结束
            如果是true，继续运行
        3:执行循环语句体
        4：执行条件控制语句
        5:回到2继续
 */

public class OperatorDemo03 {
    public static void main(String[] args) {
        //需求:在控制台输出五次“HelloWorld”
        //使用for循环
        for (int i = 1;i <= 5;i++){
            System.out.println("HelloWorld");
        }
    }
}

1.案例:输出数据

/*
   输出数据

   需求:
        在控制台输出1-5和5-1
 */

public class OperatorDemo03 {
    public static void main(String[] args) {
        //需求:输出数据1-5
        //使用for循环
        for (int i = 1;i <= 5;i++){
            System.out.println(i);
        }

        System.out.println("-------");

        //需求:输出数据5-1
        for (int i = 5;i >= 1;i--) {
            System.out.println(i);
        }
    }
}

2.案例:求和

/*
   求和

   需求:
        求1-5之间的数据和，并把求和结果在控制台输出
 */

public class OperatorDemo03 {
    public static void main(String[] args) {
        //求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
        int sum = 0;

        //从1开始到5结束的数据，使用循环结果完成
        for (int i = 1;i <= 5;i++){
            //将反复进行的事情写入循环结构内部，此处反复进行的事情时将数据i加到用于保存最终求和的变量sum中
            sum += i;
            //加后赋值a+=b 相当于把a+b的值赋给a

        }

        //当循环执行完毕时，将最终数据打印出来
        System.out.println("1-5之间的数据和是:" + sum);
    }
}

3.案例求偶数和

/*
   求偶数和

   需求:
        求1-100之间的偶数和，并把求和结果在控制台输出
 */

public class OperatorDemo03 {
    public static void main(String[] args) {
        //求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
        int sum = 0;

        //从1开始到100结束的数据，使用循环结果完成
        for (int i = 1;i <= 100;i++){
            //将反复进行的事情写入循环结构内部，此处反复进行的事情时将数据i加到用于保存最终求和的变量sum中
            //对1-100的偶数和，需要对求和添加限制条件，判断是否为偶数
            if (i % 2 == 0 ){
                sum += i; //加后赋值a+=b 相当于把a+b的值赋给a
            }
        }
        //当循环执行完毕时，将最终数据打印出来
        System.out.println("1-100之间的偶数和是:" + sum);
    }
}

4.案例水仙花

水仙花数:

  • 水仙花数是一个三位数
  • 水仙花数的个位，十位，百位的立方和等于原数

任意数字的指定位上的数值如何求

先用整出操作将要求的数字移动到个位上，再使用取余操作取出走后以为上的值

范例: 12345678 先整除1000得到12345，再对10取余得到5

/*
   水仙花数

   需求:
        在控制台输出所有的水仙花数
 */

public class OperatorDemo03 {
    public static void main(String[] args) {
        for (int i = 100;i <= 999;i++){
            //在计算之前获取三位数中每个位上的值
            
            int ge = i%10;
            int shi = i/10%10;
            int bai = i/100%10;
            //判定条件是将三位数中的每个数值取出来，计算立方和后与原数字比较是否相等
            if (ge*ge*ge + shi*shi*shi + bai* bai*bai == i){
                //输出满足条件的的数字就是水仙花数
                System.out.println(i + "是水仙花数");
            }
        }
    }
}

5.案例： 统计

/*
   统计

   需求:
        统计控制台输出所有的水仙花个数
 */

public class OperatorDemo03 {
    public static void main(String[] args) {
        //定义变量count，用于保存水仙花数的数量，初始值为0
        int count = 0;

        for (int i = 100;i <= 999;i++){
            //在计算之前获取三位数中每个位上的值

            int ge = i%10;
            int shi = i/10%10;
            int bai = i/100%10;
            //判定条件是将三位数中的每个数值取出来，计算立方和后与原数字比较是否相等

            if (ge*ge*ge + shi*shi*shi + bai* bai*bai == i){
                //输出满足条件的的数字就是水仙花数
                count++;

            }
        }
        System.out.println( "水仙花共有:" +count + "个");
    }
}

6. while 循环语句

基本格式
        while(条件判断语句）{
            循环体语句;
          }
完整格式:
    初始化语句;
    while(条件判断语句）{
     循环体语句;
     条件控制语句;
    }
执行流程:
    1:执行初始化语句
    2:执行条件判断语句，看其结果是true还是false
        如果是false，循环结束
        如果是true，继续运行
    3:执行循环体语句
    4：执行条件控制语句
     5:回到2继续
/*
           while语句
    基本格式
            while(条件判断语句）{
                循环体语句;
              }
    完整格式:
        初始化语句;
        while(条件判断语句）{
         循环体语句;
         条件控制语句;
        }

    执行流程:
        1:执行初始化语句
        2:执行条件判断语句，看其结果是true还是false
            如果是false，循环结束
            如果是true，继续运行
        3:执行循环体语句
        4：执行条件控制语句
         5:回到2继续
 */

public class OperatorDemo03 {
    public static void main(String[] args) {
        //需求:在控制台输出五次“HelloWorld”
        //使用for循环实现
        for (int i = 1;i <= 5;i++){
            System.out.println("HelloWorld");
        }
        System.out.println("----------");
        
        //使用while实现
        int j = 1;
        while (j <= 5){
            System.out.println("HelloWorld");
            j++;
        }
    }
}

1.珠穆朗玛峰

/*
       珠穆朗玛峰

       需求
            世界上最高的上珠穆朗玛峰（8844.43米=8844430毫米），假如有一张足够大的纸，它的厚度是0.1毫米。
            请问，折叠多少次，可以拆成珠穆朗玛峰的高度？
 */

public class OperatorDemo03 {
    public static void main(String[] args) {
        //定义一个计数器，初始值为0
        int count = 0;

        //定义纸张的厚度
        double paper = 0.1;

        //定义珠穆朗玛峰的高度
        int zf = 8844430;

        //因为是反复折叠，所以要使用循环，但是不知道折叠多少次，这种情况下更适合使用while循环
        //折叠过程中当纸张的厚度大于珠穆朗玛峰就停止了，因此继续执行的要求是纸张后小于珠峰高度
        while (paper <= zf){
            //循环的执行过程中纸张每次折叠，纸张的厚度加倍
            paper *= 2;

            //在循环中执行累加，对应折叠的次数
            count++;
        }
        System.out.println("需要折叠"+ count +"次");
    }
}

7.do……while 循环语句

do……while循环语句

基本格式
     do {
         循环体语句;
        }while(条件判断语句);

 完整格式
     初始化语句;
     do {
         循环体语句;
         条件控制语句;
         } while(条件判断语句);
执行流程:
    1.执行初始化语句
    2.执行循环体语句
    3.执行条件控制语句
    4.执行条件判断语句，看结果是true还是false
        如果是true，继续执行
        如果是false，结束循环
    5. 回到2继续
/*
       do……while循环语句

       基本格式
            do {
                循环体语句;
               }while(条件判断语句);

        完整格式
            初始化语句;
            do {
                循环体语句;
                条件控制语句;
                } while(条件判断语句);

        执行流程:
            1.执行初始化语句
            2.执行循环体语句
            3.执行条件控制语句
            4.执行条件判断语句，看结果是true还是false
                如果是true，继续执行
                如果是false，结束循环
            5. 回到2继续
 */

public class OperatorDemo03 {
    public static void main(String[] args) {
        //需求:在控制台输出五次“HelloWorld”
        //使用for循环实现
        for (int i = 1;i <= 5;i++){
            System.out.println("HelloWorld");
        }
        System.out.println("----------");

        //使用do……while循环实现
        int j = 1;
        do {
            System.out.println("HelloWorld");
            j++;
        }while(j <=5);
    }
}

8.三种循环的区别

  1. 三种循环的区别:

    • for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）
    • do……while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断）

  2. for和while的区别

    • 条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了
    • 条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用

  3. 死循环格式:(一直执行)

    • for(;😉{}
    • while(true){}
    • do{}while(true);

    while的死循环格式是最常用的

    命令提示符窗口Ctrl+C可以结束死循环

9.无限循环

无限循环：表示一直停不下来。

有三种循环体结构:

//第一种 for循环
for(;;){
    System.out.println("学习");
}

//第二种 while循环
while(true){
     System.out.println("学习");
}

//第三种 do while循环
do{
     System.out.println("学习")
}while(true)

注意：无限循环的下面就不能写其他代码了，因为循环永远停不下来，下面的代码执行不到。

10.跳转控制语句

跳转控制语句：在循环的过程中，跳到其他语句上执行。

1.continue:用在循环中，基于条件控制，跳过某次循环体内容执行，继续下一次的执行
/*
       continue:用在循环中，基于条件控制，跳过某次循环体内容执行，继续下一次的执行
       break:用在循环中，基于条件控制，终止循环体内容的执行，也就是说结束当前的整个循环
 */

public class OperatorDemo03 {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++){
            if (i%2 == 0){ //这是个偶数判断语句
                continue;
                //break;
            }
            System.out.println(i);
        }

    }
}



//需求：小老虎吃包子。第三个包子有虫子，跳过不吃
public class Demo6 {
    public static void main(String[] args) {
        for (int i = 1; i <= 5;i++){
            if (i == 3){
                //结束本次循环，进入下次循环。
                continue;
            }
            System.out.println("小老虎吃了第"+ i +"个包子");
        }
    }
}


2.break:用在循环中，基于条件控制，终止循环体内容的执行，也就是说结束当前的整个循环
/*
       continue:用在循环中，基于条件控制，跳过某次循环体内容执行，继续下一次的执行
       break:用在循环中，基于条件控制，终止循环体内容的执行，也就是说结束当前的整个循环
 */

public class OperatorDemo03 {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++){
            if (i%2 == 0){
                //continue;
                break;
            }
            System.out.println(i);
        }

    }
}


//需求：小老虎吃包子。第三个包子有虫子，跳过不吃
public class Demo6 {
    public static void main(String[] args) {
        for (int i = 1; i <= 5;i++){
             System.out.println("小老虎吃了第"+ i +"个包子");
            if (i == 3){
                //结束整个循环。
                break;
            }
        }
    }
}

11.循环嵌套

语句结构:

  1. 顺序语句 以分号结尾，表示一句话的结束

  2. 分支语句 一对大括号表示if的整体结构，整体描述一个完整的if语句

    一对大括号表示switch的整体结构，描述一个完整的switch语句

  3. 循环语句 一对大括号表示for的整体结构，整体描述一个完整的for语句

    一对大括号表示switch的整体结构，整体描述一个完整的switch语句

    do……while以分号结尾，整体描述一个完整的do……while语句

任何语句对外都可以看成一句话，一句代码

分支语句中包含分支语句称为分支嵌套循环

语句中包含循环语句称为循环嵌套

/*
       循环嵌套:
            循环语句中包含循环语句

       需求:
            在控制台输出一天的小时和分钟

            分钟和小时的范围:
            分钟：0 <= minute < 60
            小时：0 <= hour < 24
 */

public class OperatorDemo03 {
    public static void main(String[] args) {
        /*
        System.out.println("0时0分");
        System.out.println("0时1分");
        System.out.println("0时2分");
        System.out.println("0时3分");
        System.out.println("-------");
        System.out.println("1时0分");
        System.out.println("1时1分");
        System.out.println("1时2分");
        System.out.println("1时3分");
        System.out.println("-------");
        System.out.println("2时0分");
        System.out.println("2时1分");
        System.out.println("2时2分");
        System.out.println("2时3分");
        System.out.println("-------");
         */

        //循环改进
        /*
        for (int minute = 0;minute <= 3; minute++){
            System.out.println("0时" + minute +"分");
        }
        System.out.println("-------");

        for (int minute = 0;minute <= 3; minute++){
            System.out.println("1时" + minute +"分");
        }
        System.out.println("-------");

        for (int minute = 0;minute <= 3; minute++){
            System.out.println("2时" + minute +"分");
        }
        System.out.println("-------");

         */

        //循环嵌套
        /*
        for (int hour = 0;hour<=2;hour++){
            for (int minute = 0;minute <= 3; minute++){
                System.out.println(hour+"时" + minute +"分");
            }
        }
         */
        //现在看 分钟和小时的范围:
        //            分钟：0 <= minute < 60
        //            小时：0 <= hour < 24
        for (int hour = 0; hour<=24;hour++){
            for (int minute = 0;minute <= 60; minute++){
                System.out.println(hour+"时" + minute +"分");
            }
        }
    }
}

12.案例

//逢七过，范围1到100，只要是包含七或者是七的倍数的数字，输出过
public class Demo7 {
    public static void main(String[] args) {
        for (int i = 1; i <= 100; i++) {
            if (i % 10 == 7 || i / 10%  10 == 7 || i % 7 == 0){
                System.out.println("过");
                continue;
            }
            System.out.println(i);
        }
    }

package Scanner;

import java.util.Scanner;

//键盘输入一个大于等于2的整数 x ，计算并返回x的算数平方根，结果只保留整数，舍弃小数部分
public class Demo8 {
    public static void main(String[] args) {
        //键盘录入
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int number = sc.nextInt();
        //循环判断
        /*
        1.从1开始循环，拿着数字的平方跟原来的数字进行比较
        2.如果小于，那么继续往后判断
        3.如果等于，那么当前数字就是平方根
        4.如果大于，那么前一个数字就是平方根的整数部分
         */
        for (int i = 1; i <= number; i++) {
            if (i * i == number){
                System.out.println(i + "就是" + number +"的平方根");
                //一旦找到，循环就停止，后面数字就不用找了
                break;
            } else if (i * i > number) {
                System.out.println(i - 1 + "就是" + number +"的平方根");
                break;
            }
        }
    }
}


package Scanner;

import java.util.Scanner;

//键盘输入一个大于等于2的整数 x ，计算并返回x的算数平方根，结果只保留整数，舍弃小数部分
public class Demo8 {
    public static void main(String[] args) {
        //键盘录入
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int number = sc.nextInt();
        //循环判断
        /*
        1.从1开始循环，拿着数字的平方跟原来的数字进行比较
        2.如果小于，那么继续往后判断
        3.如果等于，那么当前数字就是平方根
        4.如果大于，那么前一个数字就是平方根的整数部分
         */
        for (int i = 1; i <= number; i++) {
            if (i * i == number){
                System.out.println(i + "就是" + number +"的平方根");
                //一旦找到，循环就停止，后面数字就不用找了
                break;
            } else if (i * i > number) {
                System.out.println(i - 1 + "就是" + number +"的平方根");
                break;
            }
        }
    }
}

13.Random类

  1. Random类可以生成一个随机数
    1. 导包 import java.util.Random;
    2. 创建对象 Random r = new Random();
    3. 生成随机数 int number = r.nextInt(随机数的范围);
package Scanner;
//导包
import java.util.Random;


public class Demo10 {
    public static void main(String[] args) {
        //创建对象
        Random r = new Random();
        /*
        1.生成随机数
        判断技巧
        在小括号中，书写的是生成随机数的范围
        到这个数-1结束
        口诀：包头不包尾，包左不包右
         */
        int number = r.nextInt(100);
        System.out.println(number);
    }
}


  /*
        用来生成任意数到任意数之间的随机数：7~15
        1.让这个范围头尾都减去一个值，让这个范围从0开始：0~8
        2.尾巴加1  8+1=9
        3.最终结果，再加上第一步减去的值。
        
        Random r = new Random();
        int number = r.nextInt(9) + 7;//可以换算成任意范围
        System.out.println(number);
         */

package Scanner;
//导包
import java.util.Random;
import java.util.Scanner;

//程序生成1到100之间的随机数，使用程序实现猜出这个数字是多少
//加入一个抽奖保底机制，比如抽三次必中
public class Demo10 {
    public static void main(String[] args) {
        //创建对象
        Random r = new Random();
        
        //计数器
        //用来统计当前猜了多少次
        int count = 0;
        int number = r.nextInt(100) + 1 ;
        //猜数字多少
        Scanner sc = new Scanner(System.in);
        while (true){
        System.out.println("请输入你要猜的数字：");
        int guessNumber = sc.nextInt();

        count++;
        if (count == 3){
            System.out.println("猜中");
            break;
        }
        //判断数字给出不同的情况
        if (guessNumber>number){
            System.out.println("大了");
        } else if (guessNumber<number) {
            System.out.println("小了");
        }else {
            System.out.println("你猜对了");
            break;
        }
        }
    }
}

计数器

​ int count = 0;

​ count++;

午后来杯java
关注
Java流程控制
qq_63762763的博客
03-16 497
一.Java流程控制01：用户交互Scanner Scanner对象: 之前我们学的基础语法中我们并没有实现程序和人的交互，但是Java给我们提供了这样一个工具类，我们可以获取用户的输入。java.util.Scanner是Java5的新特征，我们可以通过Scanner类来获取用户的输入。 基本语法： Scanner s = new Scanner(System.in); 通过Scanner类的next（）与nextLine（）方法获取输入的字符串，在读取前我们一般需要使用hasNext()与
Java流程控制语句
黑黑的博客
12-22 138
块 这里讲述块的概念，一个代码块即一对大括号和其中的代码，块定义了变量的作用域。代码如下： { int i=0; i++; } System.out.println(i);/*在这里会提示你错误，Cannot resolve symbol 'i',因为i的作用范围仅在代码块中，所以外部无法访问。*/ /*对于代码块，我们往往会遇到在try cash语句中的变量在try之外 没法使用
流程控制语句实现多需求
李某人的博客
03-06 365
流程控制语句实现多需求
Java基础——流程控制语句
weixin_52297290的博客
05-27 451
​ 循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复 执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形 成死循环。顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。for循环中，控制循环的变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了。​ ②由于奖励种类较多，属于多种判断，采用if…
16.java流程控制语句.zip
06-14
在这个"16.java流程控制语句"的学习资料中，我们将深入探讨Java中的三大流程控制结构：顺序结构、选择结构（条件控制）和循环结构。 **1. 顺序结构** 这是最基础的结构，程序中的每一行代码都会按照自上而下的顺序...
Java流程控制.md
05-13
Java流程控制，包含Scanner调用方法和简单，顺序结构，基础循环，还有简单debug方法（没有详细介绍debug，文档里有链接，其他大大有总结好的）
Java程序设计-4-流程控制.zip_控制 Java
09-14
在Java编程语言中，流程控制是编写程序时不可或缺的一部分，它决定了代码的执行顺序和条件。本教程将深入探讨Java中的流程控制结构，包括顺序控制、选择控制（条件语句）和循环控制，帮助你更好地理解和运用这些概念...
java流程控制语句的总结共9页.pdf.zip
10-30
本资料"java流程控制语句的总结共9页.pdf.zip"显然涵盖了这一关键主题的全面概述，以下是根据标题和描述提炼出的主要知识点： 1. **顺序结构**：这是最基本的流程控制，按照代码的书写顺序逐行执行。Java程序中的每...
Java流程控制顺序结构原理解析
08-25
Java流程控制顺序结构原理解析 Java流程控制 顺序结构是 Java 编程语言中最基本的流程控制结构之一。它按照代码的编写顺序，从上往下依次执行语句，这种结构非常简单易懂，但却是 Java 编程语言中最基本的流程控制...
Java流程控制（一）
chuxiqianye2020的博客
02-06 1948
Java流程控制（一）1.用户交互Scanner2.顺序结构3.选择结构if单选结构if双选择结构if多选择结构嵌套的if结构switch多选择结构 1.用户交互Scanner 之前我们学的基本语法中我们并没有实现程序和人的交互，但是Java给我们提供了这样一个工具类，我们可以获取用户的输入。java.util.Scanner是Java5的新特性，我们可以通过Scanner类来获取用户的输入 基本语法 Scanner s = new Scanner(System.in); 通过Scanner类的ne
Java程序执行流程
weixin_50485954的博客
08-16 103
Java程序执行流程
Java 程序流程控制
qq_48010634的博客
10-20 949
Java 程序流程控制
java中函数执行顺序_⑥Java中函数执行顺序
weixin_30415591的博客
02-24 265
*另：父类构造方法中用到的方法如果已被子类重写，那么在构造子类对象时在调用父类构造函数中使用子类重写的方法一、先执行内部静态对象的构造方法，如果有多个按定义的先后顺序执行；静态对象在构造的时候也是也先执行其内部的静态对象。二、再调用父类的构造方法(父类还有父类的话，从最开始的基类开始调用)，如果没有明显指定调用父类自定义的构造方法，那么编译器会调用默认的父类构造方法super()。但是如果要调用...
java 按自定义执行步骤_java自定义注解
weixin_30985047的博客
03-05 273
一、注解按照运行机制分类：源码注解：注解只在源码中存在，.class文件就没了编译时注解：注解在源码和.class文件里都存在(@Override、@Deprecate)运行时注解：程序运行时还起作用(@Autowired)二、注解按照使用的方式和用途分类。(1)内建注解又称为基本注解，位于java.lang包下。内建注解有三个：1、检验重写父类方法：@Override2、标识方法已经过时：@De...
【C++刷题】力扣-#121-买卖股票的最佳时机
最新发布
会写代码的饭桶
10-16 245
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 297
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值