目录
1. 举例说明什么叫方法
2. 方法概念及使用
2.1 什么是方法(method)
1.2 方法定义
1.3 方法调用的执行过程
1.4 实参和形参的关系(重要)
2. 方法重载
2.1 为什么需要方法重载
2.3 方法签名
3. 递归
递归执行过程分析
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. 返回值类型：如果方法有返回值，返回值类型必须要与返回的实体类型一致，如果没有返回值，必须写成 void3. 方法名字：采用小驼峰命名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 = 801.4 实参和形参的关系(重要)
这个和C语言中的一样，都是一个形参和一个实参，但是和C语言不一样的我们这里只有传值传递，没有了传址传递，具体的以后会细讲。
就拿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 = 202. 方法重载
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)就可以被区分开。
如下图所示：
方法签名中的一些特殊符号说明：
| 特殊字符 | 数据类型 |
| V | void |
| Z | boolean |
| B | byte |
| C | char |
| S | short |
| I | int |
| J | long |
| F | float |
| D | double |
| [ | 数组(以[开头，配合其他的特殊字符，表述对应数据类型的数组，几个[表述几维数组) |
| L | 引用类型，以L开头，以;结尾，中间是引用类型的全类名 |
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. 递归必须无限逼近退出条件。
递归执行过程分析
递归的程序的执行过程不太容易理解, 要想理解清楚递归, 必须先理解清楚 "方法的执行过程", 尤其是 "方法执行结束之后, 回到调用位置继续往下执行".
就拿上面的代码画图：
