🌸个人主页:https://blog.csdn.net/2301_80050796?spm=1000.2115.3001.5343
🏵️热门专栏:🍕 Collection与数据结构 (92平均质量分)https://blog.csdn.net/2301_80050796/category_12621348.html?spm=1001.2014.3001.5482
🧀线程与网络(96平均质量分) https://blog.csdn.net/2301_80050796/category_12643370.html?spm=1001.2014.3001.5482
🍭MySql数据库(93平均质量分)https://blog.csdn.net/2301_80050796/category_12629890.html?spm=1001.2014.3001.5482
🍬算法(97平均质量分)https://blog.csdn.net/2301_80050796/category_12676091.html?spm=1001.2014.3001.5482
感谢点赞与关注~~~
✒️ 今天开始,Java基本语法模块将进行重构.以保证文章质量.
目录
- [1. 逻辑控制](#1. 逻辑控制)
-
- [1.1 顺序结构](#1.1 顺序结构)
- [1.2 分支结构](#1.2 分支结构)
-
- [1.2.1 if语句](#1.2.1 if语句)
- [1.2.2 switch语句](#1.2.2 switch语句)
- [1.3 循环结构](#1.3 循环结构)
-
- [1.3.1 while循环](#1.3.1 while循环)
- [1.3.2 break](#1.3.2 break)
- [1.3.3 continue](#1.3.3 continue)
- [1.3.4 for循环](#1.3.4 for循环)
- [1.4 输入与输出](#1.4 输入与输出)
-
- [1.4.1 输出到控制台](#1.4.1 输出到控制台)
- [1.4.2 从键盘输入](#1.4.2 从键盘输入)
- [2. 方法的使用](#2. 方法的使用)
-
- [2.1 方法的概念与使用](#2.1 方法的概念与使用)
-
- [2.1.1 什么是方法](#2.1.1 什么是方法)
- [2.1.2 方法的定义](#2.1.2 方法的定义)
- [2.1.3 方法调用的执行过程](#2.1.3 方法调用的执行过程)
- [2.1.4 实参和形参的关系](#2.1.4 实参和形参的关系)
- [2.2 方法的重载](#2.2 方法的重载)
-
- [2.2.1 方法重载的概念](#2.2.1 方法重载的概念)
- [2.2.2 方法签名](#2.2.2 方法签名)
- [2.3 递归](#2.3 递归)
-
- [2.3.1 递归的概念](#2.3.1 递归的概念)
- [2.3.2 递归执行过程分析](#2.3.2 递归执行过程分析)
1. 逻辑控制
1.1 顺序结构
顺序结构比较简单,按照代码书写一行一行地执行就可以.
java
System.out.println("aaa");
System.out.println("bbb");
System.out.println("ccc");
// 运行结果
//aaa
//bbb
//ccc1.2 分支结构
1.2.1 if语句
-
语法格式1
if(布尔表达式){
// 语句
}
如果布尔表达式结果为true，执行if中的语句，否则不执行.
-
语法格式2
if(布尔表达式){
// 语句1
}else{
// 语句2
}
如果布尔表达式结果为true，则执行if中语句，否则执行else中语句.
-
语法格式
if(布尔表达式1){
// 语句1
}else if(布尔表达式2){
// 语句2
}else{
// 语句3
}
表达式1成立，执行语句1，否则表达式2成立，执行语句2，否则执行语句3.
建议\] if/else语句下只有一条语句的时候,可以不加花括号,此时的else和**最接近的if匹配**.但是实际开发中,我们不建议这样写,最好加上大括号. ```java int x = 10; int y = 10; if (x == 10) if (y == 10) System.out.println("aaa"); else System.out.println("bbb");//虽然和第3行的if对齐,但是是和第4行的if匹配. ``` #### 1.2.2 switch语句 * 基本语法: switch(表达式){ case 常量值1:{ 语句1; [break;] } case 常量值2:{ 语句2; [break;] } ... default:{ 内容都不满足时执行语句; [break;] } } * 执行流程 1. 先计算表达式的值 2. 和case依次比较，一旦有响应的匹配就执行该项下的语句，直到遇到break时结束 3. 当表达式的值没有与所列项匹配时，执行default. * 注意事项 * 多个case后的常量值不可以重复 * switch的括号内不能是以下类型的数据:**float,double,boolean,long**. * **break不要遗漏,否则就会失去多分支选择的效果**. ### 1.3 循环结构 #### 1.3.1 while循环 * 语法格式 while(循环条件){ 循环语句; } 循环条件为 true, 则执行循环语句; 否则结束循环. \[建议
- 和if类似,while下面可以不写花括号,但是不写的时候只能支持一条语句,建议还是加上花括号.
- 和if类似,while后面的{建议和while写在同一行.
1.3.2 break
break 的功能是让循环提前结束.
示例:找到 100 - 200 中第一个 3 的倍数
java
int num = 100;
while (num <= 200) {
if (num % 3 == 0) {
System.out.println("找到了 3 的倍数, 为:" + num);
break;
}
num++;
}1.3.3 continue
continue 的功能是跳过这次循环, 立即进入下次循环.
示例:找到 100 - 200 中所有 3 的倍数
java
int num = 100;
while (num <= 200) {
if (num % 3 != 0) {
num++;
continue;
}
System.out.println("找到了 3 的倍数, 为:" + num);
num++;
}执行到 continue 语句的时候, 就会立刻进入下次循环(判定循环条件), 从而不会执行到下方的打印语句.
1.3.4 for循环
-
基本语法
for(表达式①;布尔表达式②;表达式③){
表达式④;
} -
表达式1: 用于初始化循环变量初始值设置，在循环最开始时执行，且只执行一次
-
表达式2: 循环条件，满则循环继续，否则循环结束
-
表达式3: 循环变量更新方式
注意事项\] 和while类似,不再赘述
1.4.1 输出到控制台
- 基本语法
java
System.out.println(msg); // 输出一个字符串, 带换行
System.out.print(msg); // 输出一个字符串, 不带换行
System.out.printf(format, msg); // 格式化输出- println 输出的内容自带 \n, print 不带 \n
- printf 的格式化输出方式和C 语言的 printf 是基本一致的.
示例:
java
System.out.println("hello world");
int x = 10;
System.out.printf("x = %d\n", x)1.4.2 从键盘输入
使用 Scanner 读取字符串/整数/浮点数.
举例说明:
java
import java.util.Scanner; // 需要导入 util 包
Scanner sc = new Scanner(System.in);
System.out.println("请输入你的姓名：");
String name = sc.nextLine();
System.out.println("请输入你的年龄：");
int age = sc.nextInt();
System.out.println("请输入你的工资：");
float salary = sc.nextFloat();
System.out.println("你的信息如下：");
System.out.println("姓名: "+name+"\n"+"年龄："+age+"\n"+"工资："+salary);
sc.close(); // 注意, 要记得调用关闭方法解释:
- 创建一个Scanner类型的对象,使用sc引用.
- 之后调用sc中的next()系列的方法.
- next():返回字符串,自动消除有效字符之前的空格,直到结束符.(换行)
- nextLine():返回字符串,不会自动消除空格,录入所有的字符,直到回车.
- nextInt():返回十进制整数.
- nextFloat():返回浮点数.
- sc实质上是一个流对象的引用,我们在最后需要关闭.
2. 方法的使用
2.1 方法的概念与使用
2.1.1 什么是方法
方法就是一个代码片段. 类似于 C 语言中的 "函数".
- 是能够模块化的组织代码(当代码规模比较复杂的时候).
- 做到代码被重复使用, 一份代码可以在多个位置使用.
- 让代码更好理解更简单.
- 直接调用现有方法开发, 不必重复造轮子.
2.1.2 方法的定义
-
语法格式
修饰符 返回值类型 方法名称([参数类型 形参 ...]){
方法体代码;
[return 返回值];
}
示例:判断一个年份是否是闰年
java
public class Method{
// 方法定义
public static boolean isLeapYear(int year){
if((0 == year % 4 && 0 != year % 100) || 0 == year % 400){
return true;
}else{
return false;
}
}
}注意事项
- 修饰符：现阶段直接使用public static 固定搭配
- 返回值类型：如果方法有返回值，返回值类型必须要与返回的实体类型一致，如果没有返回值，必须写成void,注意这里的返回值 和c语言有所不同,这里返回的参数还可以是数组类型.
- 方法名字：采用小驼峰命名
- 参数列表：如果方法没有参数，()中什么都不写，如果有参数，需指定参数类型，多个参数之间使用逗号隔开
- 方法体：方法内部要执行的语句
- 在java当中，方法必须写在类当中
- 在java当中，方法不能嵌套定义.
2.1.3 方法调用的执行过程
调用方法--->传递参数--->找到方法地址--->执行被调方法的方法体--->被调方法结束返回--->回到主调方法继续往下执行
- 方法参数传递的注意事项
- 匹配参数的个数
- 匹配参数的类型
- 匹配参数的顺序
- 匹配返回值的类型
2.1.4 实参和形参的关系
方法的形参相当于数学函数中的自变量，比如：1 + 2 + 3 + ... + n的公式为sum(n) = (1+n)*n/2.
Java中方法的形参就相当于sum函数中的自变量n，用来接收sum函数在调用时传递的值的。形参的名字可以随意取，对方法都没有任何影响，形参只是方法在定义时需要借助的一个变量，用来保存方法在调用时传递过来的值.
java
public static int getSum(int N){ // N是形参
return (1+N)*N / 2;
}
getSum(10); // 10是实参,在方法调用时，形参N用来保存10
getSum(100); // 100是实参，在方法调用时，形参N用来保存100注意\] 在Java中，实参的值永远都是**临时拷贝到形参中** ,形参和实参本质是两个实体. 代码实例:交换两个整形变量. ```java public class TestMethod { public static void main(String[] args) { int a = 10; int b = 20; swap(a, b); System.out.println("main: a = " + a + " b = " + b); } public static void swap(int x, int y) { int tmp = x; x = y; y = tmp; System.out.println("swap: x = " + x + " y = " + y); } } // 运行结果 //swap: x = 20 y = 10 //main: a = 10 b = 20 ``` 可以看到，在swap函数交换之后，形参x和y的值发生了改变，但是main方法中a和b还是交换之前的值，即没有交换成功. * 原因解释: 实参a和b是main方法中的两个变量，其空间在main方法的栈(一块特殊的内存空间)中，而形参x和y是swap方法中的两个变量，x和y的空间在swap方法运行时的栈中，因此：实参a和b 与 形参x和y是两个没有任何关联性的变量，在swap方法调用时，只是将实参a和b中的值拷贝了一份传递给了形参x和y，因此对形参x和y操作不会对实参a和b产生任何影响.  \[总结\] 对于基础类型来说,形参相当于实参的拷贝.即传值调用. * 解决办法 使用引用类型参数.(比如数组) ```java public class TestMethod { public static void main(String[] args) { int[] array = {10, 20}; swap(array); System.out.println("array[0] = " + array[0] + " array[1] = " + array[1]); } public static void swap(int[] arr) { int tmp = arr[0]; arr[0] = arr[1]; arr[1] = tmp; } } // 运行结果 //arr[0] = 20 arr[1] = 10 ```  ### 2.2 方法的重载 #### 2.2.1 方法重载的概念 在Java中，如果多个方法的名字相同，参数列表不同，则称该几种方法被重载了. 参数列表不同一般指的是:个数,数据类型,或者是顺序不同. **返回值的类型是否一样,不影响方法的重载** .即只有方法的名字是一样的,**参数列表必须修改,返回值类型可以修改** . 举例:下面这几个方法就相互构成重载. ```java public class TestMethod { public static void main(String[] args) { add(1, 2); // 调用add(int, int) add(1.5, 2.5); // 调用add(double, double) add(1.5, 2.5, 3.5); // 调用add(double, double, double) } public static int add(int x, int y) { return x + y; } public static double add(double x, double y) { return x + y; } public static double add(double x, double y, double z) { return x + y + z; } } ``` #### 2.2.2 方法签名 在同一个作用域中不能定义两个相同名称的标识符。比如：方法中不能定义两个名字一样的变量，那为什么类中就可以定义方法名相同的方法呢？ 方法签名即：经过编译器编译修改过之后方法最终的名字。具体方式：方法全路径名+参数列表+返回值类型，构成方法完整的名字。 ### 2.3 递归 #### 2.3.1 递归的概念 从前有坐山，山上有座庙，庙里有个老和尚给小和尚将故事，讲的就是： "从前有座山，山上有座庙，庙里有个老和尚给小和尚讲故事，讲的就是： "从前有座山，山上有座庙..." "从前有座山......"  上面这个故事有一个特征:**自身中又包含了自己** .我们从而引出递归的概念. 一个方法在执行过程中调用自身, 就称为 "递归". 递归的必要条件: * 将原问题划分为其子问题.但**子问题和原问题的解法相同**. * 递归结束条件 示例:递归求n的阶乘 ```java public static void main(String[] args) { int n = 5; int ret = factor(n); System.out.println("ret = " + ret); } public static int factor(int n) { if (n == 1) { return 1; } return n * factor(n - 1); // factor 调用函数自身 } // 执行结果 //ret = 120 ``` #### 2.3.2 递归执行过程分析 我们还是那上面n的阶乘来说明: ```java public static void main(String[] args) { int n = 5; int ret = factor(n); System.out.println("ret = " + ret); } public static int factor(int n) { System.out.println("函数开始, n = " + n); if (n == 1) { System.out.println("函数结束, n = 1 ret = 1"); return 1; } int ret = n * factor(n - 1); System.out.println("函数结束, n = " + n + " ret = " + ret); return ret; } // 执行结果 //函数开始, n = 5 //函数开始, n = 4 //函数开始, n = 3 //函数开始, n = 2 //函数开始, n = 1 //函数结束, n = 1 ret = 1 //函数结束, n = 2 ret = 2 //函数结束, n = 3 ret = 6 //函数结束, n = 4 ret = 24 //函数结束, n = 5 ret = 120 //ret = 120 ``` 