方法的使用
- 方法的概念
- 什么是方法
- 方法定义
- 方法的调用过程
- 实参和形参的关系
- 方法重载
- 为什么需要方法重载
- 方法重载的概念
- 方法签名
- 递归
- 递归的概念
- 递归过程分析
- 递归练习
方法的概念
什么是方法
方法就是一个代码片段，类似于C语言的函数。
方法存在的意义：
- 是能够模块化的组织代码（当代码规模比较复杂的时候）
- 做到代码被重复使用，一份代码可以在多个位置使用
- 让代码更好理解更简单
- 直接调用现有方法使用，不用重复写一份代码
方法定义
语法格式：
//方法定义
修饰符 返回值类型 方法名称([参数类型 形参...]){
方法体代码;
[return 返回值];
}
例子1：实现一个函数，用于检测年份是否为闰年
public static boolean isLeapYear(int year){
if ((year % 400 == 0) || ((year % 100 != 0) && (year % 4 == 0))){
return true;
}
return false;
}
public static void main(String[] args) {
int year = 2023;
if (isLeapYear(year)){
System.out.println("是闰年");
}else{
System.out.println("不是闰年");
}
}
注意：
- 返回值类型：如果方法有返回值，返回值类型必须要与返回的实体类型一致，如果没有返回值，必须写成void
- 方法名字：采用小驼峰命名（首个单词的首个字母小写，后续单词首字母大写）
- 参数列表：如果方法没有参数。()中什么都不写，如果有参数，需指定参数类型，多个参数之间用逗号隔开
- 方法体：方法内部要执行的语句
- 在java当中，方法必须写在类当中
- 在java中，方法不能嵌套定义
- 在java中，没有方法声明一说
方法的调用过程
调用方法–>传递参数–>找到方法地址–>执行被调方法的方法体–>被调方法结束返回–>回到主调方法继续往下执行
注意：
- 定义方法的时候，不会执行方法的代码，只有调用的时候才会执行
- 一个方法可以被多次调用
例子：计算 1! + 2! + 3! + 4! + 5!
//计算 1! + 2! + 3! + 4! + 5!
public static int func(int n){
int result = 1;
for (int i = 1; i <= n; i++) {
result *= i;
}
return result;
}
public static void main(String[] args) {
int sum = 0;
for (int i = 1; i <= 5; i++) {
sum += func(i);
}
System.out.println(sum);
}
实参和形参的关系
java当中方法的形参相当于数学函数的自变量，用来接收函数调用时传递的值，形参的名字是可以随意取的，对方法没有任何影响，形参只是方法在定义时需要借助的一个变量，用来保存方法在调用时传递过来的值。
public static int add(int a, int b){ //a, b是形参
return a + b;
}
public static void main(String[] args){
int ret = add(2,3); //2,3是实参，a，b分别用来保存2，3，在调用时传给形参a和b
System.out.println(ret);
}
注意：在java中，实参的值永远是拷贝到形参中，形参和实参本质是两个实体。
例子：交换两个整型变量
public static void swap(int a, int b){
int tmp = a;
a = b;
b = tmp;
System.out.println("swap:a = " + a + " b = " + b);
}
public static void main(String[] args) {
int a =10;
int b = 20;
swap(a, b);
System.out.println("main:a = " + a + " b = " + b);
//运行结果：
//swap:a = 20 b = 10
//main:a = 10 b = 20
}
可以看到，在swap交换之后，形参a，b值发生了改变，但是main方法中a和b还是交换之前的值，即没有交换成功。
原因：因为实参a，b是main方法中的变量，其空间在main方法的栈中，而形参a和b是swap方法中的两个变量，a和b的空间在swap方法运行时的栈中，因此实参a和b与形参a和b是两个没有关联性的变量，在swap方法调用时，只是将实参a和b值拷贝一份传递给了形参a和b，因此对形参a和b操作不会对实参a和b产生任何影响
注意：对于基础类型，形参相当于实参的拷贝，即传值调用
解决方法：传引用类型参数（例如通过数组来解决）（java中，拿不到栈上变量的地址）
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("main:"+arr[0] + " " + arr[1]);
}
方法重载
为什么需要方法重载
public static int add(int a, int b){
return a + b;
}
public static void main(String[] args) {
int x = 10;
int y = 20;
int ret1 = add(x,y);
double a = 2.0;
double b = 1.0;
double ret2 = add(a,b);//编译报错：不兼容的类型: 从double转换到int可能会有损失
}
任何解决呢
我们可能会采取再写另外一个方法
public static int add(int a, int b){
return a + b;
}
public static double addDouble(double a, double b){
return a + b;
}
public static void main(String[] args) {
int x = 10;
int y = 20;
int ret1 = add(x,y);
double a = 2.0;
double b = 1.0;
double ret2 = addDouble(a,b);//编译报错：不兼容的类型: 从double转换到int可能会有损失
}
但是随着需求和要求增加，每增加新类型参数就需要新写一个方法，重新起一个方法名，想许多不同的方法名是一件比较烦人的事，能否都是同一个方法名呢？
方法重载的概念
在java中，方法是可以重载的，在java中，如果多个方法的名字相同，参数列表不同，则说该几种方法被重载了。
例子：
public static int add(int a, int b){
return a + b;
}
public static double add(double a, double b){
return a + b;
}
public static double add(double a, double b, double c){
return a + b + c;
}
public static void main(String[] args) {
int x = 10;
int y = 20;
int ret1 = add(x,y);//调用add(int,int)
double a = 2.0;
double b = 1.0;
double c = 3.0;
double ret2 = add(a,b);//调用add(double,double)
double ret3 = add(a,b,c);//调用add(double,double,double)
}
注意：
- 方法名必须相同
- 参数列表必须不同（参数的个数、参数的类型、类型的次序）
- 与返回值类型是否相同无关
- 如果两个数仅仅只是因为返回值类型不同，是不能构成重载的，会编译出错
- 编译器在编译代码时，会对实参类型进行推演，根据推演的结果来确定调用哪个方法
方法签名
方法签名：经过编译器编译修改过之后方法的最终名字。具体方式：方法全路径名+参数列表+返回值类型，构成方法完整的名字。
public static int add(int a, int b){
return a + b;
}
public static double add(double a, double b){
return a + b;
}
public static double add(double a, double b, double c){
return a + b + c;
}
public static void main(String[] args) {
int x = 10;
int y = 20;
int ret1 = add(x,y);//调用add(int,int)
double a = 2.0;
double b = 1.0;
double c = 3.0;
double ret2 = add(a,b);//调用add(double,double)
double ret3 = add(a,b,c);//调用add(double,double,double)
}
上述代码经过编译之后，然后使用JDK自带的javap反汇编工具查看，具体操作：
- 先对工程进行编译生成.class字节码文件
- 在控制台中进入到要查看的.class所在的目录
- 输入：javap -v 字节码文件名字即可
| 特殊字符 | 数据类型 |
|---|---|
| V | void |
| Z | boolean |
| B | byte |
| C | char |
| S | short |
| I | int |
| J | long |
| F | float |
| D | double |
| [ | 数组（以[开头，配合其他的特殊字符，表述对应数据类型的数组，几个[表述几维数组） |
| L | 引用类型，以L开头，以;结尾，中间是引用类型的全类名 |
递归
递归的概念
一个方法在执行过程中调用自身，即”递归“
解决递归问题：
- 有一个递归公式
- 找到当前递归问题的解决条件
例子：用递归求N的阶乘
public static int func(int n){
if (n == 1){
return 1;
}
return n * func(n - 1);
}
public static void main(String[] args) {
int n = 5;
int ret = func(5);
System.out.println(ret);
//结果是120
}
递归过程分析
理解清楚递归，首先必须理解清楚“方法的执行过程”，尤其是“方法执行结束之后，回到调用位置继续往下执行”
关于调用栈
方法调用的时候，会有一个“栈”这样的内存空间描述当前的调用关系，称为调用栈。
每一次的方法调用就称为一个“栈帧”，每个栈帧中包含了这次调用的参数是哪些，返回到哪里继续执行等信息。
递归练习
例子1：按顺序打印数字的每一位（例如1234，打印1 2 3 4）
//按顺序打印数字的每一位（例如1234，打印1 2 3 4）
public static void print(int n){
if (n > 9){
print(n / 10);
}
System.out.print(n % 10 + " ");
}
public static void main(String[] args) {
int num = 1234;
print(num);
}
例子2：递归求1 + 2 + 3 + … + 9 + 10
//递归求1 + 2 + 3 + ... + 9 + 10
public static int sum(int n){
if (n == 1){
return 1;
}
return n + sum(n -1);
}
public static void main(String[] args) {
int num = 10;
int ret = sum(num);
System.out.println(ret);
//计算结果是55
}
例子3：写一个递归方法，输入一个非负整数，返回组成它的数字之和. 例如，输入 1729, 则应该返回1+7+2+9，它的和是19
//写一个递归方法，输入一个非负整数，返回组成它的数字之和. 例如，输入 1729, 则应该返回1+7+2+9，它的和是19
public static int sum(int n){
if (n < 10) {
return n;
}
return n % 10 + sum(n / 10);
}
public static void main(String[] args) {
int num = 1729;
int ret = sum(num);
System.out.println(ret);
}
例子4：求斐波那契数列的第N项
//求斐波那契数列的第N项
public static int fib(int n){
if (n == 1 || n == 2){
return 1;
}
return fib(n - 2) + fib(n-1);
}
public static void main(String[] args) {
System.out.println(fib(5));
}
当我们求fib(40)的时候发现程序运行速度很慢，原因是进行了大量的重复运算
public static int fib(int n){
if (n == 1 || n == 2){
return 1;
}
if (n == 3){
count++;
}
return fib(n - 2) + fib(n-1);
}
public static void main(String[] args) {
System.out.println(fib(40));
System.out.println(count );
}
//计算结果：102334155
// 39088169(fib(3)计算的次数)
我们可以使用循环求斐波那契数列，避免冗余的计算。
public static int fib(int n){
int num1 = 1;
int num2 = 1;
for (int i = 2; i < n; i++) {
int tmp = num1 + num2;
num1 = num2;
num2 = tmp;
}
return num2;
}
public static void main(String[] args) {
System.out.println(fib(40));
}
———————————————————————————————————————————
对于方法的学习我们先了解到这里，后续我们继续学习和了解java的内容。
