方法的使用
回顾复习
向阳生长！
三种逻辑结构：顺序、选择、循环结构。
尽己所能
一、方法的提出
- 编程时，某段功能的代码可能频繁使用到，则会出现以下不便：
1）使程序变得繁琐
2） 开发效率低下，做了大量重复性的工作
3） 不利于维护，需要改动时，所有用到该段代码的位置都需要修改
4）不利于复用
所以：将频繁使用的代码封装成"帖子"(方法)，需要时直接拿来链接(即方法名–方法的入口地址)使用即可
二、方法的概念以及应用
1. 什么是方法
- 方法就类似于c语言的函数，封装了某一特定功能。
- 方法的意义：
1） 是能够模块化的组织代码(当代码规模比较复杂的时候).
2） 做到代码被重复使用, 一份代码可以在多个位置使用.
3） 让代码更好理解更简单.
4） 直接调用现有方法开发, 不必重复造轮子.
2.方法定义
- 语法格式：
// 方法定义
修饰符 返回值类型 方法名称([参数类型 形参 ...]){
方法体代码;
[return 返回值];
}
- 注意事项
1） 修饰符：现阶段直接使用public static 固定搭配（但是注意这并不是方法的固定修饰符）
2） 返回值类型：如果方法有返回值，返回值类型必须要与返回的实体类型一致，如果没有返回值，必须写成void
3） 方法名字：采用小驼峰命名
4） 参数列表：如果方法没有参数，()中什么都不写，如果有参数，需 指定参数类型，多个参数之间使用逗号隔开
5） 方法体：方法内部要执行的语句
6） 在java当中，方法必须写在类当中
7） 在java当中，方法不能嵌套定义
8） 在java当中，没有方法声明一说
（类中有方法，方法中定义变量）
- 补充：
方法调用-函数传参时注意点：
1.参数个数匹配
2.参数类型
3.参数顺序
3. 方法调用的执行过程
- 方法调用过程：
调用方法—>传递参数—>找到方法地址—>执行被调方法的方法体—>被调方法结束返回—>回到主调方法继续往下执行 - 注意事项
【注意事项】
- 定义方法的时候, 不会执行方法的代码；只有调用的时候才会执行。
- 一个方法可以被多次调用。
-
补充：
1）任何方法的调用都是在栈上开辟内存的
2）方法使用完后栈帧内存释放
3）方法都可以递归 -
实例-求阶乘fac + 求和sum
如：1！+2！+…+k!
- 代码：
import java.util.Scanner;
/**
* 求阶乘fac + 求和sum
* 如：1！+2！+…+k!
*/
public class FacSum {
//阶乘
public static int fac(int n) {
int fac =1;
if(n > 0) {
for (int i = 1; i <= n ; i++) {
fac *= i;
}
}
return fac;
}
//和
public static int sum(int n) {
int sum =0;
for (int i = 1; i <= n ; i++) {
sum += fac(i);
}
return sum;
}
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
System.out.print("请输入任意整数：");
int n = reader.nextInt();
if(n >= 0) {
System.out.print(n+"阶乘和：");
System.out.println(sum(n));
} else {
System.out.println("输入错误！");
}
}
}
- 结果：
4.形参和实参的关系（重要）
- 形参的名字可以随意取，对方法都没有任何影响，形参只是方法在定义时需要借助的一个变量，用来保存方法在调用时传递过来的值。
- 在java中，数据在栈上的 地址是拿不到 的–没有所谓的获取局部变量的地址
- 形参是实参的临时拷贝（相当于传值调用），是两个不同的实体
- 实例：交换两个整型变量
（需要传入数组进行实现）–此时先了解一下即可
- 代码：
/**
* 交换两个数
*/
public class Swap {
public static void main(String[] args) {
int[] arr = {10, 20};
System.out.println("交换前："+"arr[0] = " + arr[0] + " arr[1] = " + arr[1]);
swap(arr);
System.out.println("交换后："+"arr[0] = " + arr[0] + " arr[1] = " + arr[1]);
}
public static void swap(int[] arr) {
int tmp = arr[0];
arr[0] = arr[1];
arr[1] = tmp;
}
}
- 结果：
5. 没有返回值的方法
- 方法的返回值是可选的， 有些时候可以没有，没有时返回值类型必须写成void
- 如：判断素数的方法用boolean类型返回–true or false
三、 方法重载
1. 为什么需要方法重载
- 方法同名不同参
- 编译器记住一个方法名就好
2. 方法重载概念
- 概念：在Java中，如果多个方法的名字相同，参数列表不同，则称该方法被重载了
- 注意：
- 方法重载：
1.方法名相同
2.形参列表不同
3.返回值不做要求，可以一样也可以不一样（即：与返回值类型无关）
- 形参不同–类型、个数、顺序
试一下：两个形参字母不同、顺序不同
- 结果：若形参的类型相同，则修改字母以及顺序不构成方法重载
- 面试题：重载和重写的区别？
重载：overload，同名不同参，与返回值类型无关。
重写：override–继承讲到
3. 方法签名
- 概念：经过编译器编译修改过之后方法最终的名字。
具体方式：方法全路径名+参数列表+返回值类型，构成方法完整的名字。 - 代码经过编译之后，然后使用JDK自带的javap反汇编工具查看，具体操作：
1） 先对工程进行编译生成.class字节码文件
2） 在控制台中进入到要查看的 .class所在的目录
3）按住shift打开PowerShell窗口输入
4） 输入：javap -v 字节码文件名字即可 - 如：add:(II)I （前面有路径名）
方法名（形参列表：形参类型及个数）返回值类型 - 方法签名中的一些特殊符号说明：
四、递归
1. 递归的概念
- 概念：一个方法在执行过程中调用自身, 就称为 “递归”.
- 递归相当于数学上的 “数学归纳法”, 有一个起始条件, 然后有一个递推公式.
- 递归条件：
1） 一定要有一个趋近于终止的条件
在方法内部，自己调用自己–可能会存在栈溢出-方法在栈上开辟内存
（so：递归要能够结束，有结束条件–return or sout）
2）将原问题划分成其子问题，注意：子问题必须要与原问题的解法相同 - 递归求n的阶乘
递推公式：fac(n）= n * fac(n-1);
-代码：
import java.util.Scanner;
/**
* 如：求阶乘 n!=n*(n-1)!
*/
public class Fac {
public static int fac(int n) {
if(n > 0) {
if(n == 1) {
return 1;
}
return n*fac(n-1);
} else if(0 == n) {
return 1;
} else {
return -1;
}
}
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
System.out.print("请输入任意整数n：");
int n = reader.nextInt();
int ret = fac(n);
if(ret > 0) {
System.out.println(n+"的阶乘："+ret);
} else {
System.out.println("输入错误！");
}
}
}
-结果：
2. 递归执行过程分析
- 过程分析：
递归–
传递：从前往后
归来：从后往前 - 以上述求n的阶乘为例：
- 关于 “调用栈”
- 方法调用的时候, 会有一个 “栈” 这样的内存空间描述当前的调用关系. 称为调用栈.
- 每一次的方法调用就称为一个 “栈帧”, 每个栈帧中包含了这次调用的参数是哪些, 返回到哪里继续执行等信息.
后面我们借助 IDEA 很容易看到调用栈的内容.
3. 递归练习
- 按顺序打印一个数字的每一位(例如 1234 打印出 1 2 3 4)
- （注意：书写顺序会影响打印顺序）
- 代码：
import java.util.Scanner;
/**
* 按顺序打印一个数字的每一位(例如 1234 打印出 1 2 3 4)
* 模10 除10
* 小于10就打印
*/
public class PPrint {
public static void print1(int n) {
//注意顺序！！ 打印在后面才行！！！
//先print（n/10）--报错
if(n > 10) {
print1(n/10);
}
System.out.print(n%10+" ");
}
public static void print2(int n) {
if(n > 0) {
System.out.print(n%10+" ");
print2(n/10);
}
}
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
System.out.print("请输入任意整数n：");
int n = reader.nextInt();
System.out.println("每一位如下打印（正向）");
print1(n);
System.out.println();
System.out.println("每一位如下打印（反向）");
print2(n);
}
}
- 结果：
- 递归求 1 + 2 + 3 + … + n
- 要求1~n的和相当于求：n+sum（n-1)
-代码：
import java.util.Scanner;
/**
* 递归求 1 + 2 + 3 + ... + n
* n+sum(n-1)
*/
public class Sum {
public static int sum(int n) {
if(n == 1) {
return 1;
}
return (n + sum(n-1));
}
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
System.out.print("请输入任意整数n：");
int n = reader.nextInt();
int sum = sum(n);
System.out.print("1~"+n+"的和："+sum);
}
}
-结果：
3. 写一个递归方法，输入一个非负整数，返回组成它的数字之和.
例如，输入 1729, 则应该返回1+7+2+9，它的和是19
- key: 确定每一位数字 (模10 除10)
只有一位数字时结束 - 求和：n%10 + fun(n/10);
- 代码：
import java.util.Scanner;
/**
* 写一个递归方法，输入一个非负整数，返回组成它的数字之和.
* 例如，输入 1729, 则应该返回1+7+2+9，它的和是19
*/
public class NoSum {
public static int sum(int n) {
if(n >= 0) {
if(n < 10) {
return (n%10);
}
return ((n%10) + sum(n/10));
} else {
return -1;
}
}
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
System.out.print("请输入任意整数n：");
int n = reader.nextInt();
int sum = sum(n);
if(sum >= 0) {
System.out.print("1~"+n+"的和："+sum);
} else {
System.out.println("输入非法！");
}
}
}
- 结果：
- 求斐波那契数列的第 n 项
- 除第一二个数字外：fib(n) = fib(n-1) + fib(n-2)
- 递归方法
-代码：
import java.util.Scanner;
/**
* 求斐波那契数列的第 n 项
* 递归： 1 1 fib(n) = fib(n-1)+fib(n-2);
*/
public class DFib {
public static int count =0; //静态成员变量
public static int dFib(int n) {
if(n > 0 ) {
if((1 == n) || (2 == n)) {
return 1;
}
if(n == 3) { //fib(3)运算次数
count ++;
}
return (dFib(n-1) + dFib(n-2));
} else {
return -1;
}
}
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
System.out.print("请输入任意整数n：");
int n = reader.nextInt();
int dFib = dFib(n);
if(dFib >= 0) {
System.out.printf("fib(%d) = %d\n",n,dFib);
//静态成员变量调用--类名.静态成员变量
System.out.println("fib(3)运算次数："+DFib.count);
} else {
System.out.println("输入非法！");
}
}
}
-结果：
BUT：斐波那契数列不适合用递归–重复计算次数过多，运算效率太低
（类似二叉树的递归方式 先左边计算完成再计算右边）
- 循环完成（迭代）
-代码：
import java.util.Scanner;
/**
* 迭代求斐波那契数列--循环
*/
public class Fib {
public static int fib(int n) {
if(n > 0) {
if((1==n)||(2==n)) {
return 1;
}
int fib1 = 1;
int fib2 = 1;
int fib3 = 0;
for (int i = 3; i <= n; i++) {
fib3 = fib1 + fib2;
fib1 = fib2;
fib2 = fib3;
}
return fib3;
} else {
return -1;
}
}
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
System.out.print("请输入任意整数n：");
int n = reader.nextInt();
int fib = fib(n);
if(fib >= 0) {
System.out.printf("fib(%d) = %d\n",n,fib);
} else {
System.out.println("输入非法！");
}
}
}
-结果：
补充：经典汉诺塔问题
（Java可参考【汉诺塔】）
THINK
回顾复习：
1.方法由几部分组成:
public static（修饰符）返回值方法名（参数列表-形参）{
方法体； //对某个功能的抽象
}
2.方法的调用–参数匹配：类型、个数、顺序
3.所有的方法调用是在栈上开辟内存–先为main方法开辟内存，然后再依次为出现的方法开辟内存，方法调用结束后该内存被回收销毁
4.局部变量在方法内部，作用域只在当前方法里面{}；生命周期：方法调用开始创建到调用结束销毁
114
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
