方法概念及使用
什么是方法(method)
方法就是一个代码片段. 类似于 C 语言中的 “函数”。
- 是能够模块化的组织代码(当代码规模比较复杂的时候).
- 做到代码被重复使用, 一份代码可以在多个位置使用.
- 让代码更好理解更简单.
- 直接调用现有方法开发, 不必重复造轮子.
方法定义
方法的基本结构
1
2
3
4
|
[访问修饰符] [static] [final] 返回类型 方法名([参数列表]) [throws 异常列表] {
// 方法体
[return 返回值;]
}
|
【注意事项】
- 修饰符：现阶段直接使用public static 固定搭配
- 返回值类型：如果方法有返回值，返回值类型必须要与返回的实体类型一致，如果没有返回值，必须写成
void
- 方法名字：采用小驼峰命名
- 参数列表：如果方法没有参数，()中什么都不写，如果有参数，需指定参数类型，多个参数之间使用逗号隔开
- 方法体：方法内部要执行的语句
- 在java当中，方法必须写在类当中
- 在java当中，方法不能嵌套定义
- 在java当中，没有方法声明一说
方法调用的执行过程
【方法调用过程】
调用方法—>传递参数—>找到方法地址—>执行被调方法的方法体—>被调方法结束返回—>回到主调方法继续往下执行
注意
- 定义方法的时候, 不会执行方法的代码. 只有调用的时候才会执行.
- 一个方法可以被多次调用.
代码示例1 计算两个整数相加
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
|
public class Method {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println("第一次调用方法之前");
int ret = add(a, b);
System.out.println("第一次调用方法之后");
System.out.println("ret = " + ret);
System.out.println("第二次调用方法之前");
ret = add(30, 50);
System.out.println("第二次调用方法之后");
System.out.println("ret = " + ret);
}
public static int add(int x, int y) {
System.out.println("调用方法中 x = " + x + " y = " + y);
return x + y;
}
}
// 执行结果
一次调用方法之前
调用方法中 x = 10 y = 20
第一次调用方法之后
ret = 30
第二次调用方法之前
调用方法中 x = 30 y = 50
第二次调用方法之后
ret = 80
|
实参和形参的关系
在Java方法中，形参（形式参数）和实参（实际参数）是两个密切相关但又不同的概念，它们共同构成了方法调用的参数传递机制。
形参（Formal Parameter）
- 定义：方法声明时定义的参数
- 位置：出现在方法签名中
- 作用：指定方法接收什么类型的数据
- 生命周期：从方法调用开始到方法执行结束
1
2
3
|
public void printMessage(String message) { // message是形参
System.out.println(message);
}
|
实参（Actual Parameter）
- 定义：方法调用时实际传入的值或变量
- 位置：出现在方法调用处
- 作用：提供方法执行所需的具体数据
- 生命周期：取决于实参本身的定义位置
1
|
printMessage("Hello World"); // "Hello World"是实参
|
对应关系
- 实参和形参在数量、顺序和类型上必须严格匹配
- 方法调用时，实参的值会传递给对应的形参
数据传递方式
Java中参数传递只有值传递一种方式：
- 对于基本数据类型：传递的是值的副本
- 对于引用数据类型：传递的是引用的副本（即对象地址的副本）
基本数据类型示例：
1
2
3
4
5
6
7
8
9
|
public static void modifyValue(int x) { // x是形参
x = 100;
}
public static void main(String[] args) {
int num = 50; // num是实参
modifyValue(num);
System.out.println(num); // 输出50，原值未改变
}
|
引用数据类型示例：
1
2
3
4
5
6
7
8
9
|
public static void modifyArray(int[] arr) { // arr是形参
arr[0] = 100;
}
public static void main(String[] args) {
int[] myArray = {1, 2, 3}; // myArray是实参
modifyArray(myArray);
System.out.println(myArray[0]); // 输出100，数组内容被修改
}
|
重要特点
- 单向传递：只能从实参传给形参，不能反向传递
- 独立内存空间：形参和实参占用不同的内存空间
- 作用域不同：
- 形参只在方法内部有效
- 实参的作用域取决于它定义的位置
- 命名无关性：形参和实参的名称可以相同也可以不同
基本数据类型的修改不会影响实参
1
2
3
|
void change(int a) { a = 10; }
int x = 5;
change(x); // x仍然是5
|
引用数据类型可以通过形参修改对象内容（但不能改变引用本身）
1
2
3
|
void changeArray(int[] arr) { arr[0] = 100; }
int[] nums = {1, 2, 3};
changeArray(nums); // nums[0]变为100
|
String等不可变对象表现出类似基本类型的行为
1
2
3
|
void changeString(String s) { s = "new"; }
String str = "old";
changeString(str); // str仍然是"old"
|
没有返回值的方法
方法的返回值是可选的. 有些时候可以没有的，没有时返回值类型必须写成void
1
2
3
4
5
6
7
8
9
10
|
class Test {
public static void main(String[] args) {
int a = 10;
int b = 20;
print(a, b);
}
public static void print(int x, int y) {
System.out.println("x = " + x + " y = " + y);
}
}
|
方法重载
方法重载概念
在Java中，如果多个方法的名字相同，参数列表不同，则称该几种方法被重载了。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
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;
}
}
|
注意：
- 方法名必须相同
- 参数列表必须不同(参数的个数不同、参数的类型不同、类型的次序必须不同)
- 与返回值类型是否相同无关
- 编译器在编译代码时，会对实参类型进行推演，根据推演的结果来确定调用哪个方法
递归
递归的概念
一个方法在执行过程中调用自身, 就称为 “递归”.
递归的必要条件：
- 将原问题划分成其子问题，注意：子问题必须要与原问题的解法相同
- 递归出口
1
2
3
4
5
6
7
8
9
10
11
12
13
|
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
|