Day6-方法

---

一、方法

含义：特定功能的代码块

好处：解决了代码的冗余问题

语法结构：

			访问修饰符 static 返回值类型 方法名(参数列表){
				...代码块...
			}

注意：

			1.方法的位置是写在类的里面
			2.不能在一个方法中声明另一个方法(方法与方法之间是平级关系)
			3.方法不

被调用，就是个摆设

无返回值无参数的方法

语法结构:

			public static void methodName(){}

​
需求：
​ 编写一个方法 – printStar(),打印5行三角形

​public static void main(String[] args){
    //调用	
	printStar();
	printStar();

}
public static void printStar(){
    for(int i = 0;i<5;i++){
        for(int j = 0;j<=i;j++){
            System.out.print("*");
        }
        System.out.println();
    }
}	

带参数的方法

引入需求：编写方法printInfo，打印三遍"用良心做教育，做真实的自己"

升级：编写方法printInfo，打印"用良心做教育，做真实的自己"，打印次数由调用方指定

升级：编写方法printInfo，打印数据和打印次数由调用方指定

注意：

1. 形式参数：形参，方法声明时编写的参数
2. 实际参数：实参，方法调用时传入的具体数据
3. 形参必须指定数据类型
4. 实参数据必须兼容形参的数据类型
5. 形参之间用逗号隔开
6. 实参之间用逗号隔开

需求：编写printStar，三角形的行数与内容由调用方指定

public static void main(String[] args){
	
	//调用
	printInfo(3,"用良心做教育");
	printInfo(5,"做真实的自己");
	
	printStar(3,"$");
	printStar(6,"%");
}

public static void printStar(int num,String str){
	for(int i = 0;i<num;i++){
		for(int j = 0;j<=i;j++){
			System.out.print(str);
		}
		System.out.println();
	}
}
//版本1
//public static void printInfo(){
//	for(int i = 0;i<3;i++){
//		System.out.println("用良心做教育，做真实的自己");
//	}
//}


//版本2
//public static void printInfo(int num){
//	for(int i = 0;i<num;i++){
//		System.out.println("用良心做教育，做真实的自己");
//	}
//}


//版本3
public static void printInfo(int num,String str){
	for(int i = 0;i<num;i++){
		System.out.println(str);
	}
}

带返回值的方法

需求1：编写一个方法，传入两个数字，求数字之和

注意：

1. 方法功能单一性
2. 方法中返回具体数据的类型必须和方法声明时返回值类型兼容

需求2：编写一个方法，传入两个数字，求最大值
需求3：编写一个方法，传入一个数字，判断该数字是否是素数

总结：

		方法中参数起到了将数据传入到该方法内的作用
		方法中的返回值起到了将方法内的数据传出到调用方的作用

public static void main(String[] args){
	//调用
	int num = add(10,20);
	num = add(num,30);
	System.out.println("求和：" + num);
	
	int max = getMax(10,20);
	max = getMax(max,30);
	System.out.println("最大值为：" + max);
	
	boolean bool = isPrimeNumber(12);
	System.out.println("判断该数是否是一个素数：" + bool);
}

public static boolean isPrimeNumber(int num){
	for(int i = 2;i<num;i++){
		if(num%i == 0){
			return false;
		}
	}
	return true;
}


public static int getMax(int a,int b){
	return (a>b)?a:b;
}


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

方法的重载

含义：重载是一种关系，必须符合以下4个条件

	条件：
		1.方法之间必须在同一个类里
		2.方法名必须一致
		3.参数列表的个数或者是类型不一致
		4.与返回值无关

好处：依据实参的数据类型自动匹配到对应的重载方法

应用场景：一个类中的众多方法，功能一致，细节实现有可能不同，就是用重载

需求：

	编写一个方法，传入两个int值，求最大值 -- getMax
	编写一个方法，传入三个int值，求最大值 -- getMax
	编写一个方法，传入两个double值，求最小值 -- getMin
	编写一个方法，传入三个double值，求最小值 -- getMin

public static void main(String[] args){
	//调用
	System.out.println("求和为：" + add(10.1,12.1));
	
	System.out.println("最大值：" + getMax(10,20));
	System.out.println("最大值：" + getMax(10,20,30));
	
	System.out.println("最小值：" + getMin(10.1,20.2));
	System.out.println("最小值：" + getMin(10.1,20.2,30.3));
	
}

public static int getMax(int a,int b){
	return (a>b)?a:b;
}

public static int getMax(int a,int b,int c){
	int max = getMax(a,b);
	max = getMax(max,c);
	return max;
}

public static double getMin(double a,double b){
	return (a<b)?a:b;
}

public static double getMin(double a,double b,double c){
	double min = getMin(a,b);
	min = getMin(min,c);
	return min;
}

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

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

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

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

递归

含义：方法调用方法自身

	注意：
		1.递归用不好就容易造成死循环
		2.一定要找规律、找出口

扩展：方法调用方法自身，如果不找出口，会出现死循环（栈内存溢出），
调用方法就会在栈内存中开辟空间，死循环的调动方法，栈内存就很快被占满，就会出现栈内存溢出的错误

需求：编写一个方法，传入一个数字，求该数字的阶乘

阶乘-数学中的概念
5! = 12345 -> 5! = 4! * 5
4! = 1234 -> 4! = 3! * 4
3! = 123 -> 3! = 2! * 3
2! = 12 -> 2! = 1! * 2
1! = 1 -> 1! = 1 找出口
n! = 12.*n -> n! = (n-1)! * n 找规律

public static void main(String[] args){
	int num = getNum(5);
	System.out.println(num);
}

public static int getNum(int n){
	if(n == 1){
		return 1;
	}else{
		return getNum(n-1)*n;
	}
}

//该方法会造成栈内存溢出
public static void method(){
	method();
}

需求：

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

public static void main(String[] args){
	
	int rabbit = getRabbit(8);
	System.out.println(rabbit);
}

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