Java中的方法详解
一、什么是方法？
方法就是一个代码片段. 类似于 C 语言中的 “函数”。方法存在的意义(不要背, 重在体会):
-
是能够模块化的组织代码(当代码规模比较复杂的时候).
-
做到代码被重复使用, 一份代码可以在多个位置使用.
-
让代码更好理解更简单.
-
直接调用现有方法开发, 不必重复造轮子.
比如写一个打印函数：
那么方法该如何定义呢？
二、方法的定义
1.方法定义格式
// 方法定义
修饰符 返回值类型 方法名称([参数类型 形参 ...]){
方法体代码;
(return 返回值;)
}
示例1：实现判断一个年份是否是闰年
public class Test {
public static boolean judgeLeap (int year) {
if((0 == year % 4 && 0 != year % 100) || 0 == year % 400) {
return true;
} else {
return false;
}
}
public static void main(String[] args) {
System.out.println("请输入一个年份：");
Scanner scanner = new Scanner(System.in);
int year = scanner.nextInt();
System.out.println(judgeleap(year));
}
}
示例二：实现两个数相加
public class Test {
public class static int add (int num1,int num2) {
int sum = num1 + num2;
return sum;
}
public static void main(String[] args) {
int num1 = 10;
int num2 = 20;
System.out,println(Add(a,b));
}
}
2.注意事项
- 修饰符：现阶段直接使用public static 固定搭配
- 返回值类型：如果方法有返回值，返回值类型必须要与返回的实体类型一致，如果没有返回值，必须写成
void - 方法名字：采用小驼峰命名
- 参数列表：如果方法没有参数，()中什么都不写，如果有参数，需指定参数类型，多个参数之间使用逗号隔开
- 方法体：方法内部要执行的语句
- 在java当中，方法必须写在类当中
- 在java当中，方法不能嵌套定义
- 在java当中，没有方法声明一说
3. 方法调用的执行过程
（1）方法调用过程
调用方法—>传递参数—>找到方法地址—>执行被调方法的方法体—>被调方法结束返回—>回到主调方法继续往下
执行
public class Test {
public static int add (int n1,int n2) {
System.out.println("调用方法中 n1 = " + n1 + " n2 = " + n2);
return n1 + n2;
}
public static void main (String[] args) {
int num1 = 10;
int num2 = 20;
int num3 = 30;
int num4 = 40;
System.out.println("第一次调用方法之前");
add(num1,num2);
System.out.println("第一次调用方法之后");
System.out.println("ret = " + ret);
add(num3,num4);
System.out.println("第二次调用方法之前");
add(num3,num4);
System.out.println("第二次调用方法之后");
System.out.println("ret = " + ret);
}
}
//执行的结果
第一次调用方法之前
调用方法中 n1 = 10 n2 = 20
第一次调用方法之后
ret = 30
第二次调用方法之前
调用方法中 n1 = 30 n2 = 40
第二次调用方法之后
ret = 70
【注意事项】
- 定义方法的时候, 不会执行方法的代码. 只有调用的时候才会执行.
- 一个方法可以被多次调用.
4.形参和实参的关系
Java中方法的形参就相当于sum函数中的自变量n，用来接收sum函数在调用时传递的值的。形参的名字可以随意取，对方法都没有任何影响，形参只是方法在定义时需要借助的一个变量，用来保存方法在调用时传递过来的值。
public static int add (int n1,int n2) {
//n1和n2就是形参
return n1 + n2;
}
add(num1,num2);//num1和num2就是实参，在方法被调用时，形参n1用来保存num1的数值，形参n2用来保存num2的数值
注意：在Java中，实参的值永远都是拷贝到形参中，形参和实参本质是两个实体
代码示例：交换两个数的值
public class Test {
public static void swap (int num1,int num2) {
int tmp = num1;
num1 = num2;
num2 = tmp;
System.out.println("swap: num1 = " + num1 +"num2 = " + num2;
}
public static void main(String[] args) {
int a = 10;
int b = 20;
swap(a, b);
System.out.println("main: a = " + a + " b = " + b);
}
}
//运行结果
//swap:num1= 20num2 = 10
//main:a = 10b = 20
可以看到，在swap函数交换之后，形参x和y的值发生了改变，但是main方法中a和b还是交换之前的值，即没有交
换成功。
原因：
实参a和b是main方法中的两个变量，其空间在main方法的栈(一块特殊的内存空间)中，而形参num1和num2是swap方法中的两个变量，num1和num2的空间在swap方法运行时的栈中，因此：实参a和b 与 形参x和y是两个没有任何关联性的变量，在swap方法调用时，只是将实参a和b中的值拷贝了一份传递给了形参num1和num2，因此对形参num1和num2操作不会对实参a和b产生任何影响。
解决方法：可用数组来解决此问题
public class TestMethod {
public static void swap(int[] arr) {
int tmp = arr[0];
arr[0] = arr[1];
arr[1] = tmp;
}
public static void main(String[] args) {
int[] arr = {10, 20};
swap(arr);
System.out.println("arr[0] = " + arr[0] + " arr[1] = " + arr[1]);
}
}
// 运行结果
arr[0] = 20 arr[1] = 10
关于这个代码的运行过程, 后面学习数组的时候再详细解。
5.没有返回值的方法
关于方法返回值的有无是可以自己选择的，没有返回值的方法写成void。
代码示例：
public class Test {
public static void Print (int a) {
System.out.println(a);
}
public static void main (String[] args) {
int a = 10;
Print(a);
}
}
//此代码就没有返回值，
6.带返回值的方法和调用
关于带返回值的方法，类型根据返回值类型确定。
代码示例：
public class Test {
public static int Sum (int num1,int num2,int num3) {
int result = num1 + num2 + num3;
retuirn result;
}
public static void main (String[] args) {
//直接调用
getSum(10,20,30);
//赋值调用
int sum = getSum(10,20,30);
System.out.println(sum);
//输出调用
System.out.println(getSum(10,20,30));
}
}
7.方法的重载
概念：在同一个类中，定义了多个同名的方法，这些同名的方法具有相同的功能，且每一个方法具有不同的参数或者参数个数不同，这些同名的方法构成了重载关系。
简单记忆：在同一个类中，方法名称相同，参数（个数，类型，顺序）不同的方法，与返回值无关。
示例代码一：
public static int sum (int a,int b) {
return a + b;
}
public static int sum (int a,int b,int c) {
return a + b + c;
}
//构成重载关系，以为个数不一样
示例代码二：
public static void func (int a) {
//方法体
}
public static int func (int a) {
//方法体
}
//不构成重载关系，因为参数都一样，不用管返回值！
示例代码三：
public static float func (int a) {
//方法体
}
public static int func (int a,int b) {
//方法体
}
//构成重载，因为参数个数不同
示例代码四：
public class Test1 {
public static void func (int a) {
//方法体
}
}
public class Test2 {
public static int func (double b) {
//方法体
}
}
//不构成重载关系，因为分别在两个类中
【注意事项】
- 方法名必须相同。
- 参数列表必须不同(参数的个数不同、参数的类型不同、类型的次序必须不同)。
- 与返回值类型是否相同无关。
- 编译器在编译代码时，会对实参类型进行推演，根据推演的结果来确定调用哪个方法。
8.方法中的签名
方法签名，是来区分不同方法的标示符。
Java方法签名包括两部分：方法名和参数列表。
方法名不同或者参数列表不同都可以用来区分不同的方法。
具体方式：方法全路径名+参数列表+返回值类型，构成方法完整的名字。
Java中就是根据此来判断应该调用哪一个函数的。
示例代码：
public class TestMethod {
public static int add(int x, int y){
return x + y;
}
public static double add(double x, double y){
return x + y;
}
public static void main(String[] args) {
add(1,2);
add(1.5, 2.5);
}
}
上述代码经过编译之后，然后使用JDK自带的javap反汇编工具查看，具体操作：
- 先对工程进行编译生成.class字节码文件
- 在控制台中进入到要查看的.class所在的目录
- 输入：javap -v 字节码文件名字即可
三、递归
1.概念
一个方法在执行过程中调用自身，就称为递归。
示例代码: 用递归求N的阶乘
public class Test {
public static int fac (int n) {
if(n==1) {
return n;
}
int num = n * fac(n-1);
return num;
}
public static void main (String[] args) {
System.out.println("请输入一个数字：");
Scanner scanner = new Scanner();
int n = scanner.nextInt();
int end = fac(n);
System.out.println("end="+end);
}
}
代码讲解：
当我们从键盘输入n=5，通过方法调用将n=5传过去，在方法中，n=5，不满足if语句，num=5fac(4),再次调用方法，此时形参n=4，不满足if语句，num=4
fac(3),再次调用方法fac，n=3，不满足if语句，num=3 * fac(2),再次调用fac，n=2，不满足if语句，num=2 fac (1)，最后调用fac，n=1，然后return 1，返回到上一步的fac，num=2，又返回到上一个fac中，num=6，直到最后返回到第一次调用此函数中，num=120.
2.规则
- 执行一个方法时，就会创建一个新的受保护的栈空间。
- 方法的局部变量是独立存在的，不会相互影响。
- 如果方法中使用的是引用变量（如数组），就会共享此引用类型中的数据。
- 递归必须向退出递归的条件逼近，否则就会无限递归，最终出现StackOverflowError。
- 当一个方法执行完毕，或者遇到return，就会返回，遵循谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。
3.代码练习
用递归方法求斐波那契数列的第n个数字
关于斐波那契数列的介绍：黄金分割数列——斐波那契数列 - 知乎 (zhihu.com)
简单来理解，斐波那契数列是前两项和等于第三项，以此类推。
Demo：
import java.util.Scanner;
public class Test1 {
public static int fib (int num) {
if (num <= 2)//因为在一开始就有最初的两项，1和1，所以要<=2
return 1;
else
return fib(num - 1) + fib(num - 2);
}
public static void main(String[] args) {
System.out.println("请输入你想求的斐波那契数列的第几项：");
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int end = fib(n);
System.out.println("斐波那契数列的第"+n+"项为："+end);
}
}
代码讲解：
由于用递归求斐波那契数列第n项太麻烦，我这里就简单求第四项，在平常咱们都是用循环去写的，
斐波那契数列：1,1,2,3,5,8,13··········
以上就是关于Java中方法的基本介绍，如果各位小伙伴发现文章有什么问题或者不懂的地方，欢迎提出和咨询！！！
900
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
