Java流程控制（基础）

最新推荐文章于 2024-09-06 18:47:44 发布
最新推荐文章于 2024-09-06 18:47:44 发布
阅读量149 收藏
点赞数
分类专栏： 狂神说java学习笔记 文章标签： java 开发语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43521718/article/details/126649377
版权
这篇博客详细介绍了Java的流程控制，包括Scanner用户交互、顺序结构、选择结构（if单选择、双选择、多选择、嵌套结构和switch）以及循环结构（while、do...while、for和增强for）。通过实例展示了各种结构的使用方法和场景。
摘要由CSDN通过智能技术生成

Java流程控制基础

用户交互Scanner

java.util.Scanner 。Java5的新特征，可以通过Scanner类来获取用户的输入输出。

基本语法：

Scanner s = new Scanner(System.in);

通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。

hasNext会等待程序输入完毕

next()：

  1. 一定要读取到有效字符后才可以结束输入。
  2. 对输入有效字符之前遇到的空白，next方法会自动将其去掉
  3. 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
  4. next()不能得到带有空格的字符串。
package com.star_line.scanner;

import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        //创建一个扫描对象，用于接受键盘数据in是输入，封装成scanner对象
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用next方法接收：");

        //判断用户有没有输入字符串
        if (scanner.hasNext()){
            String str = scanner.next(); //next接受用户输入
            System.out.println("输出的内容为：" + str);
        }

        scanner.close(); //凡是属于io流的类如果不关闭就会一直占用资源，要养成好习惯用完就关掉。

    }
}

使用next方法接收：
hello world!
输出的内容为：hello

进程已结束,退出代码0

nextLine()：

  1. 以enter为结束符，也就是说该方法返回的是输入回车前的所有字符。
  2. 可以有空白。
package com.star_line.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);
        }

        scanner.close();
    }
}

使用NextLine方式接收：
hello world!
输出的内容为：hello world!

进程已结束,退出代码0

package com.star_line.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();

    }
}

请输入数据：
欢迎来到狂神说java 希望大家一起学习
输出的内容为：欢迎来到狂神说java 希望大家一起学习

进程已结束,退出代码0

package com.star_line.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();
    }
}

请输入整数：
10
整数数据：10
请输入小数：
1.1
小数数据：1.1

进程已结束,退出代码0
请输入整数：
10.1
输入的不是整数！
请输入小数：
小数数据：10.1

进程已结束,退出代码0

package com.star_line.scanner;

import java.util.Scanner;

public class Demo05 {
    public static void main(String[] args) {
        //我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果。
        Scanner scanner = new Scanner(System.in);
        //and
        double sum = 0;
        //计算输入多少数字
        int m = 0;
        //通过循环判断是否还有输入，并在里面对每一次进行求和统计。
        while (scanner.hasNextDouble()){
            double x = scanner.nextDouble();//
            m = m + 1;//m++;
            sum = sum + x;
            System.out.println("你输入了第" + m + "个数据，当前结果sum= " + sum);
        }

        System.out.println(m + "个数的和为" + sum);
        System.out.println(m + "个数的平均值为" + (sum/m));

        scanner.close();
    }
}

10
你输入了第1个数据，当前结果sum= 10.0
20
你输入了第2个数据，当前结果sum= 30.0
30
你输入了第3个数据，当前结果sum= 60.0
40
你输入了第4个数据，当前结果sum= 100.0
x
4个数的和为100.0
4个数的平均值为25.0

进程已结束,退出代码0

顺序结构

java的基本结构是顺序结构。除非特别指明，否则一句句按顺序执行。

从上到下，依次执行。

任何一种算法都离不开的基本算法结构。

package com.star_line.struct;

public class ShunxuDemo {
    public static void main(String[] args) {
        System.out.println("hello1");
        System.out.println("hello2");
        System.out.println("hello3");
        System.out.println("hello4");
        System.out.println("hello5");
    }
}

选择结构*

if单选泽结构

语法：if（布尔表达式){

​ //如果布尔表达式为true，执行语句。

}

