Java流程控制1-6

最新推荐文章于 2024-07-19 17:37:28 发布
最新推荐文章于 2024-07-19 17:37:28 发布
阅读量52 收藏
点赞数 2
分类专栏： 学习笔记 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MoonLurker/article/details/132167973
版权

Java流程控制1-12

1.Scanner 对象

0.基本语法：

  • 之前我们学的基本语法中我们并没有事先程序和人的交互，但是Java给我们提供了这样一个工具类，我们可以获取用户的输入。java.until.Scanner是Java5的新特征，我们可以通过Scanner类来获取用户的输入

  • 基本语法：

    Scanner xxxxxxx = new Scanner(System.in)
   类    函数名

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

  • ps:可以直接输入new Scanner(System.in)，点击alt+enter自动补全语法。

1.next():

  1. 一定要读取到有效字符后才可以结束输入

  2. 对输入有效字符之前遇到的空白，next()方法会自动将其去掉

  3. 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符

  4. next()不能得到带有空格的字符串

Demo01
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

2.nextLine():

  1. 以Enter为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符
  2. 可以获得空白
Demo02
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!

3.省去if判断的Scanner

Demo03
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  从入门到精通

2.Scanner进阶使用

4.对输入是否为整数，小数的判断

Demo4
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("输出的不是整数数据！");
            scanner.nextLine(); // 清空输入缓冲区，避免第一个整数判断输入的数字影响到第二个小数判断
        }

        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

//错误输入
请输入整数：
10.1
输出的不是整数数据！
请输入小数：
5.65
小数数据：5.65

5.求和与平均数

Demo05

(思考题)自己做

import java.util.Scanner;

public class Demo05 {
    public static void main(String[] args) {
        //我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确定，通过输入非数字来结束输入并输出执行结果：
        Scanner scanner = new Scanner(System.in);

        //和
        double sum = 0;
        //计算输入了多少个数字
        int num = 0;

        System.out.println("Please press enter after every time you enter numbers,enter a non numeric to get the sum and average of them:");

        //通过循环判断是否还有输入，并在里面对每一次进行求和和统计
        while(scanner.hasNextDouble()){
            sum += scanner.nextDouble();
            num++;
            if(num!=1) {
                System.out.println("You have already entered " + num + " numbers.Now, the sum of the numbers is " + sum);
            }else{
                System.out.println("You have already entered " + num + " number.Now, the sum of the number is " + sum);//这里没必要这样写if else，写一个sout就行，只是我犯病而已
            }
        }
        System.out.println("Get"+num+"numbers,The sum of numbers is:"+sum);
        System.out.println("Get"+num+"numbers,The average of numbers is:"+(sum/num));

        scanner.close();
    }
}

Please press enter after every time you enter numbers,enter a non numeric to get the sum and average of them:
9.9
You have already entered 1 number.Now, the sum of the number is 9.9
7.4
You have already entered 2 numbers.Now, the sum of the numbers is 17.3
15.2
You have already entered 3 numbers.Now, the sum of the numbers is 32.5
39.87
You have already entered 4 numbers.Now, the sum of the numbers is 72.37
x
Get4numbers,The sum of numbers is:72.37
Get4numbers,The average of numbers is:18.0925

3.顺序结构

1.顺序结构展示

SequentialStructureDemo
public class SequentialStructureDemo {
    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");
        System.out.println("Hello6");
    }
}

Hello1
Hello2
Hello3
Hello4
Hello5
Hello6

4.选择结构

1.if选择结构

1.if单选择结构

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

  • 语法：

    if(布尔表达式){
    //如果布尔表达式为true将执行的语句
}
ifDemo01
import java.util.Scanner;

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

        System.out.println("请输入内容：");
        String str =scanner.nextLine();

        //equals:判断字符串是否相等
        if(str.equals("Hello")){
            System.out.println(str);
        }
        
        System.out.println("End");
        scanner.close();
    }
}

请输入内容：
Bye
End

