1.方法的基本用法
1.1什么是方法（method）1.2方法定义语法1.3 方法调用的执行过程1.4 实参和形参的关系1.5 没有返回值的方法 2. 方法的重载
2.1 重载要解决的问题2.2 使用重载2.3 重载的规则 3. 方法的递归
3.1 递归的概念3.2 递归执行过程分析3.3 递归练习3.4 小结
1.方法的基本用法 1.1什么是方法（method）方法就是一个代码片段，类似于C语言中的”函数“
方法存在的意义
当代码规模比较复杂的时候，能够模块化的组织代码能做到代码被重复使用，一份代码可以在多个位置使用让代码更好理解，更简单直接调用现有方法开发 1.2方法定义语法
基本语法
//方法定义
public static 方法返回值 方法名称([参数类型 形参 ...]){
方法体代码；
[return 返回值];
}
代码示例：实现一个方法实现两个整数相加
class Test {
public static int add(int x,int y){
return x + y;
}
public static void main(String[] args){
int a = 10;
int b = 20;
int ret = add(a,b);
System.out.println("ret = " + ret);
}
}
注意事项
方法定义时，参数可以没有，每个参数都要指定类型方法定义时，返回值也可以没有，如果没有返回值，则返回值类型应该写为void方法定义时的参数称为”形参“，方法调用时的参数称为”实参“方法的定义必须在类中，代码写在调用位置的上方或者下方都可以Java中没有”函数声明“这一概念 1.3 方法调用的执行过程
基本规则
定义方法的时候，不会执行方法的代码，只有调用的时候才会执行当方法被调用后，实参会赋值给形参参数传递完毕后，就会执行到方法体代码当方法体代码执行完毕后（遇到return语句），回到方法调用位置继续往下执行一个方法可以被多次调用
代码示例1：计算两个整数相加
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!
class Test{
public static void main (String[] args){
int sum = 0;
for(int i = 1; i <= 5; i++){
sum = sum + factor(i);
}
System.out.println("sum = " + sum);
}
public static int factor(int n){
System.out.println("计算n的阶乘中，n = " + n);
int ret = 1;
for(int i = 1; i <= n; i++){
ret = ret * i;
}
return ret;
}
}
//执行结果
计算 n 的阶乘中! n = 1
计算 n 的阶乘中! n = 2
计算 n 的阶乘中! n = 3
计算 n 的阶乘中! n = 4
计算 n 的阶乘中! n = 5
sum = 153
1.4 实参和形参的关系
代码示例：交换两个整型变量
class Test {
public static void main (String[] args){
int a = 10;
int b = 20;
swop(a,b);
System.out.println("a = " + a + "b = " + b);
}
public static void swap(int x ,int y){
int tmp = x;
x = y;
y = tmp;
}
}
//运行结果
a = 10 b = 20
原因分析
上述代码没有完成数据的交换
对于基础类型来说，形参相当于实参的拷贝，即传值调用
对x,y的修改，不影响a和b
解决办法：传引用类型参数
class Test {
public static void main(String[] args) {
int[] arr = {10, 20};
swap(arr);
System.out.println("a = " + arr[0] + " b = " + arr[1]);
}
public static void swap(int[] arr) {
int tmp = arr[0];
arr[0] = arr[1];
arr[1] = tmp;
}
}
// 运行结果
a = 20 b = 10
1.5 没有返回值的方法
方法的返回值是可选的，有些时候可以没有返回值
代码示例
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. 方法的重载
有些时候我们需要用一个函数同时兼容多种参数的情况, 我们就可以使用到方法重载
2.1 重载要解决的问题代码示例
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);
}
}
//编译错误 从double转换到int可能会损失
由于参数类型不匹配，所以不能直接使用现有的add方法
正确写法
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 add(int x, int y) {
return x + y;
}
public static double add(double x, double y) {
return x + y;
}
}
2.2 使用重载
代码示例
class Test{
public static int add(int a, int b) {
return a + b;
}
public static double add(double a, double b) {
return a + b;
}
public static int add(int a,int b,int c){
return a + b + c;
}
public static void main2(String[] args) {
int a = 10;
int b = 20;
int e = 30;
double c = 10.3;
double d = 20.4;
System.out.println(add(a, b));
System.out.println(add(c, d));
System.out.println(add(a, b, e));
System.out.println(add (1,2,3));
}
}
方法的名字都叫add，但是有的add是计算int相加，有的是计算double相加，有的是计算三个数字相加
同一个方法名字，提供不同版本的实现，称为方法重载
2.3 重载的规则可以不是同一个类方法名相同方法的参数列表不用（类型，个数）方法的返回值不做要求
代码示例
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中定义了方法add
当两个方法的名字相同，参数也相同，但返回值不同的时候，不构成重载
3. 方法的递归 3.1 递归的概念一个方法在执行过程中调用自身，就称为 递归
实现递归，需要一个递推公式，有一个趋于终止的条件。
代码示例：递归求N的阶乘
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
3.2 递归执行过程分析
递归的程序的执行过程不太容易理解, 要想理解清楚递归, 必须先理解清楚 "方法的执行过程", 尤其是 “方法执行结束之后, 回到调用位置继续往下执行”
代码示例
public static void main(String[] args) {
int n = 5;
int ret = factor(n);
System.out.println("ret = " + ret);
}
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
ret = 120
3.3 递归练习
代码示例1：按顺序打印一个数字的每一位（例如1234 打印出 1 2 3 4）
public static void print(int num){
if(num < 10){
System.out.println(num % 10 + " ");
}else{
print(n / 10);
System.out.println(num % 10 + " ");
}
}
代码示例2:递归求1+2+3+……+10
public static void main(String[] args) {
System.out.println(sumAdd2(10));
}
public static int sumAdd(int n){
if(n == 1){
return 1;
}
return n + sumAdd(n-1)；
}
代码示例3：写一个递归方法，输入一个非负整数，返回组成它的数字之和。例如输入1234，返回10
public static void main(String[] args) {
System.out.println(sumprint(1234));
}
public static int sumprint(int n){
int sum = 0;
if(n < 10){
return n;
}
return sum = n % 10 + sumprint(n / 10);
}
代码示例4：求斐波那契数列的第N项
public static int fib(int n){
if( n == 1 || n == 2){
return 1;
}
return fib(n - 1) + fib(n - 2);
}
当我们求fib（40）的时候发现，程序执行速度极慢，原因是进行了大量的重复运算
class Test {
public static int count = 0; // 这个是类的成员变量. 后面会详细介绍到.
public static void main(String[] args) {
System.out.println(fib(40));
System.out.println(count);
}
public static int fib(int n) {
if (n == 1 || n == 2) {
return 1;
}
if (n == 3) {
count++;
}
return fib(n - 1) + fib(n - 2);
}
}
// 执行结果
102334155
39088169 // fib(3) 重复执行了 3 千万次
用循环的方式求斐波那契额数列问题，避免出现冗余运算
public static int fib(int n){
int f1 = 1;
int f2 = 1;
int f3 = 0;
for(int i = 3; i <= n; i++){
f3 = f1 = f2;
f1 = f2;
f2 = f3;
}
return f3;
}
3.4 小结
递归是一种重要的编程解决问题的方式.
有些问题天然就是使用递归方式定义的(例如斐波那契数列, 二叉树等), 此时使用递归来解就很容易.
有些问题使用递归和使用非递归(循环)都可以解决. 那么此时更推荐使用循环, 相比于递归, 非递归程序更加高效.
