Java 方法

方法

方法
	含义:
		在程序中执行特殊功能的代码块
	好处:
		1.提高程序的复用性,从而提高开发效率
		2.降低代码的耦合性
			耦合性:程序中内容与内容间的联系密度

	public static void main (String[] args) {
		method(5);
		System.out.println("百钱买百鸡");
		method(13);
		System.out.println("水仙花数");
		method(11);
		System.out.println("趣味折纸");
		method(7);
	}
	public static void method (int num) {
		for (int i = 1 ; i <= num ; i++) {
			System.out.println("HelloWorld");
		}
	}

方法的声明

	位置:
		类中方法外
	格式:
		修饰符 返回类型 方法名 (形参类型1 形参名1,形参类型2 形参名2,......,形参类型n 形参名n) {
			方法体语句
			return 返回值;
		}
	特点:
		1.不调用,不执行
		2.调用:执行指定方法
		3.传参:声明方法无法直接使用调用者方法中数据,需要通过参数传递的方式进行使用
			形参:形式参数,声明方法时()中的参数
			实参:实际参数,调用方法时()中的参数
		4.返回:调用者方法无法直接声明方法的结果数据,需要通过返回的方式进行使用;
	解释:
		修饰符:用于修饰内容关键字(暂不涉及),使用public static替换
		返回类型:声明方法需要返回结果数据的类型
			返回类型可以是:
				无返回类型
				基本类型
				引用类型
		方法名:方法的名字,做到"见名知意"
		()中的内容:形参列表,声明方法所需的变量的数据类型和变量名
			形参列表中的数据类型可以是:
				什么都没有
				基本类型
				引用类型
		方法体语句:封装特殊功能的代码片段
		return:(1)控制语句,结束方法(2)如果return后面存在返回值,在结束方法的同时返回给调用者
		返回值:方法的结果数据

方法声明前的两个明确:
返回类型: 明确声明方法的结果数据具体是什么数据类型
形参列表: 明确声明方法需要使用调用者方法中几个数据,且每个数据是什么类型

需求:通过方法完成获取两个整数的累加和
	public static void main (String[] args) {
		int num =  getSum(3,4);
	}
	/*
		两个明确:
			返回类型:int
			形参列表:int a , int b
	*/
	public static int getSum (int a , int b) {
		int sum = a + b;
		return sum;
	}

方法的调用

	含义:
		执行指定的方法
	格式:
		1.如果方法归属对象,通过对象名进行调用(暂不涉及)
		2.如果方法归属类,通过类名进行调用(暂不涉及)
		3.特殊的方法调用,调用同一个类中的方法
			(1)单独调用(直接调用)
				方法名(实参);
			(2)输出调用(打印调用)
				System.out.println(方法名(实参));
			(3)赋值调用(变量调用)
	注意:
		方法调用的实参必须是所调用方法的形参列表一一对应,否则编译报错

	public static void main (String[] args) {
		//单独调用(直接调用)
		getSum(3,4);
		//输出调用(打印调用)
		System.out.println(getSum(3,4));
		//赋值调用(变量调用)
		int sum = getSum(3,4);
		System.out.println("sum = " + sum);
	}
	/*
		两个明确:
			返回类型:int
			形参列表:int a , int b
	*/
	public static int getSum (int a , int b) {
		int sum = a + b;
		return sum;
	}

通过方法判断两个整数是否相等

	public static void main (String[] args) {
		boolean result = compare(4,4);
		System.out.println("result = " + result);
	}
	/*
		两个明确:
			返回类型:boolean
			形参列表:int a , int b
	*/
	public static boolean compare (int a , int b) {
		//1
		if (a == b) {
			return true;
		} else {
			return false;
		}
		//2
		return a == b ? true : false;
		//3
		return a == b;
	}

通过方法获取1到100的累加和

	public static void main (String[] args) {
		int sum = getSum();
		System.out.println("sum = " + sum);

		System.out.println("======================");

		int value = getValue(1,100);
		System.out.println("value = " + value);
	}
	/*
		两个明确:
			返回类型:int
			形参列表:int start , int end
	*/
	public static int getValue (int start , int end) {
		//声明并初始化求和变量
		int sum = 0;

		for (int i = start; i <= end; i++) {
			sum += i;
		}
		return sum;
	}
	/*
		两个明确:
			返回类型:int
			形参列表:什么都不写
	*/
	public static int getSum () {
		//声明求和变量
		int sum = 0;

		for (int i = 1; i <= 100 ; i++ ) {
			sum += i;
		}
		return sum;
	}

