2.Java语言基础——流程控制语句与方法

最新推荐文章于 2024-09-08 11:09:43 发布
最新推荐文章于 2024-09-08 11:09:43 发布
阅读量284 收藏
点赞数 1
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39004315/article/details/109669286
版权
本文深入介绍了Java中的流程控制语句，包括顺序结构、选择结构（if和switch）、循环结构（for、while和do...while），以及控制跳转语句（break、continue和return）。同时，文章还探讨了方法的概念、格式、调用以及方法重载的原理，为读者提供了丰富的代码示例和实践应用。
摘要由CSDN通过智能技术生成

2.Java语言基础——流程控制语句与方法

一、流程控制语句

A:什么是流程控制语句
	在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。
	也就是说程序的流程对运行结果有直接的影响。所以，我们必须清楚每条语句的执行流程。
	而且，很多时候我们要通过控制语句的执行顺序来实现我们要完成的功能
B:流程控制语句的分类
	顺序结构
	选择结构
	循环结构

1.顺序结构

A：顺序结构
	是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行
	程序中大多数的代码都是这样执行的
	总的来说：写在前面的先执行，写在后面的后执行
B:执行流程：
	从上往下，依次执行

2.选择结构

A:选择结构的分类
	if语句
	switch语句
B:if语句有几种格式
	格式1
	格式2
	格式3

选择结构if语句格式1:
A:if语句的格式1
	if(比较表达式或者是boolean类型的值) {
		语句体;
	}
B:执行流程：
		先计算比较表达式的值，看其返回值是true还是false。
		如果是true，就执行语句体；
		如果是false，就不执行语句体；

选择结构if语句格式2:
A:if语句的格式2

	if(比较表达式) {
		语句体1;
	}else {
		语句体2;
	}

	注意事项：else后面是没有比较表达式的，只有if后面有。

B:执行流程：
	首先计算比较表达式的值，看其返回值是true还是false。
	如果是true，就执行语句体1；
	如果是false，就执行语句体2；

选择结构if语句格式3:
A:if语句的格式3：
	if(比较表达式1) {
		语句体1;
	}else if(比较表达式2) {
		语句体2;
	}else if(比较表达式3) {
		语句体3;
	}
	...
	else {
		语句体n+1;
	}
B:执行流程：
	首先计算比较表达式1看其返回值是true还是false，
	如果是true，就执行语句体1，if语句结束。
	如果是false，接着计算比较表达式2看其返回值是true还是false，
	
	如果是true，就执行语句体2，if语句结束。
	如果是false，接着计算比较表达式3看其返回值是true还是false，
	...
	
	如果都是false，就执行语句体n+1。

注意事项： 当只要有一个条件满足时，if语句结束。else是可以省略，但是不建议省略

package org.westos.java;

public class MyDemo {
    public static void main(String[] args) {
        int x=10;
        int y=20;
        int z=30;
        int max;
        if(x>y){
            if(x>z){
                max=x;
            }else{
                max=z;
            }
        }else{
            if(y>z){
                max=y;
            }else{
                max=z;
            }
        }
        System.out.println(max);
    }
}

选择结构switch语句的格式：
A:switch语句的格式
	switch(表达式){
		case 值1:
			语句体1;
			break;
		case 值2:
			语句体2;
			break;
		case 值3:
			语句体3;
			break;
		....
		default：	
			语句体n+1;
			break;
	}
B:switch语句的格式解释
	(1):switch表示这是switch语句
		表达式的取值：byte,short,int,char
		JDK5以后可以是枚举(什么是枚举，以后再讲)
		JDK7以后可以是String
	(2):case后面跟的是要和表达式进行比较的值
	(3):语句体部分可以是一条或多条语句
	(4):break表示中断，结束的意思，可以结束switch语句
	(5):default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似