package com.star_line.struct;

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();

        //equas:判断字符串是否相等

        if (s.equals("Hello")){
            System.out.println(s);
        }

        System.out.println("End");
        scanner.close();
    }
}

请输入内容：
sdhk
End

进程已结束,退出代码0

请输入内容：
Hello
Hello
End

进程已结束,退出代码0

if双选择结构

if（布尔表达式）{

//布尔表达式为true

}else{

//布尔表达式为false

}

package com.star_line.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();
    }
}

请输入成绩：
60
不及格

进程已结束,退出代码0
请输入成绩：
80
及格

进程已结束,退出代码0

if多选择结构

if（布尔表达式1）{
1为true
}else if（布尔表达式2）{
2为true
}else if（布尔表达式3）{
3为true
}else{
以上表达式都不为true
}

package com.star_line.struct;

import java.util.Scanner;

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

        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();
    }
}

请输入成绩：
102
成绩不合法！

进程已结束,退出代码0
请输入成绩：
100
恭喜满分

进程已结束,退出代码0
请输入成绩：
75
C级

进程已结束,退出代码0
请输入成绩：
15
不及格

进程已结束,退出代码0

  • if语句至多有一个else语句，else语句在所有的else if语句之后。
  • if语句可以有若干个else if语句，它们必须在else语句之前
  • 一旦其中一个else if语句检测为 true，其他的else if以及else语句都将跳过执行。

if嵌套结构

if（布尔表达式1）{
1为true
if（布尔表达式2）{2为true}
}

思考：在1~100之间寻找一个数。
if和else if内部都可以嵌套。
所有的流程控制语句都能相互嵌套。

switch多选择结构

switch case语句判断一个变量与一系列值中某个值是否相等，每个值成为一个分支。

switch(expression){
	case value :
		//语句
		break;//可选
	case value :
		//语句
		break;//可选
	default : //可选
		//语句
}

switch变量类型：
byte、short、int、char
*string（jdk7）
case标签必须为字符串常量或字面量。

package com.star_line.struct;

public class SwitchDemo01 {
    public static void main(String[] args) {
        //case穿透。不加break，后续全部输出。 switch匹配一个具体的值
        char grade = 'B';
        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("未知等级");
        }
    }
}

及格
再接再厉
挂科

进程已结束,退出代码0

良好
及格
再接再厉
挂科
未知等级

进程已结束,退出代码0
良好

进程已结束,退出代码0

switch的反编译：
文件-结构-路径
打开路径-右键包-在文件夹打开-添加.class-

循环结构

while循环

while(布尔表达式){

//循环内容

}

不要表达式为true，循环一直执行。

大多数情况要让循环停止，需要一个让表达式失效的情况停滞循环。

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

循环条件一直为true会在撑死循环

package com.star_line.struct;

public class WhileDemo01 {
    public static void main(String[] args) {
        // 输出1~100

        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

进程已结束,退出代码0

思考：1+2+3+。。。。+100？

package com.star_line.struct;

public class WhileDemo03 {
    public static void main(String[] args) {
        //计算1+2+3+……+100？
        int i = 0;
        int sum = 0;

        while(i<=100){
            sum = sum + i;
            i++;
        }

        System.out.println(sum);
    }
}

5050

进程已结束,退出代码0

do…while 循环

do{

//代码

}while(布尔表达式)

do……while至少执行一次。

先执行后判断、先判断后执行

5050

进程已结束,退出代码0

package com.star_line.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);
    }
}

========================
0

进程已结束,退出代码0

package com.star_line.struct;

public class DOWhileDemo02 {
    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);
            a++;
        }while (a<0);
    }
}

for循环

在Java5中引入了一种主要用于数组的增强型for循环。

for是支持迭代的一种通用结构，是最有效最灵活的循环结构。

for循环执行的次数是在执行前就确定的。语法格式如下：

for（初始化条件;布尔表达式条件判断;更新迭代）{

//代码

}

package com.star_line.struct;

