0. 前言
在编程的过程中,经常会出现一部分代码多次使用的情况,比如计算多边形面积,输出固定格式的文字等。
今天我们就来学习方法。
1. 方法的概念和使用
1.1 什么是方法
方法就是一个代码片段,类似于C语言的“函数”。
方法存在的意义:
- 是能够模块化的组织代码(当代码规模比较复杂的时候)
- 做到代码被重复使用, 一份代码可以在多个位置使用.
- 让代码更好理解更简单.
- 直接调用现有方法开发, 不必重复造轮子
1.2 方法的定义
方法的语法格式:
修饰符 返回值类型 方法名称(形参列表){ // 方法体 return 返回值; }
代码示例:实现一个两个整数相加的方法
public static int add(int a, int b) { int c = a + b; return c; }
【注意事项】:
- 修饰符:现阶段直接使用
public static
固定搭配 - 返回值类型:如果方法有返回值,返回值类型必须要与返回的实体类型一致,如果没有返回值,必须写成
void
- 方法名字:采用小驼峰命名
- 参数列表:如果方法没有参数,()中什么都不写,如果有参数,需指定参数类型,多个参数之间使用逗号隔开
- 方法体:方法内部要执行的语句
- 在 Java当中,方法必须写在类当中
- 在 Java当中,方法不能嵌套定义
- 在 Java当中,没有方法声明一说
1.3 方法调用的过程
方法调用过程:
调用方法—>传递参数—>找到方法地址—>执行被调方法的方法体—>被调方法结束返回—>回到主调方法继续往下执行
【注意事项】
- 定义方法的时候, 不会执行方法的代码. 只有调用的时候才会执行.
- 一个方法可以被多次调用
代码示例:计算两个整数相加
public class Main { public static void main(String[] args) { int x = 10; int y = 20; int ret = add(x, y); System.out.println(ret); } public static int add(int a, int b) { int c = a + b; return c; } }
方法调用过程:
DeBug
- 内存图
方法是放在方法区中的,被调用的时候,需要进入到栈内存中运行
一旦程序遇到return
或者方法执行结束,就会把当前方法栈帧就从栈上进行销毁(回收)
1.4 形参和实参(重要)
方法的形参相当于数学函数中的自变量,比如:1 + 2 + 3 + … + n的公式为sum(n) =(1 + n) * n / 2
Java中方法的形参就相当于sum函数中的自变量n,用来接收sum函数在调用时传递的值的。形参的名字可以随意取,对方法都没有任何影响,形参只是方法在定义时需要借助的一个变量,用来保存方法在调用时传递过来的值。
public class Main { public static void main(String[] args) { getSum(10); // 10是实参,在方法调用时,形参n用来保存10 getSum(100); // 100是实参,在方法调用时,形参n用来保存100 } private static int getSum(int n) { // n 是形参 return (1 + n) * n / 2; } }
再比如:
public class Main { public static void main(String[] args) { add(2,3); // 2 和 3 是实参,在调用时传给形参a 和 b } public static int add(int a, int b) { return a + b; } }
1.5 没有返回值的方法
方法的返回值是可选的. 有些时候可以没有的,没有时返回值类型必须写成void
代码示例:
public class Main { public static void main(String[] args) { int a = 10; int b = 20; print(a,b); } private static void print(int x, int y) { System.out.println("x = " + x + ",y = " + y); } }
return
问题
- 如果没有返回值的方法要写
return
,则return
后面不能加任何返回值。
return
后面的语句不会被执行,return
表示方法的结束
2. 方法的重载
2.1 为什么需要方法的重载
由于参数类型不匹配, 所以不能直接使用现有的 add
方法.
一种比较简单粗暴的解决方法如下:
public class Main { public static void main(String[] args) { int x = 10; int y = 20; System.out.println(addInt(x,y)); double a = 1.1; double b = 1.2; System.out.println(addDouble(a,b)); } public static int addInt(int a, int b) { return a + b; } public static double addDouble(double a, double b) { return a + b; } }
上述代码确实可以解决问题,但不友好的地方是:需要提供许多不同的方法名,而取名字本来就是让人头疼的事情。那能否将所有的名字都给成 add
呢?
2.2 方法重载的概念
在Java中,如果多个方法的名字相同,参数列表不同,则称该几种方法被重载了。
public class Main { public static void main(String[] args) { int x = 10; int y = 20; System.out.println(add(x,y));// 调用add(int, int) double a = 1.1; double b = 1.2; System.out.println(add(a,b));// 调用add(double, double) double c = 1.3; System.out.println(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 + c; } }
注意:
- 方法名必须相同
- 参数列表必须不同(参数的个数不同、参数的类型不同、类型的次序必须不同)
- 与返回值类型是否相同无关
2.3 方法签名
在同一个作用域中不能定义两个相同名称的标识符。比如:方法中不能定义两个名字一样的变量,那为什么类中就可以定义方法名相同的方法呢?
方法签名即:经过编译器编译修改过之后方法最终的名字。具体方式:方法全路径名+参数列表+返回值类型,构成方法完整的名字。
3. 递归
3.1 生活中的例子
从前有坐山,山上有座庙,庙里有个老和尚给小和尚将故事,讲的就是:
"从前有座山,山上有座庙,庙里有个老和尚给小和尚讲故事,讲的就是:
“从前有座山,山上有座庙…”
“从前…”
上面的两个例子有个共同的特征:自身中又包含了自己,该种思想在数学和编程中非常有用,因为有些时候,我们遇到的问题直接并不好解决,但是发现将原问题拆分成其子问题之后,子问题与原问题有相同的解法,等子问题解决之后,原问题就迎刃而解了。
3.2 递归的概念
一个方法在执行过程中调用自身, 就称为 “递归”.
递归相当于数学上的 “数学归纳法”, 有一个起始条件, 然后有一个递推公式.
例如, 我们求 N!
起始条件: N = 1 的时候, N! 为 1. 这个起始条件相当于递归的结束条件.
递归公式: 求 N! , 直接不好求, 可以把问题转换成 N! => N * (N-1)!
递归的必要条件:
- 将原问题划分成其子问题,注意:子问题必须要与原问题的解法相同
- 递归出口
代码示例
public class Main { public static void main(String[] args) { fun(); } public static void fun() { fun(); } }
上述代码就是一个最简单的递归。
但是存在错误:出来栈溢出错误的时候,就说明结束条件不对或者没有结束条件
代码示例:递归求 N 的阶乘
public class Main { public static void main(String[] args) { System.out.println(factor(5)); // 120 } public static int factor(int n) { if (n == 1) { return 1; } return factor(n - 1) * n; // factor()方法调用自己 } }
3.3递归执行过程分析
递归的程序的执行过程不太容易理解, 要想理解清楚递归, 必须先理解清楚 “方法的执行过程”, 尤其是 "方法执行结束之后, 回到调用位置继续往下执行.
代码示例:递归求 N 的阶乘
public class Main { public static void main(String[] args) { System.out.println(factor(5)); } public static int factor(int n) { System.out.println("函数开始, n = " + n); if (n == 1) { System.out.println("函数结束, n = 1 ret = 1"); return 1; } int ret = n * factor(n - 1); System.out.println("函数结束, n = " + n + " ret = " + ret); return ret; } } /* 函数开始, n = 5 函数开始, n = 4 函数开始, n = 3 函数开始, n = 2 函数开始, n = 1 函数结束, n = 1 ret = 1 函数结束, n = 2 ret = 2 函数结束, n = 3 ret = 6 函数结束, n = 4 ret = 24 函数结束, n = 5 ret = 120 120 */
执行图:
经典递归问题