Java编程：理解方法、递归与实践应用-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_51462573/article/details/112338197

终于开始学习新的知识了，今天了解到了方法的概念，分享给大家。

方法的概念

多次反复编写明显是不合适的，而结构化编程中的模块化在Java中的体现就是自定义方法。

例如：输出1-100之间所有素数

public class Test1 {
 // 特殊的方法，用于表示程序的执行起始点，也就意味着不能写错
 public static void main(String[] args) {
 for(int i=2;i<101;i++){
 if(abc(i)){  //调用处传入的数据是实参
 System.out.println(i);
 }
 }
 System.out.println(abc(10,0));//语法报错，因为abc方法在定义时，只说明一个
参数，但是调用处是两个参数，不对应。
 }
    //定义方法，命名规则为要求见名知意，一般建议首字母小写，大写字母分词。否则必须添加注
释说明
 //判断kk是否为素数
 //boolean表示这个方法的返回值必须为boolean,也就是只能true/false,其它类型则出错
 //方法名称：标识符的命名规则
 //()中的内容为方法参数，就是调用方法时必须传递的数据
 //int表示传入的参数必须为int类型，否则报错
 //至于参数的名称可以理解为占位符,称之为形参，调用时会被传递的数据所替代
 public static boolean abc(int kk){//自定义方法，用于封装一个具体的处理过程，
当需要使用这个处理过程时只需要通过名称就可以直接调用。实际参数的传递是通过实参和形参一一对
应实现的（位置对应）。
 boolean res=true;
 for(int i=2;i<=kk/2;i++){
 if(kk%i==0){
 res=false;
 break;
 }
 }
 return res;//return表示立即终止当前程序的运行，并返回调用处
 }
}

方法可以理解为一个命名的代码块，通过名称就可以重复使用这段代码，而不需要反复书写，可以达到代码重用的目的

方法可以有参数，也可以没有参数；方法可以有返回值，也可以没有返回值[必须声明返回值为void]

方法定义的具体位置没有关系，可以先写调用【会有报错】，然后定义方法也可以；先写定义后调用也可以。

调用方式常见的有三种

单独调用。这种方式无法使用方法的返回值。格式：方法名称(参数值);
在这里插入图片描述

调用的是show(1，5)，这个show方法没有返回值，所以不能接收返回值，否则语法报错【int k=show(1,5);】；如果有返回值，可以不接受返回值

public static int pp(){...}
int k=pp();  //语法正确
pp();  //语法正确

打印调用。这种方式可以将方法的返回值直接打印。格式：System.out.println(方法名称(参数值)); 注意使用sysout方法调用需要有返回值

赋值调用。这种方式可以将方法的返回值赋值给一个变量，注意变量的数据类型必须和方法的返回值类型对应。格式：数据类型变量名称= 方法名称(参数值)

重名问题

变量的名称是否可以与方法名称重名？可以。``

public class Test03 {
	 public static void main(String[] args) {
	 pp();  //方法名称允许相同
	 pp(11);
	    }
 public static void pp() {
	 System.out.println("void...pp()");
	 }
 public static void pp(int k) { //两个同名的方法参数不同才可以重名定义
	 System.out.println("void...ppp()");
 }
    //方法参数不同有3种情况：类型不同、数量不同、顺序不同[不是方法参数名称]
}

public class Test03 {
	 public static void main(String[] args) {
	      pp();
		  pp(11);
	 }
	 
	 public static void pp() {
		 System.out.println("void...pp()");
	 }
	 
	 public static void pp(int k) {
		 System.out.println("void...pp()");
	 }
	 
	 public static void pp(int k1,String s1) {
		 System.out.println("void...ppp()");
	 }
	 
	 public static void pp(int s1,int k1) {
		 System.out.println("void...ppp0()");
	 }
	 
}

两个不同的方法中，能否各自有一个重名的变量？可以，而且各个方法中的临时变量之间没有任何关系。

main方法中有2个临时变量begin和end，add方法中也有两个临时变量begin和end，这个方法中的临时变量没有任何关系，各自生存在不同的方法中