public class ForDemo01 {
    public static void main(String[] args) {
        int a = 1;//初始化条件
        while (a<=100){//条件判断
            System.out.println(a);//循环体
            a += 2;//迭代
        }
        System.out.println("while循环结束。");

        for (int i = 1;i <= 100;i++){//初始化条件;条件判断;迭代
            System.out.println(i);
        }
        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
51
53
55
57
59
61
63
65
67
69
71
73
75
77
79
81
83
85
87
89
91
93
95
97
99
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
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
for循环结束。

进程已结束,退出代码0

快捷键（for(int i=0;i<100;i++)）100.for+enter

  • 关于for循环的说明：
  • 最先执行初始化步骤。可以声明一种类型，但可以初始化一个或多个循环控制变量，也可以是空语句。
  • 然后检测布尔表达式的值。如果为true，循环体被执行；如果为false，循环中止，执行循环体后面的语句。
  • 执行一次循环后，更新循环控制变量（迭代因子控制循环变量的增减）
  • 再次检测布尔表达式，执行上述过程。
  • for(i=0;i<100;i++)
    for(;i<100;i++)
    for(;;i++)死循环1
    for(;;)死循环2

练习1：计算从0~100之间的奇数和偶数的和。

package com.star_line.struct;

public class ForDemo02 {
    public static void main(String[] args) {
        //test1: 计算从0~100之间的奇数和偶数的和。
        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

进程已结束,退出代码0

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

package com.star_line.struct;

public class ForDemo03 {
    public static void main(String[] args) {
        //用while或for循环输出1~1000之间能被5整除的数，并且每行输出3个。
        for (int i = 0; i < 1000; i++) {
            if (i%5 == 0){
                System.out.print(i+"\t");
            }
            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
进程已结束,退出代码0

练习3：打印九九乘法表。

请添加图片描述

进程已结束,退出代码0

进程已结束,退出代码0

  1. 打印第一列
  2. 把第一列扩展到九列
  3. 去掉重复项，i<=j
  4. 调整样式。
package com.star_line.struct;
/*九九乘法表*/
public class ForDemo04 {
    public static void main(String[] args) {
        for (int j = 1; j <= 9; j++) {
            for (int i = 1; i <= j; i++) {
                System.out.print(j + "*" + i + "=" +(i*1) + "\t");
            }
            System.out.println();
        }

    }
}

练习4：倒着打印九九乘法表。

  1. 打印第一列
  2. 把第一列扩展到九列
  3. 去掉重复项，i<=j
  4. 调整样式。
package com.star_line.struct;
/*
* 练习4：倒着打印九九乘法表。
9*1 9*2 ... 9*9
8*1 8*2 ...8*8
* ...
* 1*1
1. 打印第一列
2. 把第一列扩展到九列
3. 去掉重复项，i<=j
4. 调整样式。*/
public class ForDemo041 {
    public static void main(String[] args) {
        for (int j = 9; j >= 1; j--) {
            for (int i = 1; i <= j; i++) {
                System.out.print(j + "*" + i + "=" + (j*i) +"\t");
            }
            System.out.println();
        }

    }
}

请添加图片描述

增强for循环

遍历数组和集合（Java5）

for（声明语句：表达式）{//代码}

package com.star_line.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

进程已结束,退出代码0

break continue

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

continue用于循环语句体中，用于中止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否循环的判定。

关于goto关键字

Java保留了这个关键字，但是java没有goto。break和continue能看出一些goto的影子，像是带标签的break和continue。

“标签”是后面跟一个：的标识符，如label：

对Java来说唯一用到标签的地方在循环语句之前。然而在循环前设置标签的唯一理由是：我们希望在循环中嵌套其他的循环，由于break和continue通常只中断当前循环，但是若随标签使用，它们就会中断到标签所在的位置。

package com.star_line.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;
            }
        }

        System.out.println("123");
    }
}

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
123

进程已结束,退出代码0

package com.star_line.struct;

public class ContinueDemo {
    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

进程已结束,退出代码0

continue请假，break辞职，return换个星球生活=)

练习课：

打印一个五行的等边三角形。

先打印半个，再打印另一半。

public class TestDemo {
    public static void main(String[] args) {
        //打印三角形，5行
        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();
        }
    }
}

打印菱形◇

package com.star_line.struct;

public class TestDemo {
    public static void main(String[] args) {
        //打印菱形，5行
        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();


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

请添加图片描述

star_line！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java流程控制语句
weixin_50394022的博客
07-20 1322
Java流程控制语句分为顺序结构、分支结构（if，switch）、循环结构(for、while、do...while)3大部分。
java基础-流程控制
weixin_43772772的博客
07-19 143
流程控制 一.顺序结构 概念：程序的运行步骤与代码的书写顺序一致； 二.分支结构 if 、else 2.1 单if结构 格式： if（条件表达式）{ 语句a } 语句b 逻辑：判断条件是否满足，如果满足执行语句a,再执行语句b；反之，直接执行语句b。 2.2 标准的if-else if(条件){ 语句a }else{ 语句b } 语句c 逻辑：条件满足，执行语句a,反之，执行语句b，语...
Java Scanner用法
qq_43098249的博客
12-04 1584
java.util.Scanner 是 Java5 的新特征，我们可以通过 Scanner 类来获取用户的输入。 Scanner用法： Scanner demo = new Scanner(System.in); Scanner实例： /* * * 从控制台输入 * **/ import java.util.Scanner; public class Scannertest { public static void main(String[] args) {.
【Java基础教程】详解Java三种流程控制语句
hacker707的博客
04-18 6649
持续更新Java基础教程，和hacker一起卷起来
Java 基础-流程控制
weixin_63309052的博客
10-28 466
Scanner扫描器对象 用户交互Scanner new Scanner(System.in)快捷键alt+enter输出 Scanner scanner = new Scanner(System in); //创建一个扫描仪对象, 用于接收键盘数据 System.out.println(“使用next方式接收”); if (scanner.hasNext()){ //判断用户有没有输入字符串 String str = scanner.next(); //使用next方式接收 System.out.prin
Java流程控制.md
05-13
Java流程控制，包含Scanner调用方法和简单，顺序结构，基础循环，还有简单debug方法（没有详细介绍debug，文档里有链接，其他大大有总结好的）
Java基础入门自学课件 第05章 流程控制（共17页）.ppt
08-29
Java基础入门自学课件 第05章 流程控制 流程控制是Java编程语言中非常重要的一个概念，它决定了程序的执行流程和逻辑结构。流程控制可以分为两大类：顺序结构、选择结构和循环结构。 顺序结构 顺序结构是最基本的...
Java零基础入门之流程控制与数组
06-15
让学员掌握流程控制语句，并提供实例练习；学习java中的常用关键字break 和 continue, return关键字；通过案例让学员掌握数组及多维数组 本课程是《Java零基础至高级应用》系统课程的第三章，全套课程精细讲解，...
java基础流程控制卡.zip
11-30
Java基础流程控制是编程中的重要概念，它涉及到程序执行的顺序、条件判断和循环操作。在Java中，流程控制语句使得我们能够按照特定逻辑编写复杂的程序。对于初学者来说，掌握这些基础知识至关重要，因为它们构成了...
【JavaWeb】JDBC&Druid&Tomcat入门使用
lklalmq的博客
09-04 978
预编译SQL语句并执行：预防SQL注入问题获取 PreparedStatement 对象// SQL语句中的参数值，使用？占位符替代?// 通过Connection对象获取，并传入对应的sql语句设置参数值上面的sql语句中参数使用?进行占位，在之前之前肯定要设置 这些?的值。PreparedStatement对象：setXxx(参数1，参数2)：给?赋 值Xxx：数据类型；如 setInt (参数1，参数2)参数：参数1：？的位置编号，从1 开始参数2：？的值执行SQL语句。
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1143
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
nmt---Docker-compose自动化部署
qq_69920145的博客
09-03 1005
static-rr 权重, leastconn 最少连接, source 请求IP, 轮询 roundrobin。# 这⾥是容器中的IP地址，由于配置的是轮询roundrobin，weight 权重其实没有⽣效。# 这⾥是容器中的IP地址，由于配置的是轮询roundrobin，weight 权重其实没有⽣效。# 在 mysql 创建⼀个没有权限的haproxy⽤户，密码为空。# 在 mysql 创建⼀个没有权限的haproxy⽤户，密码为空。10. docker-compose移除容器。
在Java Web开发中，如何保障应用的安全性？请列举常见的安全策略和措施。请解释Spring框架中的事务管理，包括声明式事务和编程式事务。
weixin_53180424的博客
09-03 958
在实际开发中，声明式事务管理因其非侵入性和易维护性而更受欢迎。它允许开发者将注意力集中在业务逻辑上，而不是事务管理的细节上。然而，在某些特殊场景下，编程式事务管理可能提供更灵活的控制力。因此，在选择事务管理方式时，应根据实际需求和场景来决定。
计算机毕业设计选题推荐-任务管理系统-项目任务分配系统-Java/Python项目实战
IT研究室的博客
09-03 807
随着信息化技术的迅猛发展，各类企业和组织越来越依赖于高效的任务管理系统以保证其日常运营的顺利进行。根据IDC（国际数据公司）发布的报告显示，全球企业在数字化转型上的投入已达数千亿美元，其中相当一部分资金用于提升企业内部的管理效率。任务管理系统作为企业信息化的重要组成部分，能有效帮助企业分配、监控和反馈任务，从而提高工作效率。然而，尽管市场上已有多种任务管理系统，它们在功能、用户体验和适用性上存在显著差异。
数据访问：JPA
hhgh_的博客
09-02 1010
其二，Sun希望整合ORM 技术，实现统一的 API调用接口。@Table（name=“”,catalog=“”,schema=“”）可选，用来标注一个数据库对应的实体类，数据库中创建的表明默认和类名一致，通常和@Entity配合使用，只能标注在实体的class定义处，表示实体对应的数据库表的信息。@Entity(name=“EntityName”)必须，用来标注一个数据库表对应的实体，数据库中创建的表明默认和类名一致，其中，name可选，对应数据库中的一个表，使用此注解标记Pojo是一个JPA实体。
MapStruct-Java实体转换利器
m0_63622279的博客
09-02 518
MapStruct 是一个用于生成映射器接口的代码生成库，主要用于简化 Java 对象之间的转换过程。在处理不同模型之间数据转换时，MapStruct 可以自动生成实现类减少手工转换逻辑的工作量。使用场景：各种模型之间的转换。BODTOVOPOJO引入mapstruct的pom依赖定义mapper接口（注意，这里不是MyBatis的Mapper哦），使用@Mapper注解标记，并在接口中声明映射方法。编写映射方法，（从xxxO转换为yyyO,模型之间的转换）在业务层中使用Mapper。
JavaWeb（基于SpringBoot开发）全总结（1）
2302_81420820的博客
09-02 993
再到spring boot中去设置，当我们遇到报错不要紧，我们直接再复制我们在DG上面写的sql语句，到idea那个数据库那里再运行一次，2.由于使用不同开发工具开发出来的略有不同，导致不能够互通，所以国际规定，使用maven创建的项目为统一标准结构，也就是下图所示的结构。还有我们写的案例里面的mapper层写的sql语句的新增，删除，等等操作，都是基于mybatis来实现的。例如：传入的是路径参数，json格式的参数等等，根据不同的参数我们使用不同的注解。
java后端开发-Mybatis连接数据库步骤
weixin_73355603的博客
09-02 1913
🎙座右铭：得之坦然，失之淡然。💎擅长领域：前端是的，我需要您的：是我持续下去的动力！先看看目录，是不是IDEA的配置，数据库mysql或者其他的数据库这套方法都适合的。
SpringBoot总结
最新发布
2302_77073236的博客
09-06 44
都做成图了，方便理解和掌握全局关系。
Java流程控制基础：理解if-else与switch语句
理解并熟练掌握这些流程控制语句是Java编程的基础，它们能够帮助开发者构建复杂的逻辑结构，使程序更具可读性和灵活性。通过实践和深入学习，程序员可以灵活运用这些控制结构来实现所需的功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值