JAVA流程控制

最新推荐文章于 2024-07-06 13:51:47 发布
最新推荐文章于 2024-07-06 13:51:47 发布
阅读量88 收藏 1
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/binggiao/article/details/117386417
版权

JAVA流程控制

一、Scanner对象

  • 之前我们学的基本语法中我们并没有实现程序和人的交互，但是java给我们提供了这样一个工具类，我们可以获取用户的输入。java.util.Scanner是java5的新特征，我么可以通过Scanner类来获取用户的输入。
  • 基本语法：
Scanner s =new Scanner(System.in)
  • 通过Scanner类的next（）与nextLine（）方法获取输入的字符串，在读取前我们一般需要使用hasNext（）与hasNextLine（）判断是否还有输入的数据。
  1. next
  • 一定要读取到有效字符后才可以结束输入
  • 对输入有效字符之前遇到的空白，next（）方法会自动将其去掉。
  • 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
  • next（）不能得到带有空格的字符串。
  1. next
package com.lv.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()){
            //使用next方式接收
            String str = scanner.next();//程序会等待用户输入完毕
            System.out.println("输出的内容为："+str);
        }
        //凡是属于IO流的类如果不关闭会一直占用资源，要养成好习惯用完就关
        scanner.close();


    }
}

结果：

使用next方式接收：
Hello World!
输出的内容为：Hello

  1. nextLIne（）：
  • 以Enter为结束符，也就是说nextLine（）方法返回的是输入回车之前的所有字符。
  • 可以获得空白。
package com.lv.scanner;

import java.util.Scanner;

public class Demo02 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用nextLine方法接收：");
        //判断是否还有输入
        if(scanner.hasNextLine()){
            String str = scanner.nextLine();
            System.out.println("输出的内容为："+str);
        }



    }
}

结果：

使用nextLine方法接收：
Hello World!
输出的内容为：Hello World!

package com.lv.scanner;

import java.util.Scanner;

public class Demo03 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入数据：");
        String str = scanner.nextLine();
        System.out.println("输出的内容为："+str);
        scanner.close();


    }
}

结果：

请输入数据：
每天学一点 快乐每一天
输出的内容为：每天学一点 快乐每一天

  • scanner进阶使用
package com.lv.scanner;

import java.util.Scanner;

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

        int i = 0;
        float f =0.0f;
        System.out.println("请输入整数：");
        if (scanner.hasNextInt()){
            i = scanner.nextInt();
            System.out.println("整数数据："+i);
        }
        else {
            System.out.println("你输入的不是整数！");
        }

        System.out.println("请输入小数：");
        if (scanner.hasNextFloat()){
            f = scanner.nextFloat();
            System.out.println("小数数据："+f);
        }
        else {
            System.out.println("你输入的不是小数！");
        }

        scanner.close();
    }
}

结果：

请输入整数：
6
整数数据：6
请输入小数：
4.6
小数数据：4.6

  1. 我们可以输入多个数字，并求其总和与平均数,每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果:
package com.lv.scanner;

import java.util.Scanner;

public class Demo05 {
    public static void main(String[] args) {
        Scanner scaner = new Scanner(System.in);
        //和
        double sum = 0;
        //计算输入了多少个数字
        int m = 0;
        //通过循环判断是否还有输入，并在里面进行对每一次进行求和和统计
        while (scaner.hasNextDouble()){
           double x = scaner.nextDouble();
           m++;
           sum = sum+x;
            System.out.println("你输入了第"+m+"个数据，然和当前结果为sum="+sum);
        }
        scaner.close();
    }
}

二、顺序结构

  • JAVA的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行。
  • 顺序结构是最简单的算法结构。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-I1cSsC5B-1622273473045)(C:\Users\流水过尘\AppData\Roaming\Typora\typora-user-images\image-20210523201918319.png)]

  • 语句与语句之间，框与框之间是按从上到下的顺序进行的，它是由若干个依次执行的处理步骤
    组成的，它是任何一个算法都离不开的一种基本算法结构。
package com.lv.struct;

public class shunxuDemo01 {
    public static void main(String[] args) {
        System.out.println("hello01");
        System.out.println("hello02");
        System.out.println("hello03");
        System.out.println("hello04");
        System.out.println("hello05");
    }
}