参数传递

形式参数：在定义方法的时候，写在小括号之内的变量，就叫形式参数。实际上在方法定义中起到
占位符的作用，会在方法调用时被传递过来的实际值所替代实际参数：在调用方法的时候，真正传入方法里的数据，叫做实际参数。

圆括号中的实参列表为调用方法时实际传入的实际参数，称为实参列表。声明方法时圆括号中的参数称为形式参数，形式参数和实际参数在数据类型和个数上一定要匹配

注意：调用方法时形式参数和实际参数的个数和顺序必须一致，数据类型也必须相同。

两条规则

对于基本类型来说，形式参数的操作【不会】影响实际参数。值是单向传递

对于引用类型来说，形式参数的操作【会】影响实际参数。???

对任何语言来说，方法或者函数解决了需要重复使用的代码的次数

递归调用

递归调用指在方法执行过程中允许出现直接或者间接的该方法本身的调用

列如 : 计算阶乘5!

public class Test04 {
	 public static void main(String[] args) {
	   int res=jie(5);
	   System.out.println("5!="+res);
 }
 
 public static int jie(int k) {  //自己直接调用自己---递归调用
	   if(k==0)
	        return 1;
	   return k*jie(k-1);
 } 
}

int res=1;
for(int i=1;i<=n;i++) res*=i;

斐波那契数列

Fibonacci sequence，又称黄金分割数列，以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：1、1、2、3、5、8、13、21、34…

以递推的方法定义：F(1)=1，F(2)=1, F(n)=F(n-1)+F(n-2)（n>=3，n∈N*）

斐波那契在《算盘书》中提出了一个有趣的兔子问题：一般而言，兔子在出生两个月后，就有繁殖能力，一对兔子每个月能生出一对小兔子来。如果所有兔都不死，那么一年以后可以繁殖多少对兔
子？

import java.util.Scanner;

public class Demo10 {
	public static void main(String[] args) {
		int months = 0;
		Scanner sc = new Scanner(System.in);
		while (true) {
			System.out.println("月份：");
			String ss = sc.nextLine();
			try {
				months = Integer.parseInt(ss);
				if (months > 0)
					break;
				System.out.println("请重新输入月份数!");
			} catch (Exception e) {
				System.out.println("请输入合法的月份数！");
			}
		}
		int num = tongji(months);
		System.out.println(months + "月后的兔子数为：" + num);
	}

	public static int tongji(int months) {
		if (months > 0) {
			if (months == 1 || months == 2)
				return 1;
			return tongji(months - 1) + tongji(months - 2);
		}
		return 0;
	}
}

递归调用比较符合正常人的思维方式，但是相当的浪费内存，所以如果能使用其他方式解决就不要使用递归。

循环和递归对比：
递归：易于理解、速度慢、存储空间大
循环：不易于理解、速度快、存储空间小

例如：有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13… 求出这个数列的前20项之和

public class Demo {
	public static void main(String[] args) {
		double res = 0;
		for (int i = 1; i <= 20; i++) {
			res += 1. * diguiFenzi(i) / diguiFenmu(i);
		}
		System.out.println(res);
	}

	public static int diguiFenzi(int n) {
		// 如果使用递归调用必须保证有退出递归的点，必须保证不断逼近退出的点
		if (n == 1)
			return 2;
		else if (n == 2)
			return 3;
		else
			return diguiFenzi(n - 1) + diguiFenzi(n - 2);
	}

	public static int diguiFenmu(int n) {
		if (n == 1 || n == 2)
			return n;
		else
			return diguiFenmu(n - 1) + diguiFenmu(n - 2);
	}
}

汉诺塔问题：

梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘

移动次数是f(n).显然f(1)=1,f(2)=3,f(3)=7，且f(k+1)=2*f(k)+1

猴子吃桃问题（等同汉诺塔问题）：

public class 汉诺塔问题 {
	public static void main(String[] args) {
		System.out.println(move(3));
	}

	public static long move(int n) {
		if (n == 1)
			return 1;
		return 2 * move(n - 1) + 1;
	}
}