方法的使用
1.方法的基本用法
1.1什么是方法(method)
方法就是一个代码片段.类似于 C语言中的 "函数".
方法存在的意义(不要背,重在体会):
1.是能够模块化的组织代码(当代码规模比较复杂的时候).
2.做到代码被重复使用,一份代码可以在多个位置使用.
3.让代码更好理解更简单.
4.直接调用现有方法开发,不必重复造轮子.
回忆一个之前写过的代码:计算 1! + 2! + 3! + 4! + 5!
int sum = 0;
for (int i = 1; i <= 5; i++) {
int tmp = 1;
for (int j = 1; j <= i; j++) {
tmp *= j;
}
sum += tmp;
}
System.out.println("sum = " + sum);这个代码中使用双重循环,比较容易写错. 接下来我们可以使用方法来优化这个代码.
1.2方法定义语法
// 方法定义
public static方法返回值 方法名称（[参数类型 形参 ...]){
方法体代码;
[return返回值];
}
// 方法调用
返回值变量=方法名称(实参...);
代码示例:实现一个方法实现两个整数相加
public class Test {
public static void main(String[] args) {
int a = 10;
int b = 20;
// 方法的调用
int ret = add(a, b);
System.out.println("ret = " + ret);
}
// 方法的定义
public static int add(int x, int y) {
return x + y;
}
}
//执行结果为30注意事项
1. public和 static两个关键字在此处具有特定含义,我们暂时不讨论,后面会详细介绍.
2.方法定义时,参数可以没有.每个参数要指定类型
3.方法定义时,返回值也可以没有,如果没有返回值,则返回值类型应写成 void
4.方法定义时的参数称为 "形参",方法调用时的参数称为 "实参".
5.方法的定义必须在类之中,代码书写在调用位置的上方或者下方均可（注意这里与c语言的不同之处）
6. Java中没有 "函数声明"这样的概念.
在这里顺便讲下方法在栈上开辟内存以及运行的过程：
此时首先为main方法在栈(这个栈一般我们称之为java虚拟机栈)上开辟栈帧，然后再为两个实参a,b在main方法的栈帧上分配内存，分配完后此时主函数中继续执行输出add方法的语句，此时便调用了add方法，那么这时再在栈上为add方法分配栈帧，然后再为其形参x,y分配内存，此时将实参的值传给了形参，则形参中x,y也分别对应10，20，然后此时add方法遇到了return语句，则代表方法的结束，那么此时add方法的栈帧会从栈上销毁，然后当主函数执行到大括号时，函数结束，此时main函数在栈上的栈帧同样也会被销毁。
总结：先执行谁，就给谁开辟栈帧，而栈遵循先进后出的原则，先进去的后结束，后进去的先结束，那么add方法便会先销毁，然后main方法后销毁
1.3方法调用的执行过程
基本规则
- 定义方法的时候,不会执行方法的代码.只有调用的时候才会执行.
- 当方法被调用的时候,会将实参赋值给形参.
- 参数传递完毕后,就会执行到方法体代码.
- 当方法执行完毕之后(遇到 return语句),就执行完毕,回到方法调用位置继续往下执行.
- 一个方法可以被多次调用.
代码示例1计算两个整数相加
public class Test {
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
代码示例2:计算 1! + 2! + 3! + 4! + 5!
public class Test {
public static void main(String[] args) {
int sum = 0;
for (int i = 1; i <= 5; i++) {
sum += factor(i);
}
System.out.println("sum = " + sum);
}
public static int factor(int n) {
System.out.println("计算 n 的阶乘中! n = " + n);
int result = 1;
for (int i = 1; i <= n; i++) {
result *= i;
}
return result;
}
}
//执行结果
计算n的阶乘中! n = 1
计算n的阶乘中! n = 2
计算n的阶乘中! n = 3
计算n的阶乘中! n = 4
计算n的阶乘中! n = 5
sum = 153
使用方法,避免使用二重循环,让代码更简单清晰.
1.4实参和形参的关系(重要)
代码示例:交换两个整型变量（思考下面的代码是否可取）
public class Test {
public static void main(String[] args) {
int a = 10;
int b = 20;
swap(a, b);
System.out.println("a = " + a + " b = " + b);
}
public static void swap(int x, int y) {
int tmp = x;
x = y;
y = tmp;
}
}
//运行结果为10，20 原因分析
刚才的代码, 没有完成数据的交换.对于基础类型来说,形参相当于实参的拷贝.即传值调用
对于上面代码中的方法来说，我们此时只是交换了形参中的值，并没有交换main方法中实参的值，原因是我们在栈上是无法获取地址的，所以按值传递并不可取，需使用按引用传递，如下所示
解决办法:传引用类型参数 (例如数组来解决这个问题)
public static void swap(int[] array2){
int temp=array2[0];
array2[0]=array2[1];
array2[1]=temp;
}
public static void main(String[] args) {
int[] array={10,20};
System.out.println("a="+array[0]+" "+"b="+array[1]);
swap(array);
System.out.println("a="+array[0]+" "+"b="+array[1]);
}
}下面我们通过图来分析此段代码：
此时首先定义了一个数组array,注意在java语言中定义一个数组并且初始化时，这个数组我们称之为引用，引用本质上就是一个变量，只不过在里面存的值是地址，而又因为array此时又在main方法里面，那么array又是一个局部变量，则需要在栈上先为main方法开辟栈帧，然后再为array分配内存，而我们数组初始化的值被称作对象，其存储在堆中，{10，20}此时便就在堆中，堆会为这个对象在堆中生成一个地址，我们假设这个地址为0x1110,而array在内存中存储的便是所指对象在堆中的地址（例如此时array数组中存储的就是0x1110这个地址)，在人为逻辑上来说此时引用指向了对象，如上图所示，但是实际内部并没有指向。
此时又调用了swap方法，首先在栈上为·其创建栈帧，然后再为其形参array2数组分配内存，因为将array数组内的实参值分配给了形参array2,就相当于将array内的地址0x1110赋值给了array2,那么逻辑上来说此时array2指向了{10，20}这个对象，接下来我们在swap方法中定义了一个局部变量tmp，此时继续为其在swap方法的栈帧中分配内存，然后执行交换语句后进行输出。那么最终我们的array数组和array2数组都指向了我们的{20，10}这个对象。
1.5没有返回值的方法
方法的返回值是可选的.有些时候可以没有的.
public 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);
}
}另外,如刚才的交换两个整数的方法,就是没有返回值的.
2.方法的重载（Overload)
有些时候我们需要用一个函数同时兼容多种参数的情况,我们就可以使用到方法重载.
2.1重载要解决的问题
代码示例
public class Test {
public static void main(String[] args) {
int a = 10;
int b = 20;
int ret = add(a, b);
System.out.println("ret = " + ret);
double a2 = 10.5;
double b2 = 20.5;
double ret2 = add(a2, b2);
System.out.println("ret2 = " + ret2);
}
public static int add(int x, int y) {
return x + y;
}
}
//编译出错
Test.java:13: 错误:不兼容的类型:从double转换到int可能会有损失double ret2 = add(a2, b2);
但是不是应该这样创建代码呢？
代码示例
public class Test {
public static void main(String[] args) {
int a = 10;
int b = 20;
int ret = addInt(a, b);
System.out.println("ret = " + ret);
double a2 = 10.5;
double b2 = 20.5;
double ret2 = addDouble(a2, b2);
System.out.println("ret2 = " + ret2);
}
public static int addInt(int x, int y) {
return x + y;
}
public static double addDouble(double x, double y) {
return x + y;
}
}这样的写法是对的(例如 Go语言就是这么做的),但是 Java认为addInt这样的名字不友好,不如直接就叫add
2.2使用重载
代码示例
public class Test {
public static void main(String[] args) {
int a = 10;
int b = 20;
int ret = add(a, b);
System.out.println("ret = " + ret);
double a2 = 10.5;
double b2 = 20.5;
double ret2 = add(a2, b2);
System.out.println("ret2 = " + ret2);
double a3 = 10.5;
double b3 = 10.5;
double c3 = 20.5;
double ret3 = add(a3, b3, c3);
System.out.println("ret3 = " + ret3);
}
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;
}
} 方法的名字都叫 add.但是有的 add是计算 int相加,有的是 double相加;有的计算两个数字相加,有的是计算三个数字相加.
同一个方法名字,提供不同版本的实现,称为方法重载。
2.3重载的规则
针对同一个类:(只有在同一个类中方法才能发生重载)
- 方法名相同
- 方法的参数不同(参数个数或者参数类型)
- 方法的返回值类型不影响重载.
代码示例
public class Test {
public static void main(String[] args) {
int a = 10;
int b = 20;
int ret = add(a, b);
System.out.println("ret = " + ret);
}
public static int add(int x, int y) {
return x + y;
}
public static double add(int x, int y) {
return x + y;
}
} //编译出错
Test.java:13:错误:已在类Test中定义了方法add(int,int)
public static double add(int x, int y) {
^
1个错误
总结：当两个方法的名字相同, 参数也相同, 但是返回值不同的时候, 不构成重载.
通过重载我们还可以了解一下可变参数编程，下面通过一个小demo来讲解下可变参数编程：
public class suanshu {
public static int func(int... array) {
int sum = 0;
for (int i : array) {
sum += i;
}
return sum;
}
public static void main(String[] args) {
System.out.println(func(1, 2, 3, 4, 5));
System.out.println(func(4, 3, 2, 1));
System.out.println(func(9, 19, 20, 32));
}
}我们func函数中的形参可以看做是一个数组，可以使用for...each...循环来进行遍历，得到这个数组中的每一个数字。