方法，递归引入

方法【重点】

1. 方法

1.1 生活中方法引入

生活角度分析:
	黄金蛋炒饭 [名字]
	配料:
		大米，鸡蛋, 小葱，油，盐，耗油，白胡椒 [做饭需求]
	流程:
		1. 取蛋黄
		2. 鸡蛋拌饭，放一丢丢盐
		3. 倒油，炒制
		4. 耗油，盐，白胡椒
		5. 撒小葱      [流程]
	产出: 
		一份黄金蛋炒饭 [最终结果]

开发中方法:
	1. 有名字【具有一定范围的唯一性】
	2. 有所需【方法执行需要必要的参数】
	3. 有流程【归纳总结的本体】
	4. 有结果【方法执行会存在返回值】

1.2 开发中对于方法的需求

	代码中可能存在某一个模块不断的复用！！！如果还是采用循环+CV大法会导致代码出现以下问题:
	1. 代码冗余！
	2. 代码维护性极差！
	3. 代码阅读性极差！

1.3 Java中定义方法的格式 比葫芦画瓢

public static void main(String[] args) {
	// 代码块
}

/*
public static:
	不要问，固定格式
void:
	返回值类型 returnType void表示当前方法没有返回值
main:
	方法名，操作当前方法的名字，要求符合命名规则，见名知意，动宾结构，小驼峰命名法
():
	形式参数列表，告知方法的调用者，这里方法执行所需必要参数有哪些
{}:
	大括号以内就是方法体，封装的功能代码
总结:
	public static 返回值类型 方法名(形式参数列表) {
		方法体;
	}
*/

1.4 无参数无返回值方法

需求:
	在cmd中展示一个 Hello, Method

方法分析:
	public static: 
		不要问，固定格式
	返回值类型:
		这里没有返回值需求，为void
	方法名:
		见名知意，动宾结构，小驼峰命名法
		printHelloMethod / showHelloMethod
	形式参数列表:
		当前方法执行，没有参数需求，该方法没有参数
		()

方法声明:
	public static void printHelloMethod()

class Method1 {
	public static void main(String[] args) {
		/* 
		方法是条狗，哪里需要哪里吼，吼什么
		通过名字叫一个狗
		调用方法也是通过名字来执行的
		格式:	
			方法名(实际参数);
		*/
		printHelloMethod();
		printHelloMethod();
		printHelloMethod();
		printHelloMethod();
		printHelloMethod();
		// 方法和变量最大的区别就是小括号，调用方法一定要有小括号
		// printHelloMethod;
	}
	
	/*
	自定义方法在代码中的位置:
		1. 在class大括号以内
		2. 在其他方法大括号之外，属于并列关系
	*/
	/**
	* 在cmd中展示一个Hello, Method
	*/
	public static void printHelloMethod() {
		System.out.println("Hello, 苟磊");
	}
}

1.5 有参数无返回值方法

需求:
	用户提供一个整数，当方法展示数据到cmd上

方法分析:
	public static:
		不要问，固定格式
	返回值类型:
		当前方法操作不需要返回值类型 void
	方法名:	
		printIntNumber 展示int类型数据
	形式参数列表:
		当前方法运行所需外来数据支持，也就是用户提供的int类型数据。
		(int num)
			int 
				是数据类型
			num 
				是形式参数变量名，当前num可以作为方法内的一个变量使用，当前参数
				名字要求能够满足见名知意，动宾结构，小驼峰命名法

方法声明:
	public static void printIntNumber(int num)

class Method2 {
	public static void main(String[] args) {
		// 当前方法带有参数
		printIntNumber(10);
		
		/*
		1. 需要参数传入的方法，必须有对应类型实际参数提供
		2. 方法参数的个数，类型和顺序必须和方法声明一致
		*/
		// printIntNumber(10, 10);		
	}
	
	/**
	* 在cmd中，展示用户提供的int类型数据
	* 
	* @param num 用户提供的int类型数据 parameter
	*/
	public static void printIntNumber(int num) {
		System.out.println("Int Number : " + num);
	}
}

1.6 无参数有返回值方法

需求:
	返回一个数值5

方法分析:
	public static:
		不要问，固定格式
	返回值类型:
		当前方法返回一个数据5,5是int类型，当前方法的返回值为int类型。
	方法名:
		giveMeFive 给我一个5
	形式参数列表:
		当前方法不需要参数 ()

方法声明:
	public static int giveMeFive()