选择结构switch语句的注意事项：
	a:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的值
	b:default可以省略吗?
		可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。
	c:break可以省略吗?
		可以省略，但是结果可能不是我们想要的。
		会出现一个现象：case穿透。
		int x = 2;
	    int y = 3;
	    switch(x){
		   default:
			   y++;
		    case 3:
			   y++;
		   case 4:
			   y++;
	     }
	     System.out.println("y="+y);   //输出 y=6
		 最终我们建议不要省略
	d:default一定要在最后吗?
		不是，可以在任意位置。但是建议在最后。
	e:switch语句的结束条件
		a:遇到break就结束了
		b:执行到末尾就结束了

3.循环结构

A:什么是循环结构
	循环语句可以在满足循环条件的情况下，反复执行某一段代码，
	这段被重复执行的代码被称为循环体语句，
	当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，
	从而结束循环，否则循环将一直执行下去，形成死循环
B:循环结构的分类
	for循环
	while循环
		while语句
		do...while语句

循环结构for语句的格式:
A:循环结构for语句的格式：
	for(初始化表达式语句;判断条件语句;控制条件语句) {
		循环体语句;
	}
B:执行流程：
	a:执行初始化表达式语句
	b:执行判断条件语句,看其返回值是true还是false
		如果是true，就继续执行
		如果是false，就结束循环
	c:执行循环体语句;
	d:执行控制条件语句
	e:回到B继续。	
C: 注意事项:
	初始化表达式语句只执行一次

package org.westos.java;

/*A:案例演示
        需求：请在控制台输出数据1-10
        需求：请在控制台输出数据10-1*/
public class MyDemo {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            System.out.println(i);
        }
        for (int i = 10; i >= 1; i--) {
            System.out.println(i);
        }
        for (int i = 1; i <= 10; i++) {
            System.out.println(11-i);
        }
    }
}

package org.westos.java;

/*
A:案例演示:	需求：求出1-10之间数据之和
        B:学生练
        需求：求出1-100之间偶数和
        需求：求出1-100之间奇数和
*/

public class MyDemo {
    public static void main(String[] args) {
        int sum1=0;
        int sum2=0;
        int sum3=0;
        for (int i = 1; i <= 10; i++) {
            sum1=sum1+i;
        }
        System.out.println("1-10的和："+sum1);
        for (int i = 1; i <= 100; i++) {
            if(i%2==0){
                sum2+=i;
            }else{
                sum3+=i;
            }
        }
        System.out.println("1-100偶数和："+ sum2);
        System.out.println("1-100奇数和："+ sum3);
    }
}

package org.westos.java;

/*
A:案例演示
	需求：在控制台输出所有的”水仙花数”

	所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。
	举例：153就是一个水仙花数。
	153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153
B:案例演示:    需求：统计”水仙花数”共有多少个
*/

public class MyDemo {
    public static void main(String[] args) {
        int n=0;
        for (int i = 100; i <= 999; i++) {
            int ge=i/1%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);
                n+=1;
            }
        }
        System.out.println(n);
    }
}

循环结构while语句的格式：
A:while循环的基本格式：
		while(判断条件语句) {
			循环体语句;
		}
	完整格式：
	    初始化条件语句;
	    while(判断条件语句) {
			 循环体语句;
			 控制条件语句;
	   }
B:执行流程：
	a:执行初始化条件语句;
	b:执行判断条件语句,看其返回值是true还是false
		如果是true，就继续执行
		如果是false，就结束循环
	c:执行循环体语句;
	d:执行控制条件语句
	e:回到b继续.

package org.westos.java;

/*
	需求：在控制台输出10次"helloworld"
	需求：请在控制台输出数据1-10
*/

public class MyDemo {
    public static void main(String[] args) {
        int i=1;
        while (i<=10){
            System.out.println(i+"hello world");
            i++;
        }

        int a=1;
        while (a<=10){
            System.out.println(a);
            a++;
        }
    }
}

package org.westos.java;

/*
A:求和思想:	求1-100之和
B:统计思想:	统计”水仙花数”共有多少个
*/