请输入内容：
Hello
Hello
End
2.if双选择结构

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

  • 语法

    if(布尔表达式){
    //如果布尔表达式的值为true
}else{
    //如果布尔表达式的值为false
}
ifDemo02
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的值为ture执行代码
}else if(布尔表达式2){
    //如果布尔表达式2的值为ture执行代码
}else if(布尔表达式3){
    //如果布尔表达式3的值为ture执行代码
}else{
    //如果以上布尔表达式都不为为ture执行代码
}
ifDemo03
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 语句，它们必须在els语句之前。
        一旦其中有一个else if 语句检测为true，其他的else if 以及elsee 语句都将跳过执行。
         */
        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();
    }
}
4.嵌套的if结构

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

  • 语法

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

  • 思考？我们需要寻找一个数，在1-100之间

    //目标：将目标输入的数字判断是1-100中的哪一个数字
/*思路：
1.接收用户输入,如果不属于1-100则返回数字不合法
2.判断1-50/51-100
3.1-25/26-50|51-75/76-100
4.……二分法
*/

  • ps:所有的流程控制语句都可以相互嵌套，而互不影响

2.switch选择结构

  • 多选择结构还有一个实现方式就是switch case 语句。

  • switch case 语句判断一个变量与一系列值中某个值是否想的，每个值称为一个分支。

  • 语法

    switch(expression){
    case value1 :
        //语句
        break;//可选
    case value2 :
        //语句
        break;//可选
    //你可以有人以数量多case语句
    default ://可选（默认值）
        //语句
}

  • switch 语句中的变量类型可以是：

​ 1.byte , short , int 或者 char

​ 2.从Java SE 7开始

​ 3.swich 支持字符串 String 类型了

​ 4.同时 case 标签必须为字符串常量或字面量

SwitchDemo01
public class SwitchDemo01 {
    public static void main(String[] args) {
        //switch 匹配一个具体的值
        char grade = 'C';

        switch(grade){
            case'A':
                System.out.println("优秀");
                break;//可选
            //如果不写 break ，在当前 case 匹配选项后将会把后面所有 case 输出
            //即 case 穿透
            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("未知等级");
        }
    }
}

ps:在一个case或default的整段语句没对齐的情况下，可以将这段语句选中，点击shift+tab或ctrl+alt+L来进行自动对齐。

SwitchDemo02
public class SwitchDemo02 {
    public static void main(String[] args) {
        String name = "张伟";

        switch(name){
            case("张伟"):
                System.out.println("张伟");
                break;
            case("李雷"):
                System.out.println("李雷");
                break;
            case("韩梅梅"):
                System.out.println("韩梅梅");
                break;
            default:
                System.out.println("你在干啥？");
                break;
        }
    }
}

5.循环结构

1.while 循环

  • while是最基本的循环，它的结构为：

    while(布尔表达式){
    //循环内容
}

  • 只要布尔表达式为 true ，循环就会一直执行下去

  • 我们大多数情况是会让循环停止下来的，我们需要一个让表达式失效的方式来结束循环

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

  • 循环条件一直为true就会造成无限循环【死循环】，我们正常的业务编程中尽量避免死循环。会影响程序性能或者造成程序卡死崩溃！

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

        int i = 0;

        while(i<100){
            i++;
            System.out.println(i);
        }
    }
}
WhileDemo02
public class WhileDemo02 {
    public static void main(String[] args) {
        //死循环
        while(true){
            //等待客户端连接
            //定时检查
            //……
        }
    }
}
  • 思考：计算1+2+3+……+100=？
WhileDemo03
public class WhileDemo03 {
    public static void main(String[] args) {
        int i=0;
        int sum=0;

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

        System.out.println("1-100的和是："+sum);
    }
}

2.do-while循环

  • 对于while语句而言，如果不满足条件，则不能进入循环。但有的时候我们需要即使不满足条件，也至少执行一次。

  • do…while 循环和while 循环相似，不同的是，do…while 循环至少会执行一次。

    do{
    //代码语句
}while(布尔表达式)；

  • while和do-while的区别：

​ 1.while先判断后执行。do-while是先执行后判断。

​ 2.Do-while总是保证循环体会被至少执行一次。这是它们的主要差别。

DoWhileDemo01
public class DoWhileDemo01 {
    public static void main(String[] args) {
        int i = 0;
        int sum = 0;

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

        System.out.println(sum);
    }
}
DoWhileDemo02
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);
    }
}

==============
a

