目录

一、方法的基本语法

方法的定义：

方法的调用：

实参与形参的关系

二、方法的重载

三、方法的递归

上节我们讲了Java的逻辑控制，而方法又是什么呢？

一、方法的基本语法

方法的定义： public static 方法返回值 方法名称（ 参数类型 形参  ){                     方法体代码 ;                     return 返回值 ;  }

方法的调用： 返回值变量 = 方法名称 ( 实参 ...);

 

例：用方法计算两个数相加。

运行结果如下：

 

 注意：

1、方法定义时 , 返回值也可以没有 , 如果没有返回值 , 则返回值类型应写成 void。 2、方法定义时的参数称为 " 形参 ", 方法调用时的参数称为 " 实参 "。 3、 方法的定义必须在类之中 , 代码书写在调用位置的上方或者下方均可。Java中没有函数声明的概念。

 

再来个复杂一点的例子：用方法实现 1! + 2! + 3! + 4! + 5! 的计算。

class testdemo {
        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+"的阶乘");
            int result = 1;
            for (int i = 1; i <= n; i++) {
                result *= i;
            }
            return result;
        }
    }


//运行结果

计算1的阶乘
计算2的阶乘
计算3的阶乘
计算4的阶乘
计算5的阶乘
sum = 153

 由上述例子可见，通过 factor（）方法求出每个 i 的阶乘，再返回主方法中用 for 循环累加，即可得出最终结果。

实参与形参的关系

说到它们的关系，我们先来看一道例题。

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;
  }
}



// 运行结果
a = 10 b = 20

为什么这个结果还是a=10，b=20呢？他们不是在swap中交换了吗？

答案是No！这个代码其实并没有完成数据的交换，对于基础类型来说, 形参相当于实参的拷贝。即 为传值调用。并且实参→形参是单向传递的，即实参传递给形参后，形参在函数中交换了值，但是这个函数没有返回值，形参交换完这个方法就结束了。但是实参的值并没有改变。

如果要真正做到交换，要传引用类型参数。等到数组后再分析这种情况。

二、方法的重载 有些时候我们需要用一个函数同时兼容多种参数的情况 , 我们就可以使用到方法重载。

重载满足几个条件：

1、方法名相同。 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);

     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;
 }
}

三、方法的递归 一个方法在执行过程中调用自身 , 就称为 " 递归 "。 递归相当于数学上的 " 数学归纳法 ", 有一个起始条件 , 然后有一个递推公式。 递归只要理解原理就很好掌握。 直接上例子： 例1、 按顺序打印一个数字的每一位 ( 例如 1234 打印出 1  换行  2  换行 3 换行  4)

class Test {
        public static void main(String[] args) {
            print(1234);
        }
         public static void print(int num) {
           if (num > 9) {
           print(num / 10);
     }
           System.out.println(num % 10);
  }
}

//运行结果
1
2
3
4

一定有同学看得一头雾水，想到我开始也是，画个图会更好理解。

递归递归，说到底有“递”和“归”两次执行，如上图，红线标注的为“递”的过程，蓝线标注的为“归”的过程。

 再来个经典例子，求斐波那契数列（只写方法）：

最常见也最好理解的方法就是递归版本的——

public static int fib(int n) { 
     if (n == 1 || n == 2) { 
     return 1; 
 } 
     return fib(n - 1) + fib(n - 2); 
}

但是这有个很严重的弊端，就是当你要求的数稍大一点的时候，程序进行了大量重复的运算，极大程度降低了程序的效率。因此我们求斐波那契基本不使用递归版本的，我们会选择使用循环来优化这个算法——

public static int fib(int n) { 
  if(n==1||n==2){
    return 1;
  }
   int f1 = 1; 
   int f2 = 1; 
   int f3 = 0; 
   for (int i = 3; i <= n; i++) { 
   f3 = f1 + f2; 
   f2 = f1; 
   f1 = f3; 
 } 
   return f3; 
}

解释一下这种方法：

我们定义斐波那契数列的第一项为f1，第二项为f2，第三项为f3。此时使用循环，第三项为第一项与第二项之和，然后让f1变成第二项，f2变成第三项，这样当 i 为4时，f3也通过前两项相加变成了第四项的值...以此类推，可以得出 f3 的值就是我们所传入的、所求的 第 n 项斐波那契数的值。

递归的题太多啦，就不一一列举了。包括很经典的汉诺塔，青蛙跳台阶等问题，网上讲都很详细了，暂时就不一一列举了，咱们下节数组见！！

to be continue →

欢迎大家互相探讨交流补充 欢迎捉虫！