public class MyDemo {
    public static void main(String[] args) {
        int i=1;
        int s=0;
        while (i<=100){
            s+=i;
            i++;
        }
        System.out.println(s);

        int j=100;
        int n=0;
        while(j<=999){
            int ge=j/1%10;
            int shi=j/10%10;
            int bai=j/100%10;
            if(ge*ge*ge+shi*shi*shi+bai*bai*bai==j){
                n+=1;
            }
            j+=1;
        }
        System.out.println(n);
    }
}

循环结构do...while语句的格式：
A:do...while循环的基本格式：
	do {
			循环体语句;
		}while(判断条件语句);
	
	完整格式:
		初始化条件语句;
		do {
			循环体语句;
			控制条件语句;
		}while(判断条件语句);
B:执行流程：
	a:执行初始化条件语句;
	b:执行循环体语句;
	c:执行控制条件语句;
	d:执行判断条件语句,看其返回值是true还是false
		如果是true，就继续执行
		如果是false，就结束循环
	e:回到b继续。

package org.westos.java;

/*
C:案例演示
	需求：在控制台输出10次"helloworld"
	需求：请在控制台输出数据1-10
*/

public class MyDemo {
    public static void main(String[] args) {
       int i=1;
       int j=1;
       do{
           System.out.println(i+"hello world");
           i+=1;
       }while(i<=10);

       do{
           System.out.println(j);
           j+=1;
       }while(j<=10);
    }
}



注意事项：
A:三种循环语句的区别:
	(1):do...while循环至少执行一次循环体。
		而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。
	(2):A:如果你想在循环结束后，继续使用控制条件的那个变量，用while循环,否则用for循环。
		  不知道用for循环,因为变量及早的从内存中消失，可以提高内存的使用效率。
		B:建议优先考虑for循环，然后是while循环 ，最后是do...while循环
B:一定要注意控制条件语句控制的那个变量的问题，不要弄丢了，否则就容易死循环。
C:两种最简单的死循环格式
	while(true){...}
	for(;;){...}

package org.westos.java;

/*
A:案例演示
	需求：请输出一个4行5列的星星(*)图案。
	如图：
		*****
		*****
		*****
		*****
	注意：
		System.out.println("*");和System.out.print("*");的区别
*/

public class MyDemo {
    public static void main(String[] args) {
        for (int i = 1; i <= 4; i++) {
            for (int j = 1; j <= 5; j++) {
                System.out.print("*");
            }
            System.out.print("\n");
        }
       }
}

package org.westos.java;

/*
A:案例演示
	需求：请输出下列的形状
	*
	**
	***
	****
	*****
*/

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

package org.westos.java;

/*
A:案例演示
	需求：在控制台输出九九乘法表。
B:代码优化
	注意：
	'\x' 	x表示任意，这种做法叫转义字符。

	'\t'	tab键的位置
	'\n'	换行
*/

public class MyDemo {
    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+"="+j*i+"\t");
            }
            System.out.print("\n");
        }
       }
}


A:什么是控制跳转语句
	前面我们已经说过了，Java中的goto是保留字，目前不能使用。
	虽然没有goto语句可以增强程序的安全性，但是也带来很多不便。
	比如说，我想在某个循环执行到某一步的时候就结束，现在就做不了这件事情。
	为了弥补这个缺陷，Java就提供了break，continue和return来实现控制语句的跳转和中断。
B:控制跳转语句的分类
	break 中断
	continue 继续
	return 返回 

A:break的使用场景
	(1):在选择结构switch语句中
	(2):在循环语句中
	注意：离开使用场景的存在是没有意义的
B:作用
	a:退出单层循环
	b:退出多层循环(几乎不使用)
		要想实现这个效果，就必须知道一个东西;带标签的语句；
		格式：标签名：语句

package org.westos.java;


