前言
对于这种内容较为复杂的马原笔记重点，山居以为我传给你抄，你传给他抄，他再传给隔壁王二麻子抄，效率显然比较低下，最为便捷的方法就是将笔记重点模块化，写成一个大的文件，然后上传到学校的学习资料库中，无论谁想要，自己查看，自己下载
在这里笔记重点放到代码编程中便可以叫做方法(函数)。
总结来说，方法的存在：
是能够模块化的组织代码(当代码规模比较复杂的时候).
做到代码被重复使用, 一份代码可以在多个位置使用.
让代码更好理解更简单.
直接调用现有方法开发, 不必重复造轮子
一、方法的基本用法
1、方法的定义
??基本语法形式:
// 方法定义
public static 方法返回值 方法名称（[参数类型 形参 ...]){
方法体代码;
[return 返回值];
}
// 方法调用
返回值变量 = 方法名称(实参...);
📑代码示例：
计算1！+ 2！+ 3！+ …… + n！
public class TestDemo{
//实现阶乘的相加的方法
public static int ansSum(int n) {
int sum = 0;
for (int i = 1; i <= n ; i++) {
sum += fac(i);
}
return sum;
}
//实现阶乘的方法
public static int fac(int m) {
int ret = 1;
for (int i = 1; i <= m; i++) {
ret *= i;
}
return ret;
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int ret = ansSum(n);
System.out.println(ret);
}
}
🏸 代码结果：
💬代码解释：
- public 和 static 两个关键字在此处具有特定含义,后面会详细介绍.
- 方法定义时, 参数可以没有.，每个参数要指定类型. 返回值也可以没有, 如果没有返回值, 则返回值类型应写成 void
- 方法定义时的参数称为 “形参”, 方法调用时的参数称为 “实参”.
- 方法的定义必须在类之中, 代码书写在调用位置的上方或者下方均可，Java 中==没有 “函数声明”==这样的概念.
注意：
- 函数的返回值要匹配.
- 参数的个数，对应的类型都要匹配.
- 只能返回一个数据.
- return 代表函数的结束，在 return 的后面不要写任何代码，不会被执行，还会报错.
2、方法的调用
基本规则：
- 定义方法的时候, 不会执行方法的代码. 只有调用的时候才会执行.
- 当方法被调用的时候, 会将实参赋值给形参.
- 参数传递完毕后, 就会执行到方法体代码.
- 当方法执行完毕之后(遇到 return 语句), 就执行完毕, 回到方法调用位置继续往下执行.
- 一个方法可以被多次调用.
方法的调用需要在栈上开辟空间，当函数调用结束后，该栈帧就会被系统回收，栈帧里面的值就会被销毁
二、方法的重载
我们需要用一个函数同时兼容多种参数的情况, 我们就可以使用到方法重载.
📑代码示例：
public class TestDemo{
//实现两个整形相加
public static int add(int n, int m) {
return n + m;
}
//实现两个双精度浮点型相加
public static double add(double n, double m) {
return n + m;
}
//实现三个双精度浮点型相加
public static double add(double n, double m,double p) {
return n + m + p;
}
public static void main(String[] args) {
int a1 = 10;
int a2 = 20;
System.out.println(add(a1, a2));
double b1 = 1.1;
double b2 = 1.2;
double b3 = 1.4;
System.out.println(add(b1, b2));
System.out.println(add(b1, b2, b3));
}
}
🏸 代码结果：
💬代码解释：
同一个方法名字, 提供不同版本的实现, 称为 方法重载
上面的代码中方法的名字都叫 add. 但是有的 add 是计算 int 相加, 有的是 double 相加; 有的计算两个数字相加, 有的是计算三个数
字相加
重载需要满足的要求：
- 方法名一定要相同
- 参数列表一定要不同(参数的个数不同或参数的类型不同)
- 返回值不做任何要求
另外，重载不是必须要在一个类当中，这一点学到继承时自然会懂
三、方法的递归
一个方法在执行过程中调用自身, 并且有一个趋近于终止的条件就称为 “递归”.
当递归缺乏趋近于终止的条件时
📑代码示例：
public class TestDemo {
public static void fuc() {
fuc();
}
public static void main(String[] args) {
fuc();
}
}
🏸 代码结果：
💬代码解释：
在这里出现了栈溢出异常，因为当 fuc 函数被调用的时候，就会在栈上开辟空间，由于没有趋近于终止的条件，函数将会被一直调用，栈上就会一直开辟空间，导致了栈溢出.
1、递归求 N 的阶乘
📑代码示例：
public class TestDemo {
//阶乘的实现
public static int fac(int n) {
if(n == 1) {
return 1;
}
return n * fac(n - 1);//调用函数自身
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int ret = fac(n);
System.out.println(ret);
}
}
🏸 代码结果：
💬代码解释：
- 关于该函数的实现，我们一般采取横向思考。即想要求出n！，当n = 4时即求4！，就求出4 * 3！，想要求3！，只要求出3 * 2！，以此类推，总结出递归公式 n * fac(n - 1).
- 而实际上，函数真正执行的时候，是纵向执行。
代码执行详细过程：
代码执行简图：
- 另外，从开辟栈帧这一个角度，也可以说明这一个过程
2、按顺序打印一个数字的每一位
📑代码示例：
例如 1234 打印出 1 2 3 4
public class TestDemo {
public static void print(int n) {
if(n > 9) {
print(n / 10);
}
System.out.print(n % 10 + " ");
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt();
print(num);
}
}
🏸 代码结果：
💬代码解释：
3、求组成非负整数的数字之和
📑代码示例：
public class TestDemo {
//方法一
/*public static int funcSum(int n) {
if(n < 10) {
return n % 10;
}
return n % 10 + funcSum(n / 10);
}*/
//方法二
public static int funcSum(int n) {
if(n > 9) {
return n % 10 + funcSum(n / 10);
}
return n % 10;
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt();
System.out.println(funcSum(num));
}
}
🏸 代码结果：
💬代码解释：
4、求斐波那契数列的第N项
📑代码示例：
public class TestDemo {
public static int fib(int n) {
if(n == 1 || n == 2) {
return 1;
}
return fib(n - 1) + fib(n - 2);
}
public static void main(String[] args) {
System.out.println(fib(4));
System.out.println(fib(10));
System.out.println(fib(15));
System.out.println(fib(45));
}
}
🏸 代码结果：
💬代码解释：
由代码结果可见，递归求斐波那契数列的第N项，递归表达式虽然简单，但是效率却很低下。当N越大，就意味着执行纵向展开时，重复计算的量越多
因此，递归求斐波那契数列的第N项并不是一个好方法。
📑代码示例：
public class TestDemo {
public static int fib(int n) {
if(n == 1 || n == 2) {
return 1;
}else {
int n1 = 1;
int n2 = 1;
int n3 = 0;
for (int i = 3; i <= n ; i++) {
n3 = n1 + n2;
n1 = n2;
n2 = n3;
}
return n3;
}
}
public static void main(String[] args) {
System.out.println(fib(4));
System.out.println(fib(10));
System.out.println(fib(15));
System.out.println(fib(45));
}
}
🏸 代码结果：
💬代码解释：
这里用迭代的方法求出斐波那契数列的第N项，该方法和前者相比极大地提高运行效率，强力推荐。
完！