java(04) 方法（概念，重载，递归）

方法

方法重载的规范

具体规范
一.方法名一定要相同。

二.方法的参数表必须不同，包括参数的类型或个数，以此区分不同的方法体。

1.如果参数个数不同，就不管它的参数类型了!

2.如果参数个数相同，那么参数的类型必须不同。

三.方法的返回类型、修饰符可以相同，也可不同。

方法的概念

方法的概念：一段用来完成特定功能的代码片段。

为什么使用方法？
程序中多次用到的功能
为了便于阅读程序
提高程序重用性

方法的格式

格式：
访问修饰符 返回值类型 方法名（参数类型 参数1，参数类型 参数2…）{
方法体;
return 返回值；
}

访问权限修饰符：暂时使用 public static。后面我们在面向对象再详细讲解其他的修饰符。
返回值类型：该方法的返回结果的数据类型，可以是八大基本数据类型和引用类型（类、数组、接口）。
方法名：符合命名规则即可，方便我们的调用。
参数：
实际参数：方法调用时的参数，就是实际参与运算的。
形式参数；方法定义时的参数，用于接收实际参数的。
参数类型：参数的数据类型，可以是八大基本数据类型和引用类型。
参数名：就是变量名

方法体语句：就是完成特定功能的代码。
return：方法执行结束
返回值：功能的结果，通过return返回给调用者，哪里调用的就返回到哪里去。
书写的位置：
首先方法和方法是平级关系，所以方法不能写在main方法里面。
书写的格式：
满足方法定义的格式。

方法定义三要素

返回值类型
结果的数据类型，没有返回值的方法就写成void。
参数列表
你要传递几个参数，以及每个参数的数据类型。
方法名：满足驼峰命名法，见名知意。

例1：键盘录入年份判断是否是闰年

import java.util.Scanner;

public class MethodDemo01 {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		System.out.print("请输入一个年份： ");
		int year = input.nextInt();
		boolean judgeLeapYear = judgeLeapYear(year);
		System.out.println(judgeLeapYear ? (year + "年是闰年") : (year + "年不是闰年"));
	}

	/*
	 * 1.功能：判断是否是闰年； 
	 * 2.返回值类型：boolean; 
	 * 3.参数列表：int year 
	 * 4.方法名：judgeLeapYear
	 */
	public static boolean judgeLeapYear(int year) {
		boolean judgeLeapYear = false;
		return (judgeLeapYear = (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) ? true : false);
	}
}

例2：判断一个数是否是素数

import java.util.Scanner;

public class MethodDemo02 {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		System.out.print("请输入一个数");
		int number = input.nextInt();
		System.out.println(judgePrimeNumber(number) ? number + "是素数" : number + "不是素数");
	}

	/* 1.功能：判断一个数是否是素数
	 * 2.返回值类型：boolean
	 * 3.参数列表：int number
	 * 4.方法：judgePrimeNumber
	 */
	public static boolean judgePrimeNumber(int number) {
		boolean judge = true;
		if (number < 2) {
			judge = false;
		}
		for (int i = 2; i < number; i++) {
			if (number % i == 0) {
				judge = false;
				break;
			}
		}
		return judge;
	}
}

方法的重载

/*
 * 为什么需要学习方法重载? --> 防止多个功能类似但是形参的个数类型顺序不一致导致的重名命名问题
 * 方法重载
 * 	发生在同一个类中,方法名称相同,参数的 个数,顺序,类型不同构成重载
 * 	1.发生在同一个类中
 *  2.方法名称相同
 *  3.参数的 个数,顺序,类型不同构成重载
 *  		1和2 因为个数不同构成重载
 *  		1和3 因为顺序不同构成重载
 *  		3和4 因为类型不同构成重载
 *  4.重载和访问权限修饰符和返回值类型没有任何关系
 *  5.重载虽然代码量会增多,但是对于调用者来说更为方便,会根据不同的参数类型选择不同的方法执行
 *  6.方法重载的精确性原则 [后面讲解 Object 和 String的时候讲解]
 */
public class MethodDemo03 {
	public static void main(String[] args) {
	}

	// 求两个数 int double 的和 
	// 1
	public static double add(int a, double b) {
		return a + b;
	}

	// 2
	public static double add(int a, double b, int c) {
		return a + b + c;
	}

	// 3
	public static double add(double a, int b) {
		return a + b;
	}

	// 4
	public static double add(double a, double b) {
		return a + b;
	}
}

方法递归

递归：方法中调用本方法，自己调用自己
注意:
1、递归一定要有出口，否则很容易出现死递归，走不出来，类似死循环。
2、递归的次数太多很容易出现内存溢出。
3、构造方法不能递归。

面试题: 死递归和死循环的区别？

出现死递归，执行时系统会报错；出现死循环，可以照常运行（Fly Bird游戏利用的就是死循环）

例题：用递归的方法求两个数的最大公约数

public class Recursion {
	public static void main(String[] args) {
		System.out.println(getGCD(36, 14));
	}

	/* 1.功能：求最大公约数
	 * 2.返回值类型：int
	 * 3.参数列表：int a, int b,
	 * 方法： get Greatest common divisor
	 */
	public static int getGCD(int a, int b) {
		/* 1.例(36 14)最大公约数
		 * 36/14=2 ...8
		 * 14/8=1...6
		 * 8/6=1...2
		 * 6/2=3...0
		 * 最大公约数为2
		 * 规律：每次的余数作为被除数
		 * 2.确定出口：余数为0
		 */
		int i;
		if (b == 0) {
			i = a;
		} else {
			i = getGCD(b, a % b);
		}
		return i;
	}
}

import java.util.Scanner;

//求一个数的阶乘 例如: 5! 5*4*3*2*1 0!==1
public class Pratice03 {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		System.out.println("请输入一个正整数：");
		int number = input.nextInt();
		System.out.println(getFactorial(number));
	}

	/* 1.功能：求阶乘
	 * 2.返回值类型：long
	 * 3.参数列表：int number
	 * 4.方法：getFactorial
	 */
	public static long getFactorial(int number) {
		//方法一：for 循环
		/*long result = 1;
		for (int i = 1; i <= number; i++) {
			result *= i;
		}
		return result;*/
		//方法二：递归
		if (number == 1) {
			return 1;
		} else {
			return number * getFactorial(number - 1);
		}
	}
}