public class MyDemo {
    public static void main(String[] args) {
        a:for(int x=1; x<=3; x++) {
            for (int i = 1; i <= 3; i++) {
                if(i==2){
                    break;
                }
                System.out.println("java");//输出java三次
            }

            }
       }
}

package org.westos.java;

/*
退出多层循环，使用标签
*/

public class MyDemo {
    public static void main(String[] args) {
        a:for(int x=1; x<=3; x++) {
            for (int i = 1; i <= 3; i++) {
                if(i==2){
                    break a;
                }
                System.out.println("java");//输出java一次
            }

            }
       }
}

A:continue的使用场景
	(1):在循环语句中
	(2):离开使用场景的存在是没有意义的
B:作用
	a:跳出一次循环，执行下一步操作

package org.westos.java;

/*
C:练习题
	for(int x=1; x<=10; x++) {
		if(x%3==0) {
			//在此处填写代码
		}
		System.out.println(“Java基础班”);
	}

	我想在控制台输出2次:“Java基础班“
	我想在控制台输出7次:“Java基础班“
	我想在控制台输出13次:“Java基础班“
*/

public class MyDemo {
    public static void main(String[] args) {
        int n=0;
        for(int x=1; x<=10; x++) {
            if(x%3==0) {
                //在此处填写代码
                break;//2
                //continue;//7
                /*System.out.println("java");//13
                n+=1;*/
            }
            System.out.println("java");
            n+=1;
        }
        System.out.println(n);
       }
}

A:return的作用
	return 就是退出一个方法。
	跳转到上层调用的方法。这个在方法的使用那里会在详细的讲解。
B:案例演示
	return: 		结束当前方法
	break:		    结束单层循环
	continue:		结束当前循环，执行下一次循环

二、方法

A:什么是方法
	方法就是完成特定功能的代码块
	在很多语言中都有函数的定义，但是在咱们JAVA语言中，我们将其称之为方法。
B:方法的格式
	修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2 ....){
		方法体;
		return 返回值;
	}
C:方法的格式详细说明
	(1): 修饰符 			比较多,后面会详细介绍。目前使用  public static
	(2): 返回值类型 		用于限定返回值的数据类型
	(3): 方法名			就是一个名称，它的存在是为了方便我们调用方法
	(4): 参数类型 		限定调用方法时传入参数的数据类型
	(5): 参数名 			是一个变量，接收调用方法时传入的参数
	     (这个参数其实有一个专业的名词,被称之为形式参数,它的作用是用来接收实际参数的.)
	(6): 方法体 			完成功能的代码
	(7): return 		结束方法以及返回方法指定类型的值 
	(8): 返回值 			就是功能的结果，由return带回，带回给调用者

package org.westos.java;

/*
A:需求：求两个数据之和的案例
*/

public class MyDemo {
    public static void main(String[] args) {
        int sum = sum(5, 6);
        System.out.println(sum);
    }
    public static int sum(int a,int b){
        return a+b;
    }
}

package org.westos.java;

/*
A:案例演示:	需求：获取两个数中的较大值
B:案例演示:	需求：比较两个数是否相等
使用键盘录入改进
*/

import java.util.Scanner;

public class MyDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("输入第一个数字");
        double x = sc.nextDouble();
        System.out.println("输入第二个数字");
        double y = sc.nextDouble();
        double max = max(x, y);
        boolean compare = compare(x, y);
        if (compare){
            System.out.println("两个数相等");
        }else {
            System.out.println("两个数不相等，最大值是："+max);
        }
    }
    public static double max(double a,double b){
        double max=a>b?a:b;
        return max;
    }
    public static boolean compare(double a,double b){
        return a==b;
    }
}

方法的注意事项:
A:	方法不调用不执行
B:	方法与方法是平级关系，不能嵌套定义
C:	方法定义的时候参数之间用逗号隔开
D:	方法调用的时候不用再传递数据类型，实参可以是常量，也可以是变量
E:	如果方法有明确的返回值，一定要由return带回一个值