结果：

hello01
hello02
hello03
hello04
hello05

二、选择结构

1.if单选择结构

  • 我们很多时候需要去判断f个东西是否可行，然后我们才去执行，这样一个过程在程序中用if语
    句来表示。

语法：

if(布尔表达式){
    //如果布尔表达式为true将执行的语句
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AoqlF7bW-1622273473047)(C:\Users\流水过尘\AppData\Roaming\Typora\typora-user-images\image-20210524195844050.png)]

package com.lv.struct;import javax.xml.stream.events.EndDocument;import java.util.Scanner;public class ifDemo01 {    public static void main(String[] args) {        Scanner scanner = new Scanner(System.in);        System.out.println("请输入内容：");        String s = scanner.nextLine();        //equals:判断字符串是否相等        if (s.equals("hello")){            System.out.println(s);        }        System.out.println("End");        scanner.close();    }}

结果：

请输入内容：
hello
hello
End

2.if双选择结构

  • 那现在有个需求，公司要收购个软件，成功了，给人支付100万元，失败了，自己找人开发。
    这样的需求用一个if就搞不定了，我们需要有两个判断，需要一个双选择结构，所以就有了if-
    else结构。

语法：

if(布尔表达式){    //如果布尔表达式的值为true}else{    //如果布尔表达式的值为false}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ndZDoqoG-1622273473048)(C:\Users\流水过尘\AppData\Roaming\Typora\typora-user-images\image-20210524201003294.png)]

package com.lv.struct;import java.util.Scanner;public class ifDemo02 {    public static void main(String[] args) {        //考试分数大于60就是及格，小于60分就不及格。        Scanner scanner = new Scanner(System.in);        System.out.println("请输入成绩: ");        int score = scanner.nextInt();         if (score > 60) {            System.out.println("及格");        } else {            System.out.println("不及格");            scanner.close();        }    }}

结果：

请输入成绩:
80
及格

3.if多选择结构

  • 我们发现刚才的代码不符合实际情况，真实的情况还可能存在ABCD,存在区间多级判断。比如
    90-100就是A，80-90就是B…等等,在生活中我们很多时候的选择也不仅仅只有两个，所以我
    们需要一个多选择结构来处理这类问题!

语法：

if(布尔表达式1){//如果布尔表达式1的值为true执行代码}else if(布尔表达式2){//如果布尔表达式2的值为true执行代码}else if(布尔表达式3){//如果布尔表达式3的值为true执行代码}else {//如果以上布尔表达式都不为true执行代码}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sPJ38Swu-1622273473051)(C:\Users\流水过尘\AppData\Roaming\Typora\typora-user-images\image-20210524202544349.png)]

package com.lv.struct;import java.util.Scanner;public class ifDemo03 {    public static void main(String[] args) {        //考试分数大于60就是及格，小于60分就不及格。        Scanner scanner = new Scanner(System. in);        /*if语句至多有1个else语句，else 语句在所有的else if语句之后。          if语句可以有若干个else if语句，它们必须在else语之前。          一旦其中一个else if语句检测为true,其他的else if以及else语句都将跳过执行。         */        System. out . println("请输入成绩: ");        int score = scanner . nextInt( );        if (score==100){            System. out . println("恭喜满分");        }else if (score<100 && score>=90){            System. out . println("A级");        }else if (score<90 && score>=80){            System. out . println("B级");        }else if (score<80 && score>=70){            System. out . println("C级");        }else if (score<70 &&                score>=60){            System. out. println("D级");        }else if (score<60 && score>=0){            System. out. println("不及格");        } else {            System. out. println("成绩不合法");        }        scanner.close();    }}

结果：

请输入成绩:
100
恭喜满分

3.嵌套if结构

  • 使用嵌套的if…else语句是合法的。也就是说你可以在另一个if或者else if语句中使用if或
    者else if语句。你可以像if语句一样嵌套else if…else。

语法：

if(布尔表达式1){如果布尔表达式1的值为true执行代码if(布尔表达式2){如果布尔表达式2的值为true执行代码}}

4.switch多选择结构

  • 多选择结构还有一个实现方式就是switch case语句。
  • switch case语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。
swicth(expression){    case value:    //语句    break;//可选    case value:    //语句    break;//语句    //你可以有任意数量的case语句    default://可选    //语句    }
  • switch语句中的变量类型可以是：
  1. byte、 short. int或者char.
  2. 从JavaSE 7开始
  3. switch支持字符串String类型了
  4. 同时case标签必须为字符串常量或字面量。
package com.lv.struct;public class switchDemo01 {    public static void main(String[] args) {        //case 穿透  //switch 匹配一个具体的值        char grade = 'C';        switch (grade) {            case 'A':                System.out.println("优秀");                break;            case 'B':                System.out.println("良好");                break;            case 'C':                System.out.println("及格");                break;            case 'D':                System.out.println("再接再厉");                break;            case 'E':                System.out.println("挂科");                break;            default:                System.out.println("未知等级");        }    }}

结果： 及格

package com.lv.struct;public class switchDemo02 {    public static void main(String[] args) {        String name = "好耶！";        //JDK7到最新版本的特性,表达式结果可以是字符串！！！        //字符的本质还是数字        //反翻译   java---class (字节码文件)---反翻译（IDEA）        switch(name){            case"好耶！":                System.out.println("好耶！");                break;            case"在此好耶！":                System.out.println("在此好耶！");            default:                System.out.println("干啥子！");        }    }}

结果：好耶！

反编译：

 Source code recreated from a .class file by IntelliJ IDEA// (powered by FernFlower decompiler)//package com.lv.struct;public class switchDemo02 {    public switchDemo02() {    }    public static void main(String[] args) {        String name = "好耶！";        byte var3 = -1;        switch(name.hashCode()) {        case -27123444:            if (name.equals("在此好耶！")) {                var3 = 1;            }            break;        case 23098312:            if (name.equals("好耶！")) {                var3 = 0;            }        }        switch(var3) {        case 0:            System.out.println("好耶！");            break;        case 1:            System.out.println("在此好耶！");        default:            System.out.println("干啥子！");        }    }}

三、循环结构

1.while循环

  • while是最基本的循环
while(布尔表达式){    //循环内容}
  • 只要布尔表达式为true, 循环就会一直执行下去。
package com.lv.struct;public class whileSemo02 {    //死循环    while (true){        //等待客户端连接        //定时检查        //.....    }}
  • 我们大多数情况是会让循环停止下来的，我们需要一个让表达式失效的方式来结束循环。
package com.lv.struct;public class whileDemo01 {    public static void main(String[] args) {        int i = 0;        while(i<100){            i++;            System.out.println(i);        }    }}

结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

  • 少部分情况需要循环一直执行，比如服务器的请求响应监听等。

  • 循环条件一 直为true就会造成无限循环[死循环] ,我们正常的业务编程中应该尽量避免死循

  • 环。会影响程序性能或者造成程序卡死奔溃!

    package com.lv.struct;public class whileDemo03 {    public static void main(String[] args) {        int i =0;        int sum = 0;        while(i<=100){            sum = sum+i;            i++;        }        System.out.println(sum);    }}

结果：5050

2.do… while循环

  • 对于while语句而言,如果不满足条件,则不能进入循环。但有时候我们需要即使不满足条件,也至少执行一次。
  • do…while循环和while循环相似，不同的是，do…while循环至少会执行一次。
do{    //代码语句}while(布尔表达式);
  • while和do…while的区别

​ while先判断后执行，do…while先执行后判断！

​ do…whlie 总是保证循环体会被执行一次！这是他们的主要差别。

package com.lv.struct;public class DowhileDemo01 {    public static void main(String[] args) {        int i = 0;        int sum = 0;        do {            sum = sum + i;            i++;        } while (i <= 100);        System.out.println(sum);    }}

结果：5050

package com.lv.struct;public class whileDemo02 {    public static void main(String[] args) {        int a =0;        while(a<0){            System.out.println(a);            a++;        }        System.out.println("======");        do {            System.out.println(a);        }        while(a<0);    }}

结果：

======
0

3.For循环

  • 虽然所有循环结构都可以用while或者do…while表示， 但Java提供了另一种语句——for
    循环，使一些循环结构变得更加简单。
  • for循环语句是支持迭代的一种通用结构,是最有效、最灵活的循环结构。
  • for循环执行的次数是在执行前就确定的。语法格式如下:
for(初始化；布尔表达式；更新){    //代码语句}

package com.lv.struct;public class ForDemo01 {    public static void main(String[] args) {        int i = 1;//初始化条件        while(i<=50 ){//条件判断            System.out.println(i);            i+=2;//迭代        }        System.out.println("while循环结束!");        //初始化;条件判断；迭代        for (int a =1;a<=50;a++){            System.out.println(a);        }        System.out.println("for循环结束！");    }}

结果：

1
3
5
7
9
11
13
15
17
19
21
23
25
27
29
31
33
35
37
39
41
43
45
47
49
while循环结束!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
for循环结束！

  • 关于于for循坏有以下儿点说明:
    最先执行初始化步骤。可以声明一种类型， 但可初始化一个或多 个循环控制变量，也可以是空语句。
    然后，检测布尔表达式的值。如果为true, 循环体被执行。如果为false, 循环终止，开始执行循环体后面的语句。
    执行一次循坏后，更新循环控制变量(迭代因子控制循环变量的增减)。
    再次检测布尔表达式。循环执行上面的过程。
//死循环for(; ; ){    }

练习1:计算0到100之间的奇数和偶数的和

package com.lv.struct;public class ForDemo02 {    public static void main(String[] args) {        int oddsum = 0;        int evensum = 0;        for (int i = 0;i<=100;i++){            if(i%2!=0) {                oddsum += i;            }else{                evensum+=i;                }            }        System.out.println("奇数的和:"+oddsum);        System.out.println("偶数的和:"+evensum);        }    }

结果：

奇数的和:2500
偶数的和:2550

练习2:用while或for循环输出1-1000之间能被5整除的数，并且每行输出3个

package com.lv.struct;public class ForDemo03 {    public static void main(String[] args) {        for (int i = 0; i <=1000; i++) {            if(i%5==0){                System.out.print(i+"  ");            }            if (i%(5*3)==0){//每行                System.out.println();                //System.out.print("/n");            }            //println输出完会换行            //print输出完不会换行        }    }}

结果：

0
5 10 15
20 25 30
35 40 45
50 55 60
65 70 75
80 85 90
95 100 105
110 115 120
125 130 135
140 145 150
155 160 165
170 175 180
185 190 195
200 205 210
215 220 225
230 235 240
245 250 255
260 265 270
275 280 285
290 295 300
305 310 315
320 325 330
335 340 345
350 355 360
365 370 375
380 385 390
395 400 405
410 415 420
425 430 435
440 445 450
455 460 465
470 475 480
485 490 495
500 505 510
515 520 525
530 535 540
545 550 555
560 565 570
575 580 585
590 595 600
605 610 615
620 625 630
635 640 645
650 655 660
665 670 675
680 685 690
695 700 705
710 715 720
725 730 735
740 745 750
755 760 765
770 775 780
785 790 795
800 805 810
815 820 825
830 835 840
845 850 855
860 865 870
875 880 885
890 895 900
905 910 915
920 925 930
935 940 945
950 955 960
965 970 975
980 985 990
995 1000

练习3:打印九九乘法表

package com.lv.struct;public class ForDemo04 {    public static void main(String[] args) {          //1.我们先打印第一列， 这个大家应该都会          //2.我们把固定的1再用一个 循环包起来         //3.去掉重复项，i <= j         //4.调整样式        for (int j = 1; j < 10; j++) {            for (int i = 1; i<= j; i++) {                System.out.print(j+"*"+i+"="+(j*i)+"\t");            }            System.out.println();        }    }}

结果：

1*1=1	
2*1=2	2*2=4	
3*1=3	3*2=6	3*3=9	
4*1=4	4*2=8	4*3=12	4*4=16	
5*1=5	5*2=10	5*3=15	5*4=20	5*5=25	
6*1=6	6*2=12	6*3=18	6*4=24	6*5=30	6*6=36	
7*1=7	7*2=14	7*3=21	7*4=28	7*5=35	7*6=42	7*7=49	
8*1=8	8*2=16	8*3=24	8*4=32	8*5=40	8*6=48	8*7=56	8*8=64	
9*1=9	9*2=18	9*3=27	9*4=36	9*5=45	9*6=54	9*7=63	9*8=72	9*9=81

4.增强for循环

  • 这里我们先只是见一面，做个了解，之后数组我们重点使用
  • Java5引入了一种主要用于数组或集合的增强型for循环。
  • Java增强for循环语法格式如下:
for(声明语句：表达式){

//代码句子

}
  • 声明语句:声明新的局部变量,该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
  • 表达式:表达式是要访问的数组名，或者是返回值为数组的方法。
package com.lv.struct;

public class ForDemo05{
    public static void main(String[] args) {
        int[] numbers ={10,20,30,40,50};
        for(int i =0;i<5;i++){
            System.out.println(numbers[i]);
        }
        System.out.println("======================");
        for (int x:numbers){
            System.out.println(x);
        }
    }
}

结果：

10
20
30
40
50
======================
10
20
30
40
50

四、break continue

  • break在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。(break语 句也在switch语句中使用)
package com.lv.struct;

public class BreakDemo {
    public static void main(String[] args) {
        int i =0;
        while (i<100){
            i++;
            System.out.println(i);
            if (i==30){
                break;
            }
        }

    }
}

结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

  • continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句,
    接着进行下一次是否执行循环的判定。
package com.lv.struct;

public class continueDemo0 {
    public static void main(String[] args) {
        int i = 0;
        while (i < 100) {
            i++;
            if (i % 10 == 0) {
                System.out.println();
                continue;
            }
            System.out.print(i);
        }
    }
}

结果：

123456789
111213141516171819
212223242526272829
313233343536373839
414243444546474849
515253545556575859
616263646566676869
717273747576777879
818283848586878889
919293949596979899

补充：关于goto关键字

  • goto关键字很早就在程序设计语言中出现。尽管goto仍是Java的- -个保留字,但并未在语言中得到正式使用; Java
    没有goto。然而，在break和continue这两个关键字的身上,我们仍然能看出一-些goto的影子—带标签的break和
    continue。
  • “标签"是指后面跟一个冒号的标识符，例如: label:
  • 对Java来说唯一用到标签的地方是在循环语句之前。 而在循环之前设置标签的唯-理由是:我们希望在其中嵌套另一
    个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。
package com.lv.struct;

public class LabelDemo {
    public static void main(String[] args) {
        //输出101到150之间的质数
        int count = 0;
        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+" ");
        }
    }
}

结果：

101 103 107 109 113 127 131 137 139 149

五、打印三角形

package com.lv.struct;

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

    }
}

结果：

     *
    ***
   *****
  *******
 *********

狂神说java

binggiao
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java流程控制语句
weixin_50394022的博客
07-20 1245
Java流程控制语句分为顺序结构、分支结构（if，switch）、循环结构(for、while、do...while)3大部分。
java流程控制图_Java流程控制结构
weixin_31814585的博客
02-13 1617
一、概念类型Java程序通过控制语句来控制方法的执行流程，从而实现特定的功能Java中的流程控制结构主要有三种：顺序结构；选择结构；循环结构。三种结构的结合使用可以解决任何复杂问题。二、流程表示——程序流程图流程图的基本符号如下：程序流程图三、循环结构while语句while ( 布尔表达式 ) {循环体；}do-while语句do{循环体;}while ( 表达式 );例： DoWhileTes...
Java流程控制实验
qq_44640357的博客
10-04 800
掌握Java循环控制语句、分支控制语句； 并对实现从Java语法到Python实现。
Java流程控制结构
xunmengyinjia的博客
09-26 1142
（4）循环结构：循环结构是根据判断条件来重复性地执行某段代码。Java提供了while语句、do-while语句、for语句来实现循环。（3）选择结构：选择结构是根据条件判断的结果来选择执行不同的代码。选择结构可以细分为单分支结构、双分支结构和多分支结构。Java提供了if控制语句和switch语句来实现选择结构。（2）顺序结构：顺序结构是指程序从上向下依次执行每条语句的结构，中间没有任何的判断和跳转。（1）在Java中有3种流程控制结构：顺序结构、选择结构、循环结构。
【Java基础教程】详解Java三种流程控制语句
hacker707的博客
04-18 6613
持续更新Java基础教程，和hacker一起卷起来
Java流程控制及数组实验
Szero
05-11 1666
Java流程控制及数组实验
Java流程控制（一）
chuxiqianye2020的博客
02-06 1870
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 流程控制语句
沉默王二
11-16 4008
Java 中涉及控制执行流程的关键字有 if-else、while-do-while、for、switch、return、break、continue 等等；我们来挑几个来说道说道。
JAVA的流程控制
q15923853509的博客
08-25 672
java流程控制里面的顺序语和分支结构的简单讲解
Java 流程控制 Switch 语句
hj1993的博客
06-16 2554
Switch语句是Java中的一种流程控制语句，用于根据表达式的值选择不同的执行路径。Switch语句包含一个表达式和多个case语句块。表达式的值将与每个case语句块中的值进行比较，如果表达式的值等于某个case语句块中的值，则执行该语句块中的语句。如果表达式的值与所有case语句块中的值都不匹配，则执行default语句块中的语句。Switch语句中的break语句用于终止当前的语句块，并跳过后面的所有语句块。Switch语句是Java中的一种流程控制语句，用于根据表达式的值选择不同的执行路径。
Java流程控制.md
05-13
Java流程控制，包含Scanner调用方法和简单，顺序结构，基础循环，还有简单debug方法（没有详细介绍debug，文档里有链接，其他大大有总结好的）
Java流程控制顺序结构原理解析
08-25
Java流程控制顺序结构原理解析 Java流程控制 顺序结构是 Java 编程语言中最基本的流程控制结构之一。它按照代码的编写顺序，从上往下依次执行语句，这种结构非常简单易懂，但却是 Java 编程语言中最基本的流程控制...
Java流程控制.ppt
06-04
if条件结构表达式的返回值是什么 if条件结构表达式的返回值只能是true或false if(表达式)、else if(表达式)和else后的代码块只有一行 语句是否可以省略花括号 if(表达式)、else if(表达式)和else后的代码块只有一行 ...
java流程控制练习题.pdf
07-21
初学者流程控制练习题
详解JAVA流程控制语句
08-30
Java流程控制语句是编程中不可或缺的部分，它们用于控制程序执行的顺序，使得代码可以根据不同的条件执行不同的路径。本文将详细讲解Java中的条件语句、循环语句，并给出实例解析。 首先，我们来看条件语句，它主要...
10.javaSE基础_JDBC编译程序(Driver+Statement+Connection+mysql数据库连接)
m0_61086522的博客
07-02 1208
JDBC是的缩写。它是Sun的Javasoft公司制定的Java数据库连接技术，是一套标准接口java.sql包中提供了JDBC API,通过它连接到各种数据库系统，编写访问数据库的程序。JDBC API不能直接访问数据库，它依赖于数据库厂商提供的JDBC Driver（JDBC驱动程序）
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 495
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
解决分布式环境下session共享问题
最新发布
shenxiaomo1688的博客
07-06 490
在分布式环境下，session会存在两个问题第一个问题:不同域名下，浏览器存储的jsessionid是没有存储的。比如登录时认证服务auth.gulimall.com存储了session，但是搜索服务search.gulimall.com是没有这个session的；
java 程序、进程 、线程，cpu，并行、并发、启动线程两种方式
gu2022_3_5_21_23的博客
07-02 300
Thread 方式 线程间不可以共享数据，除非变量加 static 变为 静态变量 （每次创建实例，会有一个新的副本）。条件二： 重写 Thread 父类方法 后创建实例调用 start 方法 （创建匿名子类的匿名对象）条件一： 将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。2、将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。最后调用的都是 Thread 的start 的方法。创建的线程对象，都是Thread类或其子类的实例。
第三章java流程控制语句.ppt
11-12
第三章Java流程控制语句介绍了Java语言中的流程控制语句的概念和分类。流程控制语句是用来控制程序中各语句执行顺序的语句，是程序中非常关键和基本的部分。通过流程控制语句，可以将单个的语句组合成有意义的、能够...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值