一.注释
//单行注释
/*
多行注释
*/
/**
文档注释
*/
二.关键字
- 在java中，被Java语言赋予了特殊含义，用作专门用途的字符串
- 关键字所有都为小写
- 例：public class static void
三.常量
| 常量类型 | 说明 |
|---|---|
| 字符串常量 | 双引号括起来的内容 |
| 整数常量 | 不带小数的数字 |
| 小数常量 | 带小数的数字 |
| 字符常量 | 单引号括起来的内容 |
| 布尔常量 | true、false |
| 空常量 | null |
四.数据类型
数据类型内存占用和取值范围：
ASCII码：100---->‘d’
五.变量
存放数据的，并且存放的数据是可以发生改变的
1.变量按声明位置（作用范围）：
-
局部变量：在方法中声明的变量，在当前声明距离最近的大括号内使用
-
成员变量：在方法外面声明的变量 或者 在类中声明的变量，在当前类中可以直接使用
六.标识符
标识符定义规则：
七.类型转换
类型转换分几种：
自动类型转换：
强制类型转换：
八.运算符
算数运算符
注意：1. 在Java中，当两个操作数都是整数类型时，则运算结果就是整数类型
2.在Java中，当有一个操作数是小数类型，则运算结果就是小数类型
-
+
class Operator{ public static void main(String[] args){ System.out.println(10 + 20);//两个数都是数值 System.out.println("123" + 22);//两个数其中一个以上为字符串类型 } }- 当有两个操作数都是数值时（整数、小数），则+作求和
- 当有一个操作数是字符串类型时，则+作连接、拼接，最终结果为字符串类型的值
-
-
class Operator{ public static void main(String[] args){ System.out.println(10 - 2);//在Java中，减号-只能做减法运算 } } -
*
class Operator{ public static void main(String[] args){ System.out.println(8 * 8); } } -
/
class Operator{ public static void main(String[] args){ System.out.println(10 / 2);//5 System.out.println(11 / 2);//5 //1.在Java中，当两个操作数都是整数类型时，则运算结果就是整数类型（不进行四舍五入） System.out.println(10.0 / 2);//5.0 //2.在Java中，当有一个操作数是小数类型，则运算结果为小数类型 } } -
% 取余数
class Operator{ public static void main(String[] args){ System.out.println(10 % 2);//0 System.out.println(10.0 % 2);//0.0 System.out.println(10 % 3);//1 } } -
++ 表示自身加一
class Operator{ public static void main(String[] args){ int a = 10; int b = ++a *2;//a = 11 b = 22 /*前置++:将++编写在变量名称前面； 先自身加1，然后再做其他运算 */ int x = 10; int y = x++ *2;//x = 11 y = 20 /*后置++：将++编写在变量名称后面； 先做其他运算，然后再自身加1 */ } } -
– 表示自身减一
class Operator{ public static void main(String[] args);{ int a = 10; int b = --a *2;//a = 9 b = 18 /*前置--:将--编写在变量名称前面； 先自身减1，然后再做其他运算 */ int x = 10; int y = x-- *2;//x = 9 y = 20 /*后置--：将--编写在变量名称后面； 先做其他运算，然后再自身减1 */ } }
连接运算符
+
-
求和、连接
-
当是字符串进行拼接时，变量值的位置不同，结果不一样
赋值运算符
=
- 将等号右侧的值赋值给等号左侧的变量名称
扩展赋值运算符
- += 加等 、-=减等 、*= 乘等、 /= 除等 、 %= 取余等
class Operator{
public static void main(String[] args){
int a =8;
a = a + 8//该条语句等价于 a += 8
int a = 0,b = 123;
a = a * 10 + b % 10; //a = 3
//上面一条语句是否等价于如下代码？ ---不等价
a *= 10 + b % 10; //a = 0
//结果a = 0 其实该条语句等价于a = a * (10 + b % 10);
int a =123;
a += 5.97;//a = 128
//注意：再Java中，当使用扩展赋值运算符，最终不会改变左侧变量的数据类型，
//并且不会进行四舍五入。
//但是 a = 123 + 5.97 编写错误，小数不能直接给整数类型赋值,需要强制k
int x = 123;
x -= 10; //x = 113
x *= 10; //x = 1230
x /= 10; //x = 12
x %= 10; //x = 3
}
}
关系运算符
- <、>、<=、>=、==（等等于）、!=(不等于)
class Operator08{
public static void main(String[] args){
/*
关系运算符
如果满足条件(条件成立)，则结果为true(真的),否则结果为false(假的)
*/
System.out.println(1 > 2); //false
System.out.println(10 < 20); //true
System.out.println(12 % 2 >= 6); //false
System.out.println(10 % 3 <= 3); //true
System.out.println(18 / 9 == 0); //false
System.out.println(21 / 7 != 6 / 2); //false
}
}
### == 与equals()区别：
1. **==**
判断左右两边内存中存放的是否一致
2. **equals()**
当是字符串类型时，如果比较内容(值)则使用equals()方法完成
逻辑运算符
1.逻辑与 &
class Operator{
public static void main(String[] args){
/*逻辑与&
也就是：当两个条件都满足（成立）时，则结果为true,否则为false
*/
System.out.println(5 >= 3 & 8 != 9);//true
System.out.println(11 < 22 & 0 > 5);//false
}
}
2.逻辑或 |
class Operator{
public static void main(String[] args){
//逻辑或| :当有一个条件为true，则结果为true,否则为false
System.out.println(100 / 10 >= 0 | 1 < 2); //true
System.out.println(6 % 2 == 3 | 18 / 3 == 0); //false
System.out.println(20 % 5 == 4 | 14 / 2 == 7); //true
}
}
3.逻辑异或 ^
class Operator{
public static void main(String[] args){
//逻辑异或：相同false，不同结果为true
/*true ^ true 则结果为false
true ^ false 则结果为true
false ^ false 则结果为false
false ^ true 则结果为true
*/
System.out.println(10 != 20 ^ 5 % 4 ==1);//false
System.out.println(3 <= 2 ^ 6 < 7);//true
}
}
4.逻辑非 !
class Operator{
public static void main(String[] aegs){
//对true 或者false 取反
System.out.println(!true);//false
System.out.rintln(!!true);//true
System.out.println(!(1 < 2 ));//false
}
}
5.短路与 &&
class Operator{
public static void main(String[] args){
/*通过运行得到结论：
1.短路与和逻辑与的执行结果都一样
2.无论是短路与还是逻辑与都是与，都表示并且、同时
3.短路与和逻辑与的执行过程可能不同
当使用短路与时，并且第一个条件为false时，则结果直接为false
4.因此：使用短路与执行速度相对更快或者执行效率更高
5.建议使用：短路与
*/
System.out.pringln(15 <= 16 && 2 > 1);//true
System.out.println(1 == 0 && 5 <= 9); //false
}
}
6.短路或 ||
class Operator{
public static void main(String[] args){
/*1.短路与和逻辑或的执行都一样
2.短路或和逻辑或都表示或者
3.当使用短路或时，如果第一个条件为true时，则结果直接为true
4.因此得到：使用短路或执行速度可能更快或者执行效率更高
5.建议使用：短路或
*/
System.out.println(9 > 8 || 1 < 0);//true
}
}
三目运算符（难点）
-
语法格式：条件 ？代码 1 : 代码 2
三目运算符的执行过程：
- 先判断条件，如果条件为true，则执行代码1，否则执行代码2
三木运算符什么时候使用？
- 当是二选一时，则就可以使用三目运算符完成；
- 当是多选一时，则就可以使用三目嵌套完成
class Operator{
public static void main(String[] args){
/*练习1：判断100大于18？
分析得到：
1.该题的结果：大于
2.该题有两种情况，要么是大于，要么是不大于，但是最终只得到一个结果
因此该题也就是二选一，就可以使用三目运算符完成
3.三目运算符的语法格式：条件 ? 代码1 : 代码2
*/
System.out.println(100 > 88 ? "大于" : "不大于");
}
}
class Operator{
public static void main(String[] args){
/*练习2：判断12是奇数还是偶数
分析得到：
1.该题结果是偶数
2.因此得到：该题是二选一，要么是奇数，要么是偶数，则就可以使用三目运算符完成
3.也就是：当前这个数除以2的余数如果为0，则表示能被2整除，也就是偶数
则编写为:12 % 2 == 0
*/
int num = 12;
System.out.println(num % 2 == 0 ? num + "是偶数" : num + "是奇数");
}
}
位运算符
| 位运算符 | 细节 |
|---|---|
| << | 空位补0，被移除的高位丢弃，空缺位补 0 |
| >> | 被移位的二进制最高位是0 ，右移后，空缺位补 0；最高位是1 ，空缺位补 1 。 |
| >>> | 被移位二进制最高位无论是0 或者是 1 ，空缺位都用 0 补。 |
| & | 二进制位进行运算，只有 1&1 时结果是 1 ，否则是 0; |
| | | 二进制位进行|运算，只有 0 |0 时结果是 0 ，否则是 1; |
| ^ | 相同二进制位进行^ 运算，结果是 0 1^1=0 , 0^0=0； 不相同二进制位^ 运算结果是 1 。 1^0=1 , 0^1=1 |
| ~ | 正数取反，各二进制码按补码各位取反 负数取反，各二进制码按补码各位取反 |
九.键盘接受用户输入（重点、难点）
- 当该题中有未知数时，则就可以使用键盘接收用户输入完成
- 使用时值相对灵活
//第一步：导入包，必须位于当前Java源文件所有类的最前面
//注意：一个Java源文件中只需要编写一次导入包即可
import java.util.Scanner;//还可以编写为import java.util.*;
class Input{
public static void main(String[] args){
//第二步：创建Scanner对象
//注意：一个方法中只编写一次创建Scanner即可
Scanner input = new Scanner(System.in);
//第三步：友好提示
System.out.println("请输出第一个整数：");
//第四步：接受键盘输入
//当按回车键，则表示键盘输入完毕
int num = input.nextInt();
System.out.println("num = " + num);
}
}
import java.util.*;//还可以编写为import Java.util.*;
class Input01{
public static void main(String[] args){
//练习一：输入某个学生的信息，并输出所有的信息
Scanner input = new Scanner(System.in);
System.out.println("请输入姓名")；
String a = input.next();//再String中next后没有东西
System.out.println("请输入性别")；
String b = input.next();
System.out.println("请输入年龄")；
int c = input.nextInt();
System.out.println("请输入身高");
double d = input.nextDouble();//输入double类型写法
System.out,println("请输入体重")；
double e = input.nextDouble();
System.out.println("请输入爱好")；
String f = input.next();
System.out.println("姓名：" + a
+ "\n性别：" + b
+ "\n年龄：" + c
+ "\n身高：" + d
+ "\n体重：" + e
+ "\n爱好：" + f);
}
}
十.程序流程控制有三大结构
1.顺序结构：按照顺序（步骤）逐行执行；
2.选择结构（重点）
if 选择结构语法格式
if(条件){
代码块
}
- 注意事项：
- 在Java中，当代码块中只有一条语句时，则大括号是可以省略的
其实也就是：当没有编写大括号，则系统默认给一条语句编写大括号
建议：初学者大括号还是编写上 - if else 选择结构
- 什么时候使用if else结构？
当二选一时，则可以使用if else 选择结构完成 - 语法格式
- 什么时候使用if else结构？
- 在Java中，当代码块中只有一条语句时，则大括号是可以省略的
if(条件){
代码块1
}else{
代码块2
}
-
if else 选择结构执行流程：
- 先判断条件，如果条件为true，则执行代码块1，否则执行代码块2
例：在数学中，编写条件为 100 ≤ num ≤ 999 在Java中，编写为 num >= 100 && num <= 999-
多重 if 选择结构
3.1什么时候使用多重if结构？- 当有两种或者两种以上情况时，要得到最终一个结果，则就可以使用多重 if 选择结构完成
3.2 多重if选择结构语法格式
if(条件1){ 代码块1 }else if(条件2){ 代码块2 }else if(条件3){ 代码块3 }else if(条件4){ 代码块4 } …… else{ 代码块n }3.3 多重 if 选择结构说明
- 多重if选择结构中的else if(){}是可以编写任意多个，根据题意编写
3.4 多重 if 选择结构注意事项
-
多重if选择结构中的else if(){}可以颠倒，编译不报错，但是运行结构可能会有影响
解决办法：将条件必须编写严谨
-
当多重if选择结构中所有条件都不满足时，则执行 else{}
-
多重if选择结构中的else{}是可有可无的
-
如果在多重if选择结构中编写else{}，只能编写在多重if选择结构的最后，并且只能编写一个
-
if 选择结构的嵌套：
if(){ if(){ }else{ } }else if(){ if(){ }else if(){ }else if(){ } }else{ if(){ } }
3.程序流程控制：switch-case结构（重点）
当做等值操作时，则就可以使用switch case完成
-
格式
switch(表达式){
case 常量 ：
执行语句1;
break;
……
default:
执行语句;
break;
}
-
说明：
-
根据switch表达式中的值，依次匹配各个case中的常量，一匹配成功，则进入相应case结构中，调用其执行语句’
当调用完成后，则任然继续向下执行其他case语句，直到遇到break关键字或此switch-case结构结束为止； -
break，可以使用在switch-case结构语句中，表示一旦执行到此关键词，就跳出switch-case语句；
-
switch结构中的表达式，只能是如下的数据类型之一：
byte、short、char、int、枚举类型（JDK5.0）、string类型（JDK7.0之后）
常量值的类型必须与表达式值的类型一致 -
case之后只能声明常量，不能声明范围；
常量：存放数据的，并且存放的数据是不可以发生改变的常量值的类型必须与表达式数据类型相同
-
break关键字是可选的
break表示中断，也就是：当遇到break则结束当前整个switch case执行外面的语句 -
default；相当与else；可选的
当所有case都不满足时，则执行default
default是可有可无的，如果有则一个switch 中只能编写一个
-
-
switch case中常见的注意事
1.case后面值的顺序是可以颠倒的，编译不报错，也不影响程序的运行结果
建议：还是按顺序编写
2.default顺序也可以颠倒，编译不报错，也不影响程序的运行结果
原因：当所有case都不满足时，则执行default
建议：default最好还是编写在所有case的后面
3.break是可有可无的
如果有break，当遇到break则结束当前整个switch case执行外面的语句
如果没有break，则可能会影响程序的运行结果
原因：找到第一个匹配的case或者default一直向下执行语句，
其实也就是构成case穿透
因此得到结论：switch中最后是case或者是default中的break是可有可无，不影响结果
建议：根据情况适当编写break
case是可以合并的
-
switch case 和if else 转换说明：
- 凡是可以使用switch-case的结构，都可以转换为if else语句；反之不成立
- 两结构都可以使用，switch中表达式的取值情况不太多时建议使用switch case
原因：switch-case执行效率稍高（开发中绝大部分使用if else）
1-13循环结构：
在某些条件满足的情况下，反复执行特定代码的功能
-
将重复的代码只编写一次，重复执行即可
-
好处：减少代码的重复性（冗余性）
-
循环语句的分类
- for循环
- whlie循环
- do-while循环
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-K8ywo5ff-1668951868724)(C:\Users\86136\AppData\Roaming\Typora\typora-user-images\image-20210603215518257.png)]
—— 循环结构的4要素
1. 初始化条件
2. 循环条件 ——>必须是布尔类型
3. 循环体
4. 迭代条件
一，for循环结构：
for(初始化条件;循环条件;迭代条件){
循环体
}
-
for循环说明：
- 初始化条件完成变量的初始值，比如：int i = 0;
- 表达式2完成循环条件的判断**，如果循环条件为true则执行循环体，否则结束for循环执行外面的语句，比如： **i <= 5;
- 循环体也就是：将重复的代码只在循环体中编写一次，重复执行即可，比如：System.out.println(“HelloWorld”);
- 表达式3完成变量值的更改**，比如：**i++。
-
for循环中常见的注意事项：
-
注意：
在DOS命令窗口中按Ctrl + C表示强行终止程序运行
/*for循环中三个表达式都可以省略但是分号必须编写，则出现死循环也叫做无限循环*/ // for(;;){ System.out.println("OK"); } -
注意：
//当省略表达式1，则出现编译错误 int i = 1;//解决办法：将表达式1编写在循环上面即可 for(;i <= 5;i++){ System.out.println(i); } -
注意：
//当省略表达式2，则出现死循环也叫做无限循环，也就是：当表达式2省略默认为true for(byte i = 1;;i++){ System.out.println(i); } -
注意：
//当省略表达式3，则出现死循环也叫做无限循环， for(int i = 1;i <= 5;){ System.out.println(i); i++;//解决办法：将表达式3编写在循环体中最后一条语句 } -
注意：
//当在表达式1中声明变量，如果在循环外面使用该变量，则出现编译错误， /*解决办法： 1.将表达式1声明编写在循环上面; 2：将表达式1的声明和赋值都编写在循环上面，也就是注意事项2 */ int i; for(i = 1;i <= 5;i++){ System.out.println(i); } System.out.println(i);
-
二.whlie循环结构：
初始化条件
while(循环条件){
循环体
迭代条件
}
- while 循环执行流程：
Ø 先判断循环条件，如果条件为true，则执行循环体，然后再判断循环条件………一直到循环条件为false时，则结束当前while循环，执行循环外面的语句
三.do while循环结构
初始化条件
do{
循环体
迭代条件
}while(循环条件);
-
do while循环流程：
先执行循环体，然后再判断循环条件，如果循环条件为true，则继续执行循环体…….一直到循环条件为false时，则结束当前do while循环，执行循环外面的语句
四.三种循环区别
-
执行流程不同
Ø for循环和while循环：先判断循环条件，如果条件为true，则执行循环体
Ø do while循环：先执行，然后再判断
-
使用情况不同
Ø 当循环次数固定时，建议：使用for循环Ø 当循环次数不固定时，建议：使用while循环、do while循环
-
先执行，然后再判断，则建议使用do while循环
-
先判断，然后再执行，则建议使用while循环
-
-
当循环条件第一次就为false时，
Ø for循环和while循环：执行0次循环体
Ø do while循环：执行1次循环体
Ø 因此得到结论：
-
for循环：0次------N次
-
while循环：0次----N次
-
do while循环：1次-----N次
-
五.双重循环也叫做二重循环
-
在一个完整的循环中，再编写一个完整的循环，称为二重循环，
也叫做双重循环或者循环嵌套
-
语法格式：
for(;;){ //称为外层循环
for(;;){ //称为内层循环
}
}
- 双重循环特点：
当外层循环执行一次，则内层循环执行一遍
六.循环中使用可以使用的语句
-
break;
表示中断，当在循环中遇到break，则结束当前整个循环，执行循环外面的语句 -
continue;
表示继续，当在循环中遇到continue，结束当前这次循环，继续执行下一次循环
十一.方法：
-
方法method 也叫做函数
在Java中，实现某一个功能的代码称为方式，例：输出、判定、求和……
-
方法的分类：
-
系统提供的方法：
print()
println()
nextInt()
-
用户自定义的方法
-
用户自定义方法的语法格式（重点）：
[修饰符] 返回值类型 方法名称([参数列表]){
方法体
}
- 方法的说明：
1.在Java中==[]==中的内容是可有可无
2.返回值类型有两种情况
第一种情况：无返回值类型，也就是编写为void
第二种情况：有(带)返回值类型
3.方法名称也就是标识符
建议：方法名称编写该方法实现具体功能的单词
建议：方法名称采用驼峰命名法，比如：print sum ……
4.方法体也就是编写该方法实现具体功能的代码
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pvi3ICQi-1668952309344)(C:\Users\86136\AppData\Roaming\Typora\typora-user-images\image-20210605192147095.png)]
-
方法的注意事项：
1.在Java中，方法编写在其他方法的外面或者编写在类中，也就是说：方法是不能嵌套方法的
2.仿照main方法编写需要的方法
3.当使用java命令来运行字节码文件时，会自动找程序的入口也就是main方法，然后从main方法中的第一条语句开始逐行向下执行
也就是说：运行并不是从类中的第一行开始逐行向下执行
4.因此得到：用户自定义的方法编写好以后不会自动执行，则必须要进行方法的调用
调用方法的语法格式:
第一种方式：类名.方法名称([参数列表]);
第二种方式：方法名称([参数列表]);
两种调用方式的区别：
第一种方式：可以调用本类(当前类)中的其他方法，还可以调用其他类中的方法
第二种方式：只能调用本类(当前类)中的其他方法
5.一个方法编写好以后，可以调用任意多次
6.栈特点：先进后出 或者叫做后进先出
队列特点：先进先出 或者叫做后进后出
一.无参数无返回值类型
-
格式：
public static void 方法名称(){ 方法体 }
二.无参数带返回值类型
当==方法结果只有一个==时，则可以编写为带返回值类型的方法完成
-
格式：
public static 数据类型 方法名称(){ 方法体 return; } -
方法：
- 当方法带有返回值类型时，则不能编写为void，也就是编写返回结果对应的数据类型
- 当方法带有返回值类型时，则方法体中必须编写return，否则出现编译错误
- 一个方法体中可以编写任意多个return 但是最终只执行一个相匹配的return
方法中可以使用的语句：
break; continue; return;
break;
break表示中断.break使用场景：
在switch case中使用，还可以在循环中使用
-
break作用：
当遇到break，则结束当前整个switch case或者当前整个循环，执行外面的语句
continue;
continue表示继续,continue使用场景：
只能在循环中使用
-
continue作用：
当遇到continue，则结束当前这次循环(本次循环)，继续执行下一次循环
return;
return表示返回,return使用场景：
在方法中使用
return作用：
当遇到return则结束当前这个方法
-
return特殊形式：
当方法是无返回值类型，则方法体中可以使用return 但是使用return只能编写为return;
1.当方法带有返回值类型，并且是二选一，则方法体中可以有三种写法:
public static String judge(){
int num = 12;
//第一种写法：使用if else完成
if(num % 2 == 0){
return num + "是偶数";
}else{
return num + "是奇数";
}*
//第二种写法：使用三目运算符完成
return num % 2 == 0 ? num + "是偶数" : num + "是奇数";
//第三种写法：
if(num % 2 == 0){
return num + "是偶数";
}
return num + "是奇数";
}
2.当方法带有返回值类型，并且在方法题中使用switch ，case或者default后面如果编写return则return后面就不能再编写break，否则就出现编译错误
class Method06{
/*
练习6：使用方法完成，根据星期得到每天做的事情.
假如星期一、星期二、星期四、星期六学习，星期三、星期五自习，星期日休息
*/
public static String judge(){
//假如星期为一个指定的值
String week = "星期5";
switch(week){
case "星期一":
case "星期二":
case "星期四":
case "星期六":
return "学习";
/*
出现编译错误
原因：return表示返回，也就是：当遇到return则结束当前这个方法的执行
return后面不需要再编写任何语句，如果写反而还出现编译错误
如果没有编写break，也没有穿透
*/
//break;
case "星期三":
case "星期五":
return "自习";
case "星期日":
return "休息";
//解决办法2：在switch中编写default，并且返回一个字符串类型的值
default:
return "星期输入有误！";
}
//解决办法1：在switch外面编写return 返回一个字符串类型的值
return "星期输入有误!";
}
public static void main(String[] args){
}
}
三.有参数无返回值类型
当该方法中有未知的数时，则就可以编写为带参数的方法完成
-
带参方法的注意事项
1.参数编写在方法名称后面的小括号中
2.并且**每个参数都必须编写为：数据类型 参数名称**
多个参数之间使用英文逗号隔开
3.定义方法中，未知的数，称为形式参数，
简称形参，比如：n就是形参
在调用方法时，给具体的值，称为实际参数，
简称实参，比如：5就是实参
也就是：调用时，实参的值赋给形参变量名称
必须保证
实参与形参的个数一致，
实参与形参的数据类型一致，
顺序一致
4.建议：实参的值最好编写为键盘接收用户输入，使用相对更灵活
四.有参数有返回值类型
将有参数无返回值类型与无参数有返回值结合
import java.util.*;
class School1{
public static void main(String[] args){
//判断一个数是否是水仙花数
//三位数、能被4整除但不能被100整除，或者能被400整除
//第一步：输入
Scanner input = new Scanner(System.in);
System.out.println("请输入一个三位正整数：");
int num = input.nextInt();
System.out.println(School1.judge(num));
}
public static String judge(int x){
if(x < 100 || x >= 1000){
return x + "不是一个三位正整数";
}
int gw = x % 10;
int sw = x / 10 % 10;
int bw = x / 100;
if(x == (gw*gw*gw + sw*sw*sw + bw*bw*bw)){
return x + "是水仙花数";
}else{
return x + "不是水仙花数";
}
}
}
五.方法注意事项：
- 方法中的参数属于局部变量，在当前方法中开辟空间存储
- 局部变量在当前声明大括号内使用
- 因此各自方法中的局部变量可以同名，不报错，没有任何影响
- 方法重载overload
- 同一个类中，方法的名字必须相同，参数列表必须不同（个数不同、类型不同、顺序不同），至少编写2个方法
- 在调用方法时，会根据实参自动找相匹配的方法执行，当都匹配
则会寻找更接近的方法执行 - 使用时相对灵活
14万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