package org.westos.java;

/*
A:案例演示
	需求：根据键盘录入的行数和列数，在控制台输出星形
*/

import java.util.Scanner;

public class MyDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入行数");
        int x = sc.nextInt();
        System.out.println("请输入列数");
        int y = sc.nextInt();
        show(x,y);
    }
    public static void show(int x,int y){
        for (int i = 1; i <= x; i++) {
            for (int j = 1; j <= y; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
        return;
    }
}

package org.westos.java;

/*
A:案例演示:	需求：根据键盘录入的数据输出对应的乘法表
*/

import java.util.Scanner;

public class MyDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入乘法表大小");
        int x = sc.nextInt();
        multiplicationTable(x);
    }
    public static void multiplicationTable(int x){
        for (int i = 1; i <= x; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j+"*"+i+"="+j*i+"\t");
            }
            System.out.println();
        }
    }
}



方法重载：
在同一个类中，允许存在一个以上的同名方法。

允许条件：
只要它们的参数列表不同，与返回值无关，不拿返回值类型来区分。

其中参数列表不同包含：
A:参数个数不同
B:参数类型不同

package org.westos.java;

/*
方法重载
*/

import java.util.Scanner;

public class MyDemo {
    public static void main(String[] args) {
        sum(1,2);//输出 int
    }
    public static void sum(int a,int b){
        System.out.println("int");
        return;
    }
/*    public static int sum(int a,int b){
          return a+b;
      }*/