class Method3 {
	public static void main(String[] args) {
		int num = 0;
		
		System.out.println("Before Method Call : " + num);
		// 调用方法，使用giveMeFive方法返回值赋值操作变量num
		num = giveMeFive();
		System.out.println("After Method Call : " + num);
		
	}
	
	/**
	* 当前方法返回一个int类型数据5
	*
	* @return 返回数据是一个5，为int类型
	*/
	public static int giveMeFive() {
		/*
		return 关键字
			1. 终止当前方法的运行
			2. 返回return之后的数据，到方法之外
		*/
		return 5;
	}
}

1.7 有参数有返回值方法

需求:
	计算两个整数之和，通过方法返回值返回
	
方法分析:
	public static:
		不要问，固定格式
	返回值类型:
		两个整数之和为int类型
		后期开发中可能会考虑数据类型在运行过中，发生改变的情况。两个int可能相加结
		果超出int类型数据范围，可以考虑使用long作为返回值类型
	方法名:
		getSumOfTwoNumber
		见名知意，动宾结构，小驼峰命名法
	
	形式参数列表:
		这里需要两个int类型数据，形参格式
		(int num1, int num2)

方法声明:
	public static int getSumOfTwoNumber(int num1, int num2)

class Method4 {
	public static void main(String[] args) {
		int sum = 0;
		
		System.out.println("Before Method Call : " + sum);
		
		sum = getSumOfTwoNumber(20, 10);
		System.out.println("After Method Call : " + sum);
	}
	
	/**
	* 获取两个int类型数据之和，通过返回值返回
	*
	* @param num1 int类型数据
	* @param num2 int类型数据
	* @return 返回两个整数之和，为int类型
	*/
	public static int getSumOfTwoNumber(int num1, int num2) {
		return num1 + num2;
	}
}

2.方法的重载与重写

2.1重载

重载就是在一个类中，有相同的函数名，但形参不同的函数、

方法重载的规则：
1. 方法名必须相同
2. 参数列表必须不同（个数、类型、参数顺序不同）
3. 方法的返回值可以相同也可以不同
4. 仅仅返回值类型不同不足以称为方法的重载

实现理论：方法名相同时，编译器会根据调用方法的参数个数、参数类型去逐个匹配，已选择对应的方法，如果匹配失败，则编译器报错

// 原方法
public static int add(int a, int b){
    
}
// 不是方法的重载，也不是重写
public static String add(int a, int b){
    
}
// 重载
public static String add(int a, int b，int c){
    
}
// 重载
public static int add(int b, int a){
    
}

2.2 重写

方法重写
在父类与子类的继承中，当子类需要修改或者拓展父类的一些方法时，可以覆盖继承父类的方法，也称为重写。

方法重写是指子类中的方法与父类中继承的方法有完全相同的返回值类型、方法名、参数个数和参数类型。

重写规则：

（1）父类方法的参数列表必须完全与被子类重写的方法的参数列表相同，否则不能称其为重写而是重载。

（2） 父类的返回类型必须与被子类重写的方法返回类型相同，否则不能称其为重写而是重载。

（3）子类重写的方法不能拥有比父类方法更加严格的访问权限。

（4）在继承过程中如果父类当中的方法抛出异常，那么在子类中重写父类的该方法时，也要抛出异常，

而且抛出的异常不能多于父类中抛出的异常(可以等于父类中抛出的异常)。

public class Animal {

            public void eat() {
                System.out.println("动物可以吃东西");
            }
        }
// 重写
public class TomCat extends Animal {

            public void eat() {
                System.out.println("TomCat：WDNMD");
            }
        }

3.递归

递归：就是A方法自己调用A方法，即自己调用自己

利用递归可以用简单的程序解决一写复杂的问题，他通常把一个大型的问题层层转化为一个与原问题相似的规模较小的问题，递归策略只需要少量的

程序就可描述出解题过程所需要的多次重复计算，大大减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。

递归结构包括两个部分：

递归头：什么时候不调用自身方法，如果没有头，将陷入死循环
递归体：什么时候需要调用自身方法。

// 阶乘问题
public class Test {

    public static void main(String[] args) {

        System.out.println(test(5));

    }
    public static int test(int a) {
		// 递归头
        if (a == 1) {
            return 1;
         // else {} 递归体
        } else {
            return a * test(a - 1); // 自己调用自己方法
        }
    }
}
/*
java 使用栈机制，没调用一个方法想当于压栈一次，如果调用次数过多会导致栈溢出（StackOverFlowError），因为栈内存空间有限，调用方法没用结束，无法出栈一致处于压栈，就会导致栈溢出
*/