字面量
| 字面量类型 | 说明 | 程序中的写法 |
|---|---|---|
| 整数 | 不带小数的数字 | 22，33 |
| 小数 | 带小数的数字 | 13.14，-5.21 |
| 字符 | 必须使用单引号，有且仅能一个字符 | ‘m’，‘3’， ‘我’ |
| 字符串 | 必须使用双引号，内容可有可无 | “HelloWorld” |
| 布尔值 | 布尔值，表示真假，只有两个值：true，false | true 、false |
| 空值 | 一个特殊的值，空值 | 值是：null |
- 不带小数点的数字都是整数类型的字面量。
- 只要带了小数点，那么就是小数类型的字面量。
- 只要用双引号引起来的，不管里面的内容是什么，不管里面有没有内容，都是字符串类型的字面量。
- 字符类型的字面量必须用单引号引起来，不管内容是什么，但是个数有且只能有一个。
- 字符类型的字面量只有两个值，true、false。
- 空类型的字面量只有一个值，null。
变量
1 什么是变量？
变量就在程序中临时存储数据的容器。但是这个容器中只能存一个值。
2 变量的定义格式
数据类型 变量名 = 数据值；
2.1 格式详解
数据类型：限定了变量当中能存储什么类型的数据。
如果要存10，那么数据类型就需要写整数类型。
如果要存10.0，那么数据类型就需要写小数类型。
变量名：其实就是这个容器的名字。
当以后想要使用变量里面的数据时，直接使用变量名就可以了。
数据值：真正存储在容器中的数据。
分号：表示语句的结束，就跟以前写作文时候的句号是一样的。
数据类型
1. Java语言数据类型的分类
- 基本数据类型
- 引用数据类型（面向对象的时候再深入学习）
2. 基本数据类型的四类八种
| 数据类型 | 关键字 | 内存占用 | 取值范围 |
|---|---|---|---|
| 整数 | byte | 1 | 负的2的7次方 ~ 2的7次方-1(-128~127) |
| short | 2 | 负的2的15次方 ~ 2的15次方-1(-32768~32767) | |
| int | 4 | 负的2的31次方 ~ 2的31次方-1 | |
| long | 8 | 负的2的63次方 ~ 2的63次方-1 | |
| 浮点数 | float | 4 | 1.401298e-45 ~ 3.402823e+38 |
| double | 8 | 4.9000000e-324 ~ 1.797693e+308 | |
| 字符 | char | 2 | 0-65535 |
| 布尔 | boolean | 1 | true，false |
- 如果要定义 一个整数类型的变量，不知道选择哪种数据类型了，默认使用int。
- 如果要定义 一个小数类型的变量，不知道选择哪种数据类型了，默认使用double。
- 如果要定义一个long类型的变量，那么在数据值的后面需要加上L后缀。（大小写都可以，建议大写。）
- 如果要定义一个float类型的变量，那么在数据值的后面需要加上F后缀。（大小写都可以）
标识符
业内大多数程序员都在遵守阿里巴巴的命名规则。
1 硬性要求：
必须要这么做，否则代码会报错。
- 必须由数字、字母、下划线_、美元符号$组成。
- 数字不能开头
- 不能是关键字
- 区分大小写的。
2 软件建议：
如果不这么做，代码不会报错，但是会让代码显得比较low。
2.1 小驼峰命名法
适用于变量名和方法名
如果是一个单词，那么全部小写，比如：name
如果是多个单词，那么从第二个单词开始，首字母大写，比如：firstName、maxAge
2.2 大驼峰命名法
适用于类名
如果是一个单词，那么首字母大写。比如：Demo、Test。
如果是多个单词，那么每一个单词首字母都需要大写。比如：HelloWorld
不管起什么名字，都要做到见名知意。
阿里巴巴命名规范细节：
尽量不要用拼音。但是一些国际通用的拼音可视为英文单词。
正确：alibaba、hangzhou、nanjing
错误：jiage、dazhe
平时在给变量名、方法名、类名起名字的时候，不要使用下划线或美元符号。
错误：_name
正确：name
键盘录入
1 | //导包，其实就是先找到Scanner这个类在哪 |
运算符
运算符
运算符是对常量或变量进行操作的符号，例如：
+：加法-：减法*：乘法/：除法
表达式
表达式是用运算符将常量或变量连接起来的式子，符合 Java 语法。例如：
a + b：一个算术表达式
二、算术运算符详解
算术运算符包括 + - * / %。具体特点如下：
+ - *：与小学数学运算一致。/：整数相除结果只取整数部分，若需小数结果则需有小数参数参与。1
2System.out.println(10 / 3); // 输出 3
System.out.println(10.0 / 3); // 输出 3.3333333333333335%：取模（余数），可用于判断奇偶数等。1
System.out.println(10 % 3); // 输出 1
三、数值拆分练习
通过键盘录入一个三位数，利用公式拆分为个位、十位、百位并打印。公式如下：
- 个位：数字 % 10
- 十位：数字 / 10 % 10
- 百位：数字 / 100 % 10
代码示例：
1 | Scanner sc = new Scanner(System.in); |
四、隐式转换规则
隐式转换即自动类型提升，将取值范围小的数据或变量赋给取值范围大的变量，无需额外代码。规则如下：
- 取值范围小的与大的运算，小的会先提升为大的再运算。
byte、short、char在运算时会先提升为int再运算。- 取值范围从小到大顺序：
byte short int long float double。
五、隐式转换练习案例
double d = 10;，int类型（10）自动提升为double类型赋给d。byte b = 100; int i = b;，byte类型（b）自动提升为int类型赋给i。int i = 10; long n = 20L;，i和n运算时i提升为long类型，结果为long类型。int i = 10; long n = 100L; double d = 20.0;，i和n运算时先提升为long，再与d运算时都提升为double，结果为double类型。byte b1 = 10; byte b2 = 20;，b1和b2运算时都提升为int类型，结果为int类型。byte b = 10; short s = 20; long n = 100L;，b和s先提升为int，再与n运算时提升为long，结果为long类型。
六、强制转换要点
强制转换是将取值范围大的数据或变量赋给取值范围小的变量时需进行的操作，格式为目标数据类型 变量名 = （目标数据类型）被强转的数据。例如：
1 | double a = 12.3; |
注意：强制转换可能导致数据精度丢失。
七、字符串的 + 操作
当 + 操作中出现字符串时，为字符串连接符，会将前后数据拼接成新字符串，且从左到右逐个执行。例如：
1 | 1 + "abc" + 1; // 结果为 "1abc1" |
八、字符的 + 操作
字符的 + 操作会先查 ASCII 码表对应数字再进行计算。例如：
1 | char c = 'a'; |
九、算术运算符总结
算术运算符 + - * / % 操作与小学数学类似，注意以下几点：
/和%的区别：/取结果的商，%取结果的余数。- 整数运算只能得到整数，若需小数结果则需有浮点数参与。
- 字符串只有
+操作。
十、自增自减运算符
自增（++）和自减（--）运算符用于变量值的加 1 或减 1 操作，可放在变量前后，单独一行时结果相同。应用场景包括：
- 年龄增长
- 商品数量选择
- 数据统计等
十一、赋值运算符
赋值运算符（=）将等号右边结果赋给左边变量。扩展赋值运算符（+=、-=、*=、/=、%=）会进行相应运算后将结果赋值给左边变量，且隐含强制转换。例如：
1 | int a = 10; |
十二、关系运算符
关系运算符（==、!=、>、>=、<、<=）用于比较左右两边数据，结果为布尔类型。注意：
==用于判断相等!=用于判断不相等>、>=、<、<=用于大小比较- 注意
==与=的区别
十三、逻辑运算符
逻辑运算符包括：
&（逻辑与）：两边都为真，结果才为真。|（逻辑或）：两边都为假，结果才为假。^（异或）：两边相同，结果为假；不同，结果为真。!（取反）：对布尔值取反，注意取反最多用一个。
十四、短路逻辑运算符
短路逻辑运算符（&&、||）与逻辑运算符结果相同，但具有短路效果，当左边能确定整个表达式结果时，右边不会执行，提高代码效率。例如：
用户名正确 && 密码正确：若用户名错误，不会验证密码有房 || 有车：若有房，不会检查是否有车
十五、三元运算符
三元运算符格式为 关系表达式 ? 表达式1 : 表达式2;，根据关系表达式结果选择执行表达式1或表达式2，结果需被使用。例如：
1 | int max = a > b ? a : b; |
十六、练习案例
练习 1：判断两只老虎体重是否相同
通过键盘录入两只老虎的体重，利用三元运算符输出结果。
1 | Scanner sc = new Scanner(System.in); |
练习 2：求三个和尚的最高身高
已知三个和尚的身高分别为 150cm、210cm、165cm，利用三元运算符求出最高身高。
1 | int height1 = 150; |
十七、运算符优先级
Java 中各运算符有优先级，但只需记住小括号优先级最高。使用小括号可以
十八、运算符优先级与结合性
优先级
运算符优先级决定了表达式中运算的先后顺序。优先级高的运算符先进行计算。
例如，乘除运算符（
*、/、%）的优先级高于加减运算符（+、-）。1
int result = 10 + 5 * 2; // 先计算 5 * 2，再计算 10 + 10，结果为 20
结合性
结合性决定了同优先级运算符的计算方向，分为左结合性和右结合性。
大多数运算符是左结合的，即从左到右计算。例如：
1
int result = 10 - 5 - 3; // 先计算 10 - 5，再计算 5 - 3，结果为 2
赋值运算符是右结合的，即从右到左计算。例如：
1
2int a, b, c;
a = b = c = 10; // 先计算 c = 10，再计算 b = 10，最后计算 a = 10
十九、位运算符
位运算符用于对整数的二进制位进行操作，包括：
&：按位与|：按位或^：按位异或~：按位取反<<：左移>>：右移（符号位填充）>>>：无符号右移（零填充）
按位与（&）
对两个操作数的每一位进行与运算，只有当两个位都为 1 时，结果位才为 1。
1
2
3int a = 5; // 二进制：0101
int b = 3; // 二进制：0011
int result = a & b; // 二进制：0001，结果为 1
按位或（|）
对两个操作数的每一位进行或运算，只要有一个位为 1，结果位就为 1。
1
2
3int a = 5; // 二进制：0101
int b = 3; // 二进制：0011
int result = a | b; // 二进制：0111，结果为 7
按位异或（^）
对两个操作数的每一位进行异或运算，只有当两个位不相同时，结果位才为 1。
1
2
3int a = 5; // 二进制：0101
int b = 3; // 二进制：0011
int result = a ^ b; // 二进制：0110，结果为 6
按位取反（~）
对操作数的每一位进行取反运算，0 变 1，1 变 0。
1
2int a = 5; // 二进制：0101
int result = ~a; // 二进制：1010，结果为 -6（补码表示）
左移（<<）
将操作数的二进制位向左移动指定的位数，右侧补 0。
1
2int a = 5; // 二进制：0101
int result = a << 1; // 二进制：1010，结果为 10
右移（>>）
将操作数的二进制位向右移动指定的位数，左侧补符号位（正数补 0，负数补 1）。
1
2int a = 5; // 二进制：0101
int result = a >> 1; // 二进制：0010，结果为 2
无符号右移（>>>）
将操作数的二进制位向右移动指定的位数，左侧补 0，不考虑符号位。
1
2int a = -5; // 二进制：11111111 11111111 11111111 11111011（补码表示）
int result = a >>> 1; // 二进制：01111111 11111111 11111111 11111101，结果为 2147483645
二十、实例应用
实例 1：计算两个数的平均值
1 | public class AverageCalculator { |
实例 2：判断一个数是否为素数
1 | public class PrimeChecker { |
实例 3：实现一个简单的计算器
1 | public class SimpleCalculator { |
流程控制语句
1.1 流程控制语句分类
- 顺序结构：程序中最简单最基本的流程控制，按照代码的先后顺序依次执行。
- 判断和选择结构：
if和switch语句，用于根据条件选择执行特定的代码块。 - 循环结构：
for、while、do...while循环，用于在满足条件的情况下反复执行某一段代码。
1.2 顺序结构
顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序依次执行。
第二章 判断语句：if 语句
2.1 if 语句格式 1
1 | if (关系表达式) { |
执行流程：
- 首先计算关系表达式的值。
- 如果关系表达式的值为
true，则执行语句体。 - 如果关系表达式的值为
false，则不执行语句体。 - 继续执行后面的语句内容。
示例：
1 | public class IfDemo { |
2.2 if 语句格式 2
1 | if (关系表达式) { |
执行流程：
- 首先计算关系表达式的值。
- 如果关系表达式的值为
true，则执行语句体1。 - 如果关系表达式的值为
false，则执行语句体2。 - 继续执行后面的语句内容。
示例：
1 | public class IfDemo02 { |
2.3 if 语句格式 3
1 | if (关系表达式1) { |
执行流程：
- 首先计算关系表达式1的值。
- 如果值为
true，则执行语句体1；如果值为false，则计算关系表达式2的值。 - 如果值为
true，则执行语句体2；如果值为false，则计算关系表达式3的值。 - …
- 如果没有任何关系表达式为
true，则执行语句体n+1。
示例：
1 | public class IfDemo03 { |
第三章 switch 语句
3.1 格式
1 | switch (表达式) { |
3.2 执行流程
- 首先计算出表达式的值。
- 其次，和
case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。 - 最后，如果所有的
case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束。
示例：
1 | public class SwitchDemo2 { |
3.3 switch 的扩展知识
default 的位置和省略情况：
default可以放在任意位置，也可以省略。case 穿透：不写
break会引发case穿透现象。switch 在 JDK12 的新特性：
1
2
3
4
5
6
7int number = 10;
switch (number) {
case 1 -> System.out.println("一");
case 2 -> System.out.println("二");
case 3 -> System.out.println("三");
default -> System.out.println("其他");
}switch 和 if 第三种格式各自的使用场景：
- 当需要对一个范围进行判断时，用
if的第三种格式。 - 当把有限个数据列举出来，选择其中一个执行时，用
switch语句。
- 当需要对一个范围进行判断时，用
示例：
1 | public class SwitchDemo3 { |
第四章 循环结构
4.1 for 循环结构
4.1.1 for 循环格式
1 | for (初始化语句; 条件判断语句; 条件控制语句) { |
格式解释：
- 初始化语句：用于表示循环开启时的起始状态。
- 条件判断语句：用于表示循环反复执行的条件。
- 循环体语句：用于表示循环反复执行的内容。
- 条件控制语句：用于表示循环执行中每次变化的内容。
执行流程：
- 执行初始化语句。
- 执行条件判断语句，看其结果是
true还是false。- 如果是
false，循环结束。 - 如果是
true，继续执行。
- 如果是
- 执行循环体语句。
- 执行条件控制语句。
- 回到第 2 步继续。
示例：
1 | public class ForTest01 { |
4.2 while 循环
4.2.1 格式
1 | 初始化语句; |
示例：
1 | public class WhileTest01 { |
4.3 do…while 循环
格式：
1 | 初始化语句; |
特点：
- 先执行循环体，再进行条件判断。
- 无论条件是否满足，循环体至少执行一次。
示例：
1 | public class DoWhileTest01 { |
4.4 三种循环格式的区别
- for 循环：
- 适用于知道循环次数或循环范围的情况。
- 语法结构紧凑，初始化、条件判断、条件控制语句都在一个地方，代码更清晰。
- while 循环：
- 适用于不知道循环次数，但知道循环结束条件的情况。
- 代码结构相对灵活，初始化和条件控制语句可以分散在不同位置。
- do…while 循环：
- 适用于至少需要执行一次循环体的情况。
- 先执行循环体，再进行条件判断，循环体至少执行一次。
条件控制语句语句总结
break 语句
- 作用：用于终止循环或 switch 语句的执行。
continue 语句
- 作用：用于结束当前循环的本次迭代，继续执行下一次迭代
return 语句
- 作用：用于从方法中返回，可以返回一个值或不返回值。
数组
1. 数组概念
数组是一种容器，用于存储同种数据类型的多个值。数组在存储数据时需要结合隐式转换考虑。例如，定义了一个 int 类型的数组，那么 boolean、double 类型的数据不能存入该数组，但 byte、short、int 类型的数据可以存入。
建议：容器的数据类型和存储的数据类型保持一致。
2. 数组的定义
格式一
1 | 数据类型[] 数组名; |
例如：int[] array;
格式二
1 | 数据类型 数组名[]; |
例如：int array[];
详解
- 数据类型：限定了数组以后能存什么类型的数据。
- 方括号：表示现在定义的是一个数组。
- 数组名：只是一个名字，方便以后使用。
注意点
- 方法括号跟数组名，谁写在前面，谁写在后面都是一样的。
- 平时习惯性使用第一种方式。
3. 数组的静态初始化
完整格式
1 | 数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, 元素3, 元素4...}; |
例如：
1 | int[] arr = new int[]{11, 22, 33}; |
格式详解
- 数据类型：限定了数组以后能存什么类型的数据。
- 方括号：表示现在定义的是一个数组。
- 数组名：只是一个名字，方便以后使用。
- new：给数组在内存中开辟一个空间。
- 数据类型：限定了数组以后能存什么类型的数据，前后数据类型必须一致。
- 方括号：表示现在定义的是一个数组。
- 大括号：表示数组里面的元素，多个元素之间用逗号隔开。
注意点
- 等号前后的数据类型必须保持一致。
- 数组一旦创建之后，长度不能发生变化。
简化格式
1 | 数据类型[] 数组名 = {元素1, 元素2, 元素3, 元素4...}; |
例如：
1 | int[] array = {1, 2, 3, 4, 5}; |
练习
定义数组存储5个学生的年龄。
1
int[] agesArr = {18, 19, 20, 21, 22};
定义数组存储3个学生的姓名。
1
String[] namesArr = {"zhangsan", "lisi", "wangwu"};
定义数组存储4个学生的身高。
1
double[] heightsArr = {1.85, 1.82, 1.78, 1.65};
4. 地址值
打印数组时，实际输出的是数组的地址值。数组的地址值表示数组在内存中的位置。例如，[I@6d03e736 表示一个 int 类型的数组，6d03e736 是数组在内存中的地址值（十六进制）。
5. 数组元素访问
格式
1 | 数组名[索引]; |
作用
- 获取数组中对应索引上的值。
- 修改数组中对应索引上的值，修改后原来的值会被覆盖。
代码示例
1 | public class ArrDemo2 { |
6. 索引
索引也叫角标、下标，是数组容器中每一个小格子对应的编号。
索引的特点
- 索引一定是从 0 开始的。
- 连续不间断。
- 逐个 +1 增长。
7. 数组的遍历
遍历是把数组里面所有的内容一个一个全部取出来。数组的长度通过 数组名.length 获取。
通用代码：
1 | for (int i = 0; i < arr.length; i++) { |
8. 数组的动态初始化
格式
1 | 数据类型[] 数组名 = new 数据类型[数组的长度]; |
举例
1 | // 定义一个数组，存 3 个人的年龄，年龄未知 |
数组的默认初始化值
- 整数类型：0
- 小数类型：0.0
- 布尔类型：false
- 字符类型：’\u0000’
- 引用类型：null
9. 数组两种初始化方式的区别
- 静态初始化：
int[] arr = {1, 2, 3, 4, 5};- 手动指定数组的元素，系统会根据元素的个数计算出数组的长度。
- 动态初始化：
int[] arr = new int[3];- 手动指定数组长度，由系统给出默认初始化值。
使用场景
- 只明确元素个数，但不明确具体的数据，推荐使用动态初始化。
- 已经明确了要操作的所有数据，推荐使用静态初始化。
举例
使用数组来存储键盘录入的 5 个整数。
1
int[] arr = new int[5];
将全班的学生成绩存入数组中，已知学生成绩为：66, 77, 88, 99, 100
1
int[] arr = {66, 77, 88, 99, 100};
10. 数组常见问题
当访问了数组中不存在的索引时，会引发索引越界异常（ArrayIndexOutOfBoundsException）。
避免方法：
- 针对任意一个数组，索引的范围：
- 最小索引：0
- 最大索引：数组的长度 - 1，即
数组名.length - 1
代码示例
1 | public class ArrDemo6 { |
方法
1. 方法概述
1.1 方法的概念
方法（method）是程序中最小的执行单元。
- 注意：
- 方法必须先创建才可以使用，该过程称为方法定义。
- 方法创建后并不是直接可以运行的，需要手动使用后，才执行，该过程称为方法调用。
2. 方法的定义和调用
2.1 无参数方法定义和调用
定义格式：
java复制
1
2
3public static void 方法名 ( ) {
// 方法体;
}范例：
java复制
1
2
3public static void method ( ) {
// 方法体;
}调用格式：
java复制
1
方法名();
范例：
java复制
1
method();
注意：
- 方法必须先定义，后调用，否则程序将报错。
2.3 无参数方法的练习
需求：设计一个方法用于打印两个数中的较大数。
思路：
- 定义一个方法，用于打印两个数字中的较大数，例如
getMax()。 - 方法中定义两个变量，用于保存两个数字。
- 使用分支语句分两种情况对两个数字的大小关系进行处理。
- 在
main()方法中调用定义好的方法。
- 定义一个方法，用于打印两个数字中的较大数，例如
代码：
java复制
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20public class MethodTest {
public static void main(String[] args) {
// 在 main() 方法中调用定义好的方法
getMax();
}
// 定义一个方法，用于打印两个数字中的较大数，例如 getMax()
public static void getMax() {
// 方法中定义两个变量，用于保存两个数字
int a = 10;
int b = 20;
// 使用分支语句分两种情况对两个数字的大小关系进行处理
if (a > b) {
System.out.println(a);
} else {
System.out.println(b);
}
}
}
3. 带参数方法定义和调用
3.1 带参数方法定义和调用
定义格式：
参数：由数据类型和变量名组成 - 数据类型 变量名
参数范例：
int ajava复制
1
2
3
4
5
6
7public static void 方法名 (参数1) {
方法体;
}
public static void 方法名 (参数1, 参数2, 参数3...) {
方法体;
}范例：
java复制
1
2
3
4
5
6
7public static void isEvenNumber(int number) {
...
}
public static void getMax(int num1, int num2) {
...
}- 注意：
- 方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错。
- 方法定义时，多个参数之间使用逗号（,）分隔。
- 注意：
调用格式：
java复制
1
2
3方法名(参数)；
方法名(参数1,参数2);范例：
java复制
1
2
3isEvenNumber(10);
getMax(10, 20);- 注意：
- 方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错。
- 注意：
3.2 形参和实参
- 形参：方法定义中的参数。
- 等同于变量定义格式，例如：
int number。
- 等同于变量定义格式，例如：
- 实参：方法调用中的参数。
- 等同于使用变量或常量，例如：
10number。
- 等同于使用变量或常量，例如：
3.3 带参数方法练习
需求：设计一个方法用于打印两个数中的较大数，数据来自于方法参数。
思路：
- 定义一个方法，用于打印两个数字中的较大数，例如
getMax()。 - 为方法定义两个参数，用于接收两个数字。
- 使用分支语句分两种情况对两个数字的大小关系进行处理。
- 在
main()方法中调用定义好的方法（使用常量）。 - 在
main()方法中调用定义好的方法（使用变量）。
- 定义一个方法，用于打印两个数字中的较大数，例如
代码：
java复制
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25public class MethodTest {
public static void main(String[] args) {
// 在 main() 方法中调用定义好的方法（使用常量）
getMax(10, 20);
// 调用方法的时候，人家要几个，你就给几个，人家要什么类型的，你就给什么类型的
// getMax(30);
// getMax(10.0, 20.0);
// 在 main() 方法中调用定义好的方法（使用变量）
int a = 10;
int b = 20;
getMax(a, b);
}
// 定义一个方法，用于打印两个数字中的较大数，例如 getMax()
// 为方法定义两个参数，用于接收两个数字
public static void getMax(int a, int b) {
// 使用分支语句分两种情况对两个数字的大小关系进行处理
if (a > b) {
System.out.println(a);
} else {
System.out.println(b);
}
}
}
4. 带返回值方法的定义和调用
4.1 带返回值方法定义和调用
定义格式：
java复制
1
2
3public static 数据类型 方法名 ( 参数 ) {
return 数据 ;
}范例：
java复制
1
2
3
4
5
6
7public static boolean isEvenNumber( int number ) {
return true ;
}
public static int getMax( int a, int b ) {
return 100 ;
}- 注意：
- 方法定义时
return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错。
- 方法定义时
- 注意：
调用格式：
java复制
1
2方法名 ( 参数 ) ;
数据类型 变量名 = 方法名 ( 参数 ) ;范例：
java复制
1
2
3isEvenNumber ( 5 ) ;
boolean flag = isEvenNumber ( 5 );- 注意：
- 方法的返回值通常会使用变量接收，否则该返回值将无意义。
- 注意：
4.2 带返回值方法练习 1
需求：设计一个方法可以获取两个数的较大值，数据来自于参数。
思路：
- 定义一个方法，用于获取两个数字中的较大数。
- 使用分支语句分两种情况对两个数字的大小关系进行处理。
- 根据题设分别设置两种情况下对应的返回结果。
- 在
main()方法中调用定义好的方法并使用变量保存。 - 在
main()方法中调用定义好的方法并直接打印结果。
代码：
java复制
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21public class MethodTest {
public static void main(String[] args) {
// 在 main() 方法中调用定义好的方法并使用变量保存
int result = getMax(10, 20);
System.out.println(result);
// 在 main() 方法中调用定义好的方法并直接打印结果
System.out.println(getMax(10, 20));
}
// 定义一个方法，用于获取两个数字中的较大数
public static int getMax(int a, int b) {
// 使用分支语句分两种情况对两个数字的大小关系进行处理
// 根据题设分别设置两种情况下对应的返回结果
if (a > b) {
return a;
} else {
return b;
}
}
}
4.3 带返回值方法练习 2
需求：定义一个方法，求一家商场每个季度的营业额。根据方法结果再计算出全年营业额。
代码示例：
java复制
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
28package com.itheima.demo;
public class MethodDemo9 {
public static void main(String[] args) {
/*需求：定义一个方法，求一家商场每个季度的营业额。
根据方法结果再计算出全年营业额。*/
int sum1 = getSum(10, 20, 30);
int sum2 = getSum(10, 20, 30);
int sum3 = getSum(10, 20, 30);
int sum4 = getSum(10, 20, 30);
int sum = sum1 + sum2 + sum3 + sum4;
System.out.println(sum);
}
// 心得：
// 1.我要干嘛？ 决定了方法体 每个季度的营业额
// 2.我干这件事情，需要什么才能完成？ 决定了形参 需要三个月的营业额 a b c
// 3.我干完这件事情，看调用处是否需要使用方法的结果。 决定了返回值
// 如果需要使用，那么必须返回
// 如果不需要使用，可以返回也可以不返回
public static int getSum(int month1, int month2, int month3) {
int sum = month1 + month2 + month3;
// 因为方法的调用处，需要继续使用这个结果
// 所以我们必须要把sum返回
return sum;
}
}
5. 方法的注意事项
5.1 方法的注意事项
方法不能嵌套定义
示例代码：
1
2
3
4
5
6
7
8
9
10
11public class MethodDemo {
public static void main(String[] args) {
}
public static void methodOne() {
public static void methodTwo() {
// 这里会引发编译错误!!!
}
}
}
void 表示无返回值，可以省略 return，也可以单独的书写 return，后面不加数据
示例代码：
1
2
3
4
5
6
7
8
9
10public class MethodDemo {
public static void main(String[] args) {
}
public static void methodTwo() {
//return 100; 编译错误，因为没有具体返回值类型
return;
//System.out.println(100); return语句后面不能跟数据或代码
}
}
5.2 方法的通用格式
格式：
1
2
3
4public static 返回值类型 方法名(参数) {
方法体;
return 数据;
}解释：
public static：修饰符，目前先记住这个格式。- 返回值类型：方法操作完毕之后返回的数据的数据类型。
- 如果方法操作完毕，没有数据返回，这里写
void，而且方法体中一般不写return。
- 如果方法操作完毕，没有数据返回，这里写
- 方法名：调用方法时候使用的标识。
- 参数：由数据类型和变量名组成，多个参数之间用逗号隔开。
- 方法体：完成功能的代码块。
return：如果方法操作完毕，有数据返回，用于把数据返回给调用者。
定义方法时，要做到两个明确：
- 明确返回值类型：主要是明确方法操作完毕之后是否有数据返回，如果没有，写
void；如果有，写对应的数据类型。 - 明确参数：主要是明确参数的类型和数量。
- 明确返回值类型：主要是明确方法操作完毕之后是否有数据返回，如果没有，写
调用方法时的注意：
void类型的方法，直接调用即可。- 非
void类型的方法，推荐用变量接收调用。
6. 方法重载
6.1 方法重载
方法重载概念
方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载：
- 多个方法在同一个类中。
- 多个方法具有相同的方法名。
- 多个方法的参数不相同，类型不同或者数量不同。
注意：
- 重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式。
- 重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载。
正确范例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17public class MethodDemo {
public static void fn(int a) {
// 方法体
}
public static int fn(double a) {
// 方法体
}
}
public class MethodDemo {
public static float fn(int a) {
// 方法体
}
public static int fn(int a, int b) {
// 方法体
}
}错误范例：
```java
public class MethodDemo {
public static void fn(int a) {
// 方法体
}
public static int fn(int a) { /错误原因：重载与返回值无关/
// 方法体
}
}public class MethodDemo01 {
public static void fn(int a) {
// 方法体
}
}
public class MethodDemo02 {
public static int fn(double a) { /错误原因：这是两个类的两个fn方法/
// 方法体
}
}