Java程序猿必学第三篇——方法

//1. 无参数无返回值方法

//打印10个-的冗余代码特别多，如何优化？
//引入方法：
//概述：代码的封装，将多处重复编写的代码抽取出去，放到方法定义(实现)处；通过方法调用来执行
//作用： 使代码结构清晰，方便复用
		
//方法的组成： 1. 方法实现(定义)  2.方法调用

 

//建议大家创建类，后缀写上Test，代表测试类--里面包含了main方法
//学习面向对象后，就会有非测试类，里面没有main方法
//案例：打印静夜思；每打印一句，都要打印出10个'-'
public class FunTest {
	public static void main(String[] args) {
		System.out.println("床前明月光");
		
		//使用方法调用，来调方法实现
		print();
		
		System.out.println("疑是地上霜");
		
		print();
		
		System.out.println("举头望明月");
		
		print();
		
		System.out.println("低头思故乡");
		
		print();
	}
	
	//方法定义(实现)： print为方法名
	public static void print() {
		//方法体
		for(int i=1;i<=10;i++) {
			System.out.print("-");
		}
		System.out.println();  //换行
	}

	//注意：方法与方法间是同级的不能嵌套使用，main方法也是一个方法，不能把我们定义的方法放到main方法里面
	
}


//2. 有参数无返回值方法
 

//案例2：打印静夜思；每打印一句，第一次打印出10个'-';后面每一次都比前一次多5个'-'
public class FunTest2 {
	public static void main(String[] args) {
		System.out.println("床前明月光");
		
		print(10);  //实参：在方法调用传，实际传入的参数
		
		System.out.println("疑是地上霜");
		print(15);
		
		
		System.out.println("举头望明月");
		
		print(20);
		
		System.out.println("低头思故乡");
		
		print(25);
		
	}
	
     //形参： 在方法实现处，形式上的参数
	public static void print(int c) { //int c = 10;  c = 15
		//方法体
		for(int i=1;i<=c;i++) {
			System.out.print("-");
		}
		System.out.println();  //换行
	}
	
}

//3. 有参数有返回值方法（常用）

 

//案例: 从控制台输入两个整数，并求和
//升级： 加入第一个参数小于0，则求和为0
public class FunTest3 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入第一个变量");
		int a = sc.nextInt();
		System.out.println("请输入第二个变量");
		int b = sc.nextInt();
		int sum = add(a,b);  //使用方法，方便复用及扩展
		System.out.println("和为:"+sum);
		
		
	}
	
	//有参数，有返回值方法
	public static int add(int a,int b) {
		if(a>=0) {
			return a+b;
		}else {
			return 0;  //return的值要匹配上返回类型
		}
		
	}
	
	//注意： 
	//1.有返回值，方法实现处不能写void，而是指定要返回的类型--int
	//2.方法体最后，一定要写上return，及对应类型的值---int值
	//3.有多少个出口，就有多少个return； 且不能重复使用return
}


//4. return的使用

//=======================return使用1=======================
//问题：return只能用在有返回值的方法中吗，其他地方能使用吗？
//1.return使用在无返回值方法中
//案例：循环打印1~10，遇到3的倍数则退出，使用方法来做
public class ReturnTest1 {
	public static void main(String[] args) {
		for(int i=1;i<=10;i++) {
			if(i%3==0) {
				return;  //跳出函数体，如果方法没有返回值，则return不能带值
				//break;   //跳出循环体
			}
			System.out.println(i);
		}
		System.out.println("最后的执行...");
		
		//return;  //在方法最后也可以加return，也可以不加
	}
}
  
 
  
//=======================return使用2=======================
//2.return使用在switch中
//打印周一到周五吃饭的问题
public class ReturnTest2 {
	public static void main(String[] args) {
		System.out.print("请输入一周吃饭问题:");
		Scanner sc = new Scanner(System.in);
		int week = sc.nextInt();
		switch (week) {
		case 1:
			System.out.println("鲍鱼龙虾");
			break;
		case 2:
		case 3:
		case 4:
			System.out.println("肯德基");
			break;
		case 5:
			System.out.println("泡面");
			return;  //跳出函数体
		default:
			System.out.println("输入有误~");
			break;
		}
		System.out.println("结束语句....");
	}
}


