在之前我们学习C语言时，当我们想要重复使用某段代码的功能时，我们会将这段代码定义为一个函数，而在java中我们把这段重复使用的代码叫做方法。

方法的定义

类体的内容分为变量的声明和方法的定义，方法的定义包括两部分：方法头和方法体。

// 方法定义

修饰符 返回值类型 方法名称 ([ 参数类型 形参 ...]){

方法体代码 ;

[ return 返回值 ];

}

public class Method{
    public static boolean LeapYear(int year){
       if((year%4==0&&year%100!=0)||year%400==0)){
                 return true;
           }
      else{
                 return false;
            }
    }
}

【 注意事项 】

1. 修饰符：现阶段直接使用 public static 固定搭配

2. 返回值类型：如果方法有返回值，返回值类型必须要与返回的实体类型一致，如果没有返回值，必须写成

void

3. 方法名字：采用小驼峰命名

4. 参数列表：如果方法没有参数， () 中什么都不写，如果有参数，需指定参数类型，多个参数之间使用逗号隔开

5. 方法体：方法内部要执行的语句

6. 在 java 当中，方法必须写在类当中

7. 在 java 当中，方法不能嵌套定义

8. 在java当中，没有方法声明一说,java是在全局搜索的，这点与c语言不一样哦。

方法调用的执行过程

【方法调用过程】

      调用方法 --- > 传递参数 --- > 找到方法地址 --- > 执行被调方法的方法体 --- > 被调方法结束返回 --- > 回到主调方法继续往下 执行。

这里在给大家一个例子好好体会一下java方法的语法：

计算1到5的阶乘：

public class TestMethod {
public static void main(String[] args) {
int sum = 0;
for (int i = 1; i <= 5; i++) {
sum += fac(i);
}
System.out.println("sum = " + sum);
}
public static int fac(int n) {
System.out.println("计算 n 的阶乘中n! = " + n);
int result = 1;
for (int i = 1; i <= n; i++) {
result *= i;
}
return result;
}
}

// 执行结果
计算 n 的阶乘中 n! = 1
计算 n 的阶乘中 n! = 2
计算 n 的阶乘中 n! = 3
计算 n 的阶乘中 n! = 4
计算 n 的阶乘中 n! = 5
sum = 153

java方法中形参与实参的关系

这里需要着重给大家强调，在java中所有的方法里形参都是实参的一份临时拷贝，这里与C语言是一样的。

还是给大家列举一个交换数值的例子帮助理解：

public class TestMethod {
public static void main(String[] args) {
int a = 10;
int b = 20;
swap(a, b);
System.out.println("main: a = " + a + " b = " + b);
}
public static void swap(int x, int y) {
int tmp = x;
x = y;
y = tmp;
System.out.println("swap: x = " + x + " y = " + y);
}
}
// 运行结果
swap: x = 20 y = 10
main: a = 10 b = 20

我们发现a与b的值并没有因为经过swap而发生交换，交换的只不过是形参x,y而实参a,b并没有改变。

注意：对于基础类型来说, 形参相当于实参的拷贝. 即 传值调用

方法重载

功能多态性就是指可以向功能传递不同的消息，以便让对象根据相应的消息来产生相应的行为。对象的行为通过类中的方法来体现，那么行为的多态性就是方法的重载。

简单点来说的话就是：

public class TestMethod {
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);
}
public static int add(int x, int y) {
return x + y;
}
}

还是举个例子帮助理解：

public class TestMethod {
public static void main(String[] args) {
add(1, 2); // 调用add(int, int)
add(1.5, 2.5); // 调用add(double, double)
add(1.5, 2.5, 3.5); // 调用add(double, double, double)
}
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;
}
}

 方法签名

在同一个作用域中不能定义两个相同名称的标识符。比如：方法中不能定义两个名字一样的变量，那 为什么类中就

可以定义方法名相同的方法呢？

方法签名即：经过编译器编译修改过之后方法最终的名字。具体方式： 方法全路径名 + 参数列表 + 返回值类型，构成

方法完整的名字。

这就是方法重载这个概念建立的基础。 

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

Java递归

从前有坐山，山上有座庙，庙里有个老和尚给小和尚将故事，讲的就是：

" 从前有座山，山上有座庙，庙里有个老和尚给小和尚讲故事，讲的就是：

" 从前有座山，山上有座庙 ..."

" 从前有座山 ……"

这小段话完美诠释了递归的思想，就是在方法中调用自己的行为。 

递归的必要条件：

1. 将原问题划分成其子问题，注意：子问题必须要与原问题的解法相同

2. 递归出口

这里利用递归求一下n的阶乘

public class Main {
    public static int factor(int n){
        if(n==0){
            return 1;
        }
        else{
            return n*factor(n-1);
        }
    }
    public static void main(String[] args) {
        int n=5;
        int ret=factor(n);
        System.out.println(ret);
    }
}

 递归执行过程分析

这里要强调的是递归写出来的代码，对比其他的代码往往比较简洁清晰，但是我们知道，方法调用结束时才会释放它在内存中的数据，而递归他会在每一次递归的过程时产生一个新的方法的调用，这样会给内存很大负担，影响运行效率。 

递归练习

这里给大家几道递归的题，让大家体会一下递归的快乐：

public static void print(int num) {
if (num > 9) {
print(num / 10);
}
System.out.println(num % 10);
}

public static int sum(int num) {
if (num == 1) {
return 1;
}
return num + sum(num - 1);
}

public static int sum(int num) {
if (num < 10) {
return num;
}
return num % 10 + sum(num / 10);
}

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