3.for循环

  • 虽然所有的循环结构都可以用 while 或者 do-while 表示，但 Java 提供了另一种语句——for 循环，使一些循环结构变得更加简单。

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

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

    for(初始化；布尔表达式；更新){
    //代码语句
}
ForDemo01
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循环结束！");
        
        /*
        关于for 循环有以下几点说明：

        最先执行初始化步骤，可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
        然后，检测布尔表达式的值。如果为true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
        执行一次循环后，更新循环控制变量（迭代因子控制循环变量的增减）。
        再次检测布尔表达式，循环执行上面的过程。
         */
    }
}

快捷写法：输入100.for点击回车，自动生成for(int i=0;i<100;i++){}

  • 练习1：计算0到100之间的奇数和偶数的和
ForDemo02
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);
    }
}
  • 练习2：用while或for循环输出1-1000之间能被5整除的书，并且每行输出3个
ForDemo03
public class ForDemo03 {
    public static void main(String[] args) {
        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.println("\n");
           }
        }
        //println 输出完会换行
        //print 输出完不会换行
    }
}
  • 练习3：打印九九乘法表
ForDemo04
/*目标
1*1=1	
1*2=2	2*2=4	
1*3=3	2*3=6	3*3=9	
1*4=4	2*4=8	3*4=12	4*4=16	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81
 */

public class ForDemo04 {
    public static void main(String[] args) {
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j + "*" + i + "=" + (i * j) + "\t");
            }
            System.out.println();
        }
    }
}

增强for循环：

  • Java5 引入了一种主要用于数组或集合的增强型 for 循环

  • Java 增强 for 循环语法格式如下：

    for(声明语句：表达式)
{
    //代码句子
}

  • 声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

  • 表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

ForDemo05
public class ForDemo05 {
    public static void main(String[] args) {
        int [] numbers = {10,20,30,40,50};//定义了一个数组

        //普通for写法
        for (int i = 0; i < 5; i++) {
            System.out.println(numbers[i]);
        }
        System.out.println("=====================");

        //遍历数组的元素
        //遍历numbers[]中的数字时，赋值给x
        for(int x:numbers){
            System.out.println(x);
        }
    }
}

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

4.break continue

  • break 在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。（break语句也在switch语句中使用）
  • continue 语句用在循环语句体中，用于终止当次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

BreakDemo

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

  • 关于goto关键字

    • goto关键字很早就在程序设计语言中出现，尽管goto仍是Java的一个保留字，但并没在语言中得到证实使用；Java没有goto。然而，在break和continue这两个关键字上，我们仍然能看出一些goto的影子—带标签的break和continue。
    • “标签”是指后面跟一个冒号的标识符，例如：label:
    • 对Java来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于break和continue关键字通常值中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。
    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

6.打印三角形以及Debug

TestDemo

public class TestDemo {
    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();
        }
    }
}

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

Debug

使用debug的方式，可以一步一步地看到程序是怎么运行的

