1. 举例说明什么叫方法

我们利用面向对象的方式来说明什么叫做方法。

我们假设我们有一只猫，这个类型叫做cat类（这里运用到一些面向对象的内容，不用纠结），那么我们这只猫有那些属性呢？

我们假设它的名字叫做marry，年龄为2岁，颜色为白色。

那么它肯定还有一些行为对吧，比如跑，跳，叫，这些都是它的行为，我们称之为方法。

public class demo {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.speak();//speak()这就是方法，我们通过 . 来调用方法
    }
}
class Cat{
    String name ;
    int age ;
    String color;
    public void speak(){
        System.out.println("喵喵喵");
    }
}

2. 方法概念及使用

2.1 什么是方法(method)

方法就是一个代码片段. 类似于C 语言中的"函数"。方法存在的意义 ( 不要背 , 重在体会 ):

1. 是能够模块化的组织代码 ( 当代码规模比较复杂的时候 ).

2. 做到代码被重复使用 , 一份代码可以在多个位置使用 .

3. 让代码更好理解更简单 .

4. 直接调用现有方法开发 , 不必重复造轮子 .

比如我上述的例子，小猫 喵喵喵 就是一个方法。

1.2 方法定义

方法语法格式：

// 方法定义

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

       方法体代码 ;

       [ return 返回值 ];

}

这个修饰符我们以后会有一章重点讲解，这里先不用理解。

示例： 实现一个两个整数相加的方法

public class Method{
// 方法的定义
    public static int add(int x, int y) {
    return x + y;
    }
}

当然啦，方法和C语言中的函数还是有很多不同的。

注意事项：

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

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

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

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

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

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

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

8. 在 java 当中，没有方法声明一说

1.3 方法调用的执行过程

【方法调用过程】

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

就好像做菜，干什么都需要一步一步得走。

【注意事项】

定义方法的时候, 不会执行方法的代码. 只有调用的时候才会执行.

一个方法可以被多次调用.

举例：

public class Method {
    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

1.4 实参和形参的关系(重要)

这个和C语言中的一样，都是一个形参和一个实参，但是和C语言不一样的我们这里只有传值传递，没有了传址传递，具体的以后会细讲。

注意：在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

原因：在swap方法调用时，只是将实参a和b中的值拷贝了一份传递给了形参x和y，具体的解析可以参考之前的C语言。

2. 方法重载

2.1 为什么需要方法重载

比如：我们要求两个数相加，到后面我又需要去求三个、四个、五个数的相加，我不可能去取那么多名字，然后根据不同的名字去找方法，这样太辛苦了。

Java提供了便利，Java中允许同一类中有多个同名的方法的存在，但是要求形参列表不一致。

class 类名{ 
    public static int addInt(int x, int y) {
        return x + y;
    }
    public static double addDouble(double x, double y) {
        return x + y;
    }
}

切记啊，在同一类中的才叫重载。

注意：

1. 方法名必须相同

2. 参数列表必须不同(参数的个数不同、参数的类型不同、类型的次序必须不同)

3. 与返回值类型是否相同无关

// 注意：两个方法如果仅仅只是因为返回值类型不同，是不能构成重载的
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);
    }
    public static int add(int x, int y) {
        return x + y;
    }
    public static double add(int x, int y) {
        return x + y;
    }
}
// 编译出错
Test.java:13: 错误: 已在类 Test中定义了方法 add(int,int)
public static double add(int x, int y) {
        ^
        1 个错误

2.3 方法签名

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

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

L两个同名的方法假设命名为sum(_int,_int)，程序就无法识别，而sun(_double,_double)就可以被区分开。

如下图所示：

方法签名中的一些特殊符号说明：

3. 递归

递归的概念相信大家都懂，我也就不介绍了。

我们直接看例子：递归求 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) {
        System.out.println("函数开始, n = " + n);
        if (n == 1) {
        System.out.println("函数结束, n = 1 ret = 1");
        return 1;
        } in
        t 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

相信大家学过C语言的基本都做过这个。

其他递归的本质就是：追溯，利用后进后出，从追溯底部开始输出步骤。

递归调用的规则：

1. 执行一个方法时，就创建一个新的受保护的独立空间也就是：栈空间。

2. 方法的局部变量是独立的。

3. 如果方法中调用的是引用数据类型（比如数组，类），就需要共享该引用数据类型的数据（存放于堆区中）。

4. 递归必须无限逼近退出条件。

递归执行过程分析

递归的程序的执行过程不太容易理解, 要想理解清楚递归, 必须先理解清楚 "方法的执行过程", 尤其是 "方法执行结束之后, 回到调用位置继续往下执行".

就拿上面的代码画图：