    public static void sum(double a,int b){
        System.out.println("double");
        //return a+b;
    }
    public static int sum(int a,int b,int c){
        return a+b+c;
    }
    public static void sum(byte a,int b){
        System.out.println("byte");
    }
}
孑孓莎
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Scala—— 2. 流程控制
01-20
在Scala编程语言中，流程控制是程序设计的基本要素，它涉及到如何根据特定条件来决定程序的执行路径。本文将深入探讨Scala中的流程控制结构，主要包括表达式、键盘输入、分支和循环。 首先，我们来看表达式。Scala...
六java的作业流程控制.docx
11-24
它是 Java 编程语言的基础部分，决定了程序的执行流程和结果。 一、次序结构 次序结构是指 Java 程序的基本执行结构。它是指程序语句的执行顺序，或者说是语句出现的前后顺序。Java 程序的执行是根据程序平台的...
Java语言基础--流程控制语句
小乔与你同在
11-18 121
1 顺序结构语句 程序自上而下执行。 System.out.println("1"); System.out.println("2"); System.out.println("3"); 2 判断结构语句 格式一： if ( 条件表达式 ) { 语句序列; } 条件表达式：决定是否进行循环或判断的表达式，其结果为booolean类型，也就是条件表达式结果要么为true，要么为fal...
03-java入门-流程控制语句
asd747571569的博客
07-14 170
学习目标 1、掌握键盘录入类Scanner的基本使用 2、掌握三种if分支语句结构、执行流程以及使用 3、掌握switch分支语句结构、执行流程以及使用 4、掌握Eclipse工具的debug调试使用 第1章 数据输入 数据输入是程序获取指获取用户键盘录入的数据，那么在java语言中，怎样实现呢？ 我们可以通过 Scanner 类来获取用户的输入。 1.1 Scanner类的使用 1.1.1 导包 使用import关键字导包，在类的所有代码之前导包，引入要使用的类型，java.lang包下的所有类无需导入
Java基础：（四）流程控制语句和方法介绍
地球村
05-27 286
本文概述 流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块 其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：顺序结构、分支结构和循环结构，如下图所示： 目录结构 顺序结构 选择结构（if-else、switch） 循环结构（while、do-while、for） 跳转（break、continue、return） 多重循环 方法（定...
c#switch语句判断成绩_Java基础篇(03)：流程控制语句，和算法应用
weixin_32243793的博客
12-26 220
一、分支语句流程控制语句对任何一门编程语言都是非常重要的，Java中基于流程控制程序执行的不同步骤和代码块。1、IF条件IF条件语句会根据不同的判断条件执行不同的语句，if后括号内的条件是否成立关键步骤，IF条件的判断结果必然要是true或false。IF...Else语句则是满足IF条件，就执行相应代码块，否则就执行Elase代码块。public class Process01 { pu...
java有几种流程控制语句_java-04流程控制语句
weixin_39613712的博客
02-27 1374
这里先简单介绍几种流程控制语句 包括if/if-else、switch语句1.三大流程控制结构所谓流程控制，就是说要控制程序的执行方式，根据不同的情况执行不同的代码，从而得到不同情况下的不同结果。首先，我们先了解一下常见的三大流程结构：顺序，分支和循环1.1 顺序结构：顺序结构是这几种结构中最简单的一种结构，其含义就是按顺序执行。就像我们在在做一件事的时候，要有一定的步骤，我们就要按照这个步骤一步...
Java 流程控制语句——分支结构
业余幻想家的博客
08-17 1510
Java 流程控制语句——分支结构
Java 流程控制语句——循环结构
业余幻想家的博客
08-18 1280
Java 流程控制语句——循环结构
java基础语法——条件判断与循环语句
zywcxz的博客
01-26 2316
java基础语法——条件判断与循环语句
精通Python（基础篇）——流程控制语句
NowNow的博客
04-08 1960
本篇介绍三种组织结构：顺序结构、选择结构和循环结构。
Java语言——条件判断if语句和switch语句
班的博客
05-16 4590
Java语言学习04——控制语句（循环、条件判断）条件语句if语句案例三目运算符if语句的嵌套使用switch语句小结：if与switch的区别 条件语句 在Java中条件的判断语句目前有两种if语句和switch语句。 if语句 简单的if语句 格式： if( 条件表达式 ){ 代码块 } 当条件表达式的结果为true时执行if大括号里的代码块，否则跳过 if…else语句 格式： i...
学习java基础(2)循环语句for、while、do...while（csdn）————程序.pdf
12-05
在Java中，循环语句是控制程序流程的重要工具，它们允许我们重复执行一段代码直到满足特定条件为止。本篇文章将深入探讨Java中的三种主要循环语句：for、while和do...while。 首先，我们来看`for`循环。在Java中，`...
java——基础程序设计
03-08
Java 基础程序设计是 Java 编程语言的基础知识，包括 Java 语言的基本知识、Java 控制语句、Java 循环语句、Java 数组等。 一、Java 语言基础知识 Java 语言是一种面向对象的编程语言，由 James Gosling 等人在 ...
spring事务详细讲解-深入浅出
小电玩
09-08 347
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
最新发布
m0_63550220的博客
09-08 1339
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1326
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
自定义Stater
m0_63624484的博客
09-07 669
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
基于JavaWeb开发的JavaSpringboot+Vue实现前后端分离房屋租赁系统
央顺科技官方博客
09-05 519
2021年处于信息科技高速发展的大背景之下。在今天，缺少手机和电脑几乎已经成为不可能的事情，人们生活中已经难以离开手机和电脑。针对增加的成本管理和操作,各大商家非常有必要建立自己的网上房屋租赁平台系统，这既可以让更多的人体验到网络所带来的方便，也有助于提高房屋的租赁。在经过几十年的高速发展后，互联网已成为最流行、最普及的媒体，每天的信息流量甚至能比得上过去十年。其以便捷的信息交换、快速的沟通速度，悄然地改变着会员的消费方式。
Java语言基础：流程控制与关键概念
"该资源是关于Java编程的课件，主要涵盖了流程控制的三大结构——顺序结构、分支结构和循环结构，并对Java语言基础进行了详细讲解，包括标识符、关键字、基本数据类型、运算符、表达式和语句、方法、变量的作用域...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值