MoonLurker
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java流程控制
qq_42847094的博客
03-30 119
Java流程控制 文章目录Java流程控制一、Scanner对象（输入）1.next():2.nextLine();3.int , short , float , double ，long，各类型输入二、顺序结构三、选择结构1.if单选择结构2.if 双选择结构3.if 多选择结构4.嵌套的if结构5.switch多选择结构四、循环结构1.while 循环2. do ... while 循环3.f...
Java流程控制语句-顺序结构
热门推荐
ThinkWon的博客
09-28 2万+
定义 顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的 举例 /* * 顺序结构：从上往下，依次执行 */ public class OrderDemo { public static void main(String[] args) { System.out.println("开始"); System.out...
Java流程控制语句-循环结构
ThinkWon的博客
09-28 2万+
定义 循环语句就是在满足一定条件的情况下反复执行某一个操作。包括while循环语句、do···while循环语句和for循环语句。 分类 for循环语句 执行流程 执行流程图 执行流程说明 A:执行初始化语句 B:执行判断条件语句，看其结果是true还是false 如果是false，循环结束。 如果是true，继续执行。 C:执行循环体语句 D:执行控制条件语句 E:回到B继续 格式 for(初...
【Java基础教程】详解Java三种流程控制语句
hacker707的博客
04-18 6616
持续更新Java基础教程，和hacker一起卷起来
Java流程控制顺序结构原理解析
08-25
Java流程控制顺序结构原理解析 Java流程控制 顺序结构是 Java 编程语言中最基本的流程控制结构之一。它按照代码的编写顺序，从上往下依次执行语句，这种结构非常简单易懂，但却是 Java 编程语言中最基本的流程控制...
Java流程控制.md
05-13
Java流程控制，包含Scanner调用方法和简单，顺序结构，基础循环，还有简单debug方法（没有详细介绍debug，文档里有链接，其他大大有总结好的）
java郑java03-流程控制.rar
07-01
java郑java03-流程控制.rar
关于Java中流程控制的复习
06-27
Java中的流程控制是编程的基础，它允许我们根据特定条件决定程序执行的路径。流程控制主要包含选择结构、循环结构、循环控制语句以及在多重循环中的应用。 **选择结构**： 1. **单分支结构**：`if`语句是最基本的...
Java流程控制.docx
05-13
以下是关于Java流程控制的一些关键知识点： 1. **Scanner类**：Scanner类是Java中用于输入操作的类，可以从System.in（标准输入流，通常是键盘）获取用户输入。基本语法是`Scanner s = new Scanner(System.in)`。...
Java内存模型
最新发布
weixin_44267758的博客
07-19 320
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 614
JVM-垃圾回收与内存分配
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 855
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
【Java算法】前缀和 下
2302_79806056的博客
07-18 906
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
Java 中有哪几种基本数据类型？请分别列出它们并简述每种数据类型的特点及其在内存中的占用空间？
liangzai215的专栏
07-15 510
在Java的世界里，数据是构建应用程序的基石。为了高效地处理这些数据，Java设计了一系列基础数据类型，它们直接映射到计算机硬件上，因此在性能和内存使用上更为高效。我们常说的Java八大基本数据类型，涵盖了整数、浮点数、字符和布尔值，下面我将一一介绍它们的特点以及在内存中的占用空间，并通过简单的代码实例来加深理解。
构建自动化的精粹：Gradle任务依赖性与执行顺序控制
liuxin33445566的博客
07-15 584
本文以"构建自动化的精粹：Gradle任务依赖性与执行顺序控制"为题，详细介绍了任务依赖性的重要性、基本配置、多个任务的依赖性、条件依赖性、错误处理、高级用法、多项目构建中的任务依赖性。随着Gradle的不断发展，我们可以预见到更多关于任务依赖性和构建自动化的高级特性的出现，这将进一步扩展Gradle的构建能力，满足更复杂的项目构建需求。任务依赖性定义了任务之间的执行关系，确保了在构建过程中，任务能够按照预期的顺序执行。任务是一个特殊的任务，它默认依赖于所有没有显式排除的任务。方法来指定任务的依赖性。
maven项目容器化运行之1-基于1Panel软件将docker镜像构建能力分享给局域网
qq_37372909的博客
07-15 531
docker核心功能包括镜像的构建和容器的运行，它可以开放端口将镜像构建的能力暴露。docker daeson就是docker的守护进程，开放能力是通过指定docker守护进程监听端口来实现的。后面开发人员就可以通过maven中docker插件来远程调用docker镜像构建能力了。
Java实验2
qq_64727229的博客
07-16 520
类的封装、继承、多态和接口（1）有理数四则运算（2）最终得分
对androidTestDebug 产物进行重新签名
shuizhizhiyin的专栏
07-19 279
在运行 gradle assembleAndroidTestDebug 任务后，自定义的 reSignAndroidTestDebug 任务将会被执行，并对子模块的 androidTestDebug 产物进行重新签名。your_keystore_path.jks、your_keystore_password、your_key_alias 和 your_key_password 需要替换为你的实际路径和密码。如果需要对其他子模块的产物进行重新签名，可以根据需要创建不同的自定义任务。// 设置密钥库密码。
Java流程控制：if-else条件判断
"Java流程控制，包括if-else条件结构的三种形式，以及在不同条件下的执行逻辑。通过示例解释了如何根据年龄判断人的年龄段，并提供了与购车决策相关的条件判断练习。同时，提到了在解决学校运动会百米赛跑决赛资格...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值