-
方法与递归（JAVA基础一）
一、方法的概念
**概念：**实现特定功能的一段代码，可反复使用。
二、方法的定义【重点】
2.1 方法的定义
定义语法：
经验：将需要在多个位置重复使用的一组代码，定义在方法内部。2.2 定义的位置
方法定义在类的内部，与main方法并列。
正确位置：位置2、位置4
-
类的内部
-
方法和方法之间是平级关系 比如： printStr 和main
三、方法的调用
3.1 方法的调用
注意：调用方法时，会优先执行方法内部代码，结束后，返回到方法调用处，继续向下执行。
package com.qfedu.methoda; public class Test02Method { // main方法： 程序 的入口 // 修饰符 返回值 方法名(参数列表){ // 方法体 // } //1 定义一个方法， 计算两个整数的和 //2. 这两个数，在 main中，控制台输入 //3. main方法中调用 计算两份个数的和的方法 public static void main(String[] args) { add(2,2); } // 方法名(参数列表) public static void add(int a,int b) { System.out.println("a="+a); System.out.println("b="+b); int sum = a+b; System.out.println("这两个数的和是："+sum ); } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
四、方法的参数【重点】
4.1 方法的参数
多数情况下，方法与调用者之间需要数据的交互；调用者必须提供必要的数据，才能使方法完成相应的功能。
调用方法时，所传入的数据被称为 “参数” 。4.2 形参与实参
方法名称和形参名要符名 标识符的定义
定义语法：
public static void 方法名称( 形式参数 ){ //方法主体 }- 1
- 2
- 3
经验： “形参”等价于“局部变量的声明”。
调用语法：
方法名称( 实际参数 );- 1
经验：“实参”等价于“局部变量的赋值”。
作用：
方法的参数可以让代码功能更灵活、普适性更高，易于修改及维护。- 1
4.2.1 单个参数
public static void 方法名(参数的类型 参数名) { 方法体; } 参数名: 形参- 1
- 2
- 3
- 4
4.2.2 多个参数
public static void 方法名(参数的类型 参数名, 参数的类型 参数名,参数的类型 参数名,参数的类型 参数名,参数的类型 参数名.....) { 方法体; }- 1
- 2
- 3
练习1：调用方法输出字符串
package com.qfedu.methoda; public class Test03 { //1 定义一个方法， 计算两个整数的和 //2. 这两个数，在 main中，控制台输入 //3. main方法中调用 计算两份个数的和的方法 public static void main(String[] args) { //say("我胡汉三又回来了，你们走着瞧"); String aa ="I love you "; say(aa); String bb = "I love myself"; say(bb); } // 我说一句话， 这个方法的功能是 打印10 次这句话 // say(参数的类型 参数的名称,类型 名称，类型 名称.......) // say(形参) public static void say(String str) { for(int i=0; i<10; i++) { System.out.println(str); } } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
练习2：计算两个数的 + - * / %
package com.qfedu.methoda; import java.util.Scanner; public class Test04Method { // 写 以下方法 // 计算两个数的 + - * / % //注意： 参数类型必须匹配; 参数个数必须匹配 public static void main(String[] args) { //1 .定义扫描器 Scanner sc = new Scanner(System.in); // 2. 输入两个int 类型的值 a ,b System.out.println("请输入两个数："); int a = sc.nextInt(); int b = sc.nextInt(); // 3. 输入你要做的计算符号 + - * / % System.out.println("请输入计算符号："); String type = sc.next(); // 4. 判断 计算符号， 依据计算符号选择 调用的方法 if(type.equals("+")) { add(a,b); }else if(type.equals("-")) { sub(a,b); }else if(type.equals("*")) { multi(a,b); }else if(type.equals("/")) { chu(a,b); }else if(type.equals("%")) { mod(a,b); }else { System.out.println("计算符号不合法....."); } } // + public static void add(int a,int b) { int sum = a+b; System.out.println("a+b="+ sum ); } // - public static void sub(int a,int b) { int sum = a-b; System.out.println("a-b="+sum); } // / public static void chu(int a,int b) { int sum = a/b; System.out.println("a/b="+sum); } // * public static void multi(int a,int b) { int sum = a*b; System.out.println("a*b="+sum); } // % public static void mod(int a,int b) { int sum = a%b; System.out.println("a%b="+sum ); } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
练习3：优化练习2
package com.qfedu.methoda; public class Test03Method { // 写 以下方法 // 计算两个数的 + - * / % //注意： 参数类型必须匹配; 参数个数必须匹配 public static void main(String[] args) { int a = 101; int b = 345; // + add(a,b); // - sub(a,b); multi(a,b); chu(a,b); mod(a,b); } // + public static void add(int a,int b) { int sum = a+b; System.out.println("a+b="+ sum ); } // - public static void sub(int a,int b) { int sum = a-b; System.out.println("a-b="+sum); } // / public static void chu(int a,int b) { int sum = a/b; System.out.println("a/b="+sum); } // * public static void multi(int a,int b) { int sum = a*b; System.out.println("a*b="+sum); } // % public static void mod(int a,int b) { int sum = a%b; System.out.println("a%b="+sum ); } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
4.3 如何定义参数
经验：根据具体的业务需求，来定义方法的参数。
案例： 用户登录
public class TestUser { public static void main(String[] args) { //1.从前端获取的username password String userName ="zs"; String passWord = "123"; //2. 登录 login(userName,passWord); //调用修改密码操作 changePass("123","123","456","456"); } //用户登录的方法 //输入用户名和密码 public static void login(String userName, String passWord) { // zs 123 if(userName.equals("zs") && passWord.equals("123")) { System.out.println("登录成功！"); }else { System.out.println("登录失败"); } } //手机号和验证码 public static void login1(String phone,int code) { if(phone.equals("123") && code==123) { System.out.println("登录成功"); }else { System.out.println("登录失败"); } } //用户修改密码的方法 //需求： 输入手机号 验证码 新密码 再次新密码 /** * * @param phone 手机号 * @param code 验证码 * @param newPass1 新密码 * @param newPass2 再次新密码 */ public static void changePass(String phone,String code,String newPass1,String newPass2) { //1.手机号和验证码通过，则继续 if(phone.equals("123456") && code.equals("123")) { //2. 判断两次新密码 if(newPass1.equals(newPass2)) { System.out.println("操作数据库，更新成功"); }else { System.out.println("两次密码不一致，请重新输入"); } }else { System.out.println("手机号和验证码不一致"); } } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
五、返回值与返回值类型
5.1 返回值
概念： 方法执行后的返回结果。
方法执行后，一些情况下无需返回结果；另一些情况下则必须返回结果。
例如：
存款操作无需返回结果。 取款操作必须返回结果。- 1
- 2
5.2 定义语法
public static 返回值类型 方法名称( 形式参数列表 ){ //方法主体 return value; //返回值 }- 1
- 2
- 3
- 4
规定返回值的具体类型（基本、引用、void）。
根据需求返回一个结果（值）。
5.3 调用语法
变量 = 方法名称( );- 1
变量类型与返回值类型一致。
5.4 需求
需求：定义方法，计算两个整数的和，并返回结果，在main中打印。
public class TestSum { //计算任意两个数的和,要求键盘输入 用方法来写逻辑代码 ， 并且 在main方法中调用，把结果打印在main方法中 public static void main(String[] args) { Scanner sc = new Scanner(System.in); int a = sc.nextInt(); int b = sc.nextInt(); int sum = sum(a,b); System.out.println("a+b="+sum); } //void 表示没有返回结果： null // 1. void --> int //2. 在方法的代码当中，要有对应类型就量的返回 public static int sum(int a ,int b ) { int sum = a+b; System.out.println(sum); //返回结果：要求类型与 方法定义的类型相同,return 返回结果，表示方法结束 return sum ; } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
5.5 return关键字
return的两种用法：
应用在具有返回值类型的方法中： return value; 表示结束当前方法，并伴有返回值，返回到方法调用处。 应用在没有返回值类型（void）的方法中： return; 表示结束当前方法，直接返回到方法调用处。- 1
- 2
- 3
- 4
- 5
注意：一个类中可以定义多个方法，方法之间属于并列关系，不可嵌套。
经验：一个方法只做一件事。
案例 ：计算1-10的和
package com.qfedu; public class Test01 { // 1. 写一个方法， 计算 1-10 的和 // 2. 在main中调用 // 3. 在main 方法中，计算 平均数 public static void main(String[] args) { // 方法的返回值 // void 表示本方法，没有返回值 // 如果有返回值，把void 换成 对应的返回类型 // 如果有返回值 在方法中要添加 return 返回值 // 如果有返回值 ， 返回值的类型必须和 return 后边值的类型一致 // 如果有返回值，调用方法的结果，要用对应的类型去接 // 调用 int a = sum(); System.out.println("平均数="+(a/10)); String str = say(); System.out.println("我想说的一句话是："+str); } /** * 计算1-10 的和 */ public static int sum() { int sum = 0; for(int i=0; i<=10; i++) { sum += i; } return sum ; } public static String say() { String str = "昨晚没有睡好，你猜为什么？"; return str; } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
案例 ：+ - * / % 计算
package com.qfedu; import java.util.Scanner; /** * @Author lcw * @Description * @Date 2021/11/5 */ public class Test02 { // 1. 写一个方法， 计算 1-10 的和 // 2. 在main中调用 // 3. 在main 方法中，计算 平均数 public static void main(String[] args) { // 方法的返回值 // void 表示本方法，没有返回值 // 如果有返回值，把void 换成 对应的返回类型 // 如果有返回值 在方法中要添加 return 返回值 // 如果有返回值 ， 返回值的类型必须和 return 后边值的类型一致 // 如果有返回值，调用方法的结果，要用对应的类型去接 //1.定义扫描器 Scanner sc = new Scanner(System.in); while (true) { System.out.println("--------------------开始计算--------------------"); System.out.print("请输入第一个数："); int num1 = sc.nextInt(); System.out.print("请输入第二个数："); int num2 = sc.nextInt(); System.out.print("请输入计算符号:"); String flag = sc.next(); //2.调用方法 int result = count(num1,num2,flag); System.out.println("计算结果:"+num1+flag+num2+"="+ result); } } //1. 写一个计算器，参数是 数字a ,b 计算符号 // 2. 返回结果是一个int public static int count(int a,int b,String fh) { // result 这个单词是结果的意思 int result =0; // fh + - * / % if(fh.equals("+")) { result = a+b; }else if(fh.equals("-")) { result = a-b; }else if(fh.equals("*")) { result = a*b; }else if(fh.equals("/")) { result = a/b; }else if(fh.equals("%")) { result = a%b; }else { result = -1; } return result; } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
六、方法的好处
好处：
减少代码冗余。 提高复用性。 提高可读性。 提高可维护性。 方便分工合作。- 1
- 2
- 3
- 4
- 5
七、递归
注意事项
1.递归的使用注意事项，并举例应用场景方法不停地进栈而不出栈，导致栈内存不足
2.如果使用循环可以解决，则优先使用循环
3.一定要有结束条件
场景： 可以用来操作文件目录：比如文件统计总大小，删除目录及基目录下的所有文件
生活举例：
简单的从字面意思来，就是既有传递又有回归的算法，就叫做递归。比如：你在电影院看电影，凑巧的是你来迟了，一懵，发现自己的座位号找不到，你就开始问旁边的人，你是第几号，然后旁边的人又不知道，又问旁边的人，那个人又不知道，之后他又问旁边的人，依次类推，等到你问到最前面的时候，那个人知道自己的座位号，就告诉他旁边的人，然后他们一个又一个的把消息传递回来，直到你知道自己的作为在哪里。这就是所谓的递归；
7.1 多级调用
运行结果：
m1() - start m2() - start m2() - end m1() - end- 1
- 2
- 3
- 4
优先执行方法内部代码，结束后，返回到调用处，继续向下执行。
7.2 无穷递归
运行结果：m1() - start m1() - start m1() - start m1() - start m1() - start m1() - start m1() - start m1() - start m1() - start m1() - start- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
7.3 递归
什么是递归？
解决具有既定规律的问题时，在方法内部再次调用自身方法的一种编程方式。
何时使用递归？
当需要解决的问题可以拆分成若干个小问题，大小问题的解决方式相同，方法中自己调用自己。
使用循环解决的常规问题，都可以替换为递归解决。如何正确使用递归？
设置有效的出口条件，可以让调用链上的每个方法都可以正确返回，避免无穷递归。
7.4 循环阶乘
计算5的阶乘：5！= 5 * 4 * 3 * 2 * 1;
循环计算阶乘较为简单，依次与每个值相乘即可。
7.5 递归阶乘
阶乘的定义：n ! = n * (n-1) * (n-2) * (n-3) . . . .
多个方法解决问题的思路相同，同时遵循着相同的规律。
注意：所有能以递归解决的问题，循环都可以解决。当解决复杂问题时，递归的实现方式更为简单。
public class Test7factorial { // 5! = 5* 4 *3 * 2*1 //5! = 5* 4! // 4!= 4*3! // 3! = 3*2! // 2! = 2*1! // 1* =1*1; public static void main(String[] args) { int factorial = factorial(5); System.out.println(factorial); } //求阶乘的方法 public static int factorial(int n) { if(n==1) { return 1; } return n*factorial(n-1); // 5 * (factorial(4)) // 5* 4* factorial(3) // 5* 4* 3* factorial(2) // 5* 4* 3* 2* factorial(1) // 5* 4* 3* 2* 1 } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
案例: 1-100的和
package com.qfedu; public class Test08 { //1-100的和 public static void main(String[] args) { int add = add(100); System.out.println(add); } // 100+(1-99) // 100 + 99 + (1-98) // 100 + 99 + 98 + (1-97) public static int add(int n ) { if(n==1) { return 1; } return n+ add(n-1); } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
-
-
相关阅读:
代理IP与Socks5代理：跨界电商智能爬虫的引擎与安全壁垒
小解C语言文件编译过程【linux】
【python编程从入门到实践】P1 搭建python编程环境
金仓数据库 KingbaseGIS 使用手册（6.2. 管理函数）
Java 同步锁ReentrantLock与抽象同步队列AQS
不要再说你不会了——网络性能问题排查思路
mac安装nvm
RuoYi-Vue-Plus 高端进阶 源码分析 系列教程
卷积神经网络（CNN）
牛客网-JS篇-在线编程---前端面试手撕题
- 原文地址：https://blog.csdn.net/LCHONSEONE/article/details/127583469