//5. debug调试

//======================有参有返回值调试======================
//问题：给出一个案例，让你用方法来操作，如何确定是否需要参数和返回值呢？
//加入方法参数，目的是加强复用性和扩展性--变化的数值传入
//加入返回值，目的是在main方法中根据结果做后续处理
//所以后续，往往最常用的就是--有参数有返回值的方法
//案例： 输入两个整数，求出最大值，请使用方法完成

//debug调试：
//1.加断点---从哪个位置开始调试
//f5： 跳到方法的实现处 
//f6: 下一步（最常用）
//f8: 跳到下一个断点，如果没有，结束了
public class DebugTest {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入第一个整数");
		int num1 = sc.nextInt();
		System.out.println("请输入第二个整数");
		int num2 = sc.nextInt();
		int max = maxFun(num1,num2);
		System.out.println("最大值为:"+max);
	}

	public static int maxFun(int num1, int num2) {
		return (num1>num2)?num1:num2;
	}
}


//=======================循环嵌套调试=======================
//案例：打印直角三角形，个数及图形从控制台录入;使用方法封装
public class QianTao {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.print("请录入个数:");
		int count = sc.nextInt();
		System.out.print("请录入图形:");
		String tu = sc.next();
		printTu(count,tu);
	}

	private static void printTu(int count, String tu) {
		for(int i=1;i<=count;i++) {
			for(int j=1;j<=i;j++) {
				System.out.print(tu);
			}
			System.out.println(); //回车
		}
	}
}


//6. 方法的多级调用
//多级方法调用：方法实现中，又调方法
public class ManyFun {
	public static void main(String[] args) {
		System.out.println("main----start");  //1
		m1();
		System.out.println("main----end");  //5
	}

	private static void m1() {
		System.out.println("m1....start");   //2
		m2();
		System.out.println("m1....end");    //4
	}

	private static void m2() {
		System.out.println("执行m2...");    //3
	}
}


// 递归方法（扩展）

//递归(扩展)：  自己调用自己；且必须要有出口，没有出口就是死递归
//递归的用法，类似于循环，如果能用循环，可以考虑用递归
//注意：如果能用其他方式解决，尽量不用递归，递归有两个弊端：1.效率低  2.容易出现死递归

//使用递归的条件:
//1.定义一个方法，找出有规律的数列
//2.要有退出的出口

//=======================死递归=======================
public class Test1 {
	public static void main(String[] args) {
		m1();
	}

	private static void m1() {
		System.out.println("执行m1...");
		m1();   //死递归---类似于死循环
	}
	
}


//=======================求阶乘案例=======================
//案例：求一个数的阶乘； 例如4的阶乘： 1*2*3*4
//4的阶乘: 4*3的阶乘  ===>4*3*2*1
//3的阶乘：  3*2的阶乘
//2的阶乘： 2*1的阶乘
//1的阶乘： 1
public class Test2 {
	public static void main(String[] args) {
		int n = 4;
		int val = f(n);  //4*3*2*1
		System.out.println(n+"的阶乘为:"+val);
	}

	private static int f(int n) { //4 3
		if(n==1) {
			return 1;
		}
		return n*f(n-1);  //2*f(1)
	}
}


//=======================斐波拉契数列=======================
//案例2：使用递归完成斐波拉契数列：
//0  1  1  2  3  5  8  13  21 ...
//规律：第1项为0   第二项为1  第3项=第1项+第2项
public class Test3 {
	public static void main(String[] args) {
		System.out.println("请输入斐波拉契数列的项数:");
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		for(int i=0;i<=n;i++) {
			System.out.print(f(i)+"\t");  //0  1  1  2  3
		}
	}

	public static int f(int n) { //4
		if(n==0||n==1) {
			return n;
		}
		return f(n-1)+f(n-2); //2+1
	}
}