方法的注意事项:
当方法没有返回值时,声明方法时,返回类型的位置也不能空着,需要使用void关键字进行占位

	/*
		两个明确:
			返回类型:无返回类型
			形参列表:int count
	*/
	public static void print (int count) {
		for (int i = 1; i <= count ; i++ ) {
			System.out.println("HelloWorld");
		}
		return;
	}

void关键字
	含义:方法没有返回值
	注意:
		当方法的返回类型是void时,方法的调用方式只能是直接调用(单独调用)
		当方法的返回类型是void时,return关键字可以省略不写

	public static void main (String[] args) {
		print(10);
	}
	/*
		两个明确:
			返回类型:无返回类型
			形参列表:int count
	*/
	public static void print (int count) {
		for (int i = 1; i <= count ; i++ ) {
			System.out.println("HelloWorld");
		}
		//return;
	}

方法的小结

	1.方法的声明位置在类中方法外
	2.方法中可以含有多个return语句,但是最终执行的只有唯一的一个
	3.当方法没有返回值时,声明方法时返回类型的位置也不能空着,需要使用void关键字进行占位
	4.当方法的返回类型是void时,return语句可以省略不写
	5.当方法的返回类型是void时,方法的调用方式只能使用单独调用
	6.当方法的返回类型不是void时,方法的调用方式推荐使用赋值调用
	7.不调用,不执行

方法的重载

在同一个类中(或者子父类继承关系中)出现了方法名相同,形参列表不同的现象

	public static void getSum (int a ,int b) {}

	public static void getSum (int a ,int b ,int c) {}

	public static void getSum (double a ,double b) {}

方法重载的前提条件:
	1.必须在同一个类中(或者子父类继承关系中)
	2.方法名必须相同
	3.形参列表必须不同(至少满足以下一点)
		(1)形参的个数不同
		(2)形参的数据类型不同
		(3)形参的数据类型顺序不同

	public static void getSum (int a ,double b) {}

	public static void getSum (double a ,int b) {}

	public static void getSum (int a ,int b) {}

	public static void getSum (double a ,double b) {}

	public static void getSum (int a ,int b ,int c) {}

方法重载的注意事项:
重载的方法具体执行哪个,取决于调用方法时的实参数据类型

方法的递归

	含义:
		在程序中方法通过自身直接或间接的方式调用自身的一种现象
	分类:
		直接递归
			在方法A中调用方法A
		间接递归
			在方法A中调用方法B,在方法B中调用方法C,在方法C中调用方法A
	好处:
		方法递归和循环有些类似,递归的出现可以解决一些使用for和while无法解决的问题
			举例:
				遍历多级文件夹
	注意:
		1.使用方法递归时,需要给递归添加结束条件,否则会发生栈内存溢出
		2.使用方法递归时,即使添加了结束条件,也不能让递归的层数过多,否则也会发生栈内存溢出 

	static int num = 1;

	public static void main (String[] args) {
		method();
	}

	public static void method () {
		System.out.println(num++);
		if (num == 10000) {
			return;
		}
		method();
	}

使用方法递归获取1到指定整数的累加和

	public static void main (String[] args) {
		int value = getValue(5);
		System.out.println("sum = " + value);

		System.out.println("===================");

		int sum = getSum(5);
		System.out.println("sum = " + sum);
	}

	public static int getSum (int num) {
		if (num == 1) {
			return 1;
		}	

		//使用递归调用 *** 作
		return num + getSum(num - 1);
	}

	/*
		两个明确:
			返回类型:int
			形参列表:int num
	*/

	public static int getValue (int num) {
		int sum = 0;
		for (int i = 1; i <= num ; i++ ) {
			sum += i;
		}
		return sum;
	}

需求：
	有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，
	假如兔子都不死，问指定月份的兔子对数为多少？ 

规律：
	第一个月：1
	第二个月：1
	第三个月：2
	第四个月：3
	第五个月：5
	第六个月：8
	...

	规律：从第三个月开始，每个月的兔子对数是前两个月的兔子对数之和
       第一个月和第二个月的兔子对数都是1

	public static void main (String[] args) {
		long num = getNum(8);
		System.out.println("兔子的总对数:" + num);
	}

	/*
		两个明确:
			返回类型:long
			形参列表:int month
	*/
	public static long getNum (int month) {
		//给递归添加限定条件
		if (month == 1 || month == 2) {
			return 1;
		}

		return getNum(month - 1) + getNum(month - 2);
	}