[java基础-4] 循环&方法:方法声明.重载.递归

[java基础-4] 循环&方法:方法声明.重载.递归 循环 死循环

for死循环:执行效率优先于while

for (;;) {
  循环体语句;
}

while死循环:代码阅读性更强

while (true) {
循环体语句;
}

循环嵌套

百钱买百鸡:

花100文钱买100只鸡,公鸡5文1只,母鸡3文1只,小鸡1文3只,花100文钱正好买100只鸡

public class BasicDemo03 {
	public static void main (String[] args) {
		

		
		//循环次数=21*34=714
		for (int gong = 0; gong <= 20 ; gong++ ) {
			for (int mu = 0; mu <= 33; mu++) {
				int xiao = 100 - gong - mu;//前提是被3整除
				if ((gong * 5 + mu * 3 + xiao / 3 == 100) && (xiao % 3 == 0)) {
					System.out.println("公鸡有"+gong+"只，母鸡有"+mu+"只，小鸡有"+xiao+"只");
				}
			}
		}
	}
}

---

打印1-100之间所有质数:

public class BasicDemo04 {
	public static void main (String[] args) {
		int c = 0;
        
		

		//循环次数:1133
		for (int i = 2; i <= 100 ; i++ ) {
			//给每个被除数设置一个标记,默认所有的整数都是质数
			boolean flag = true;

			for (int j = 2; j < i; j++) {
				c++;

				if (i % j == 0) {
					flag = false;
					break;
				}
			}

			if (flag) {
				System.out.println(i);
			}
		}

		System.out.println(c);
	}
}

---

打印九九乘法表:

public class BasicDemo05 {
	public static void main (String[] args) {
		for (int hang = 1; hang <= 9; hang++) {
			for (int lie = 1; lie <= hang ; lie++ ) {
				System.out.print(lie + "*" + hang + "=" + hang * lie + "t");
			}
			System.out.println();
		}
	}
}

---

方法 定义

method是执行特殊功能的代码块

好处

提高代码的复用性,从而提高开发效率将功能性代码抽取出来,有效的降低代码的耦合性(降低代码与代码之间的依赖) 声明格式

​ 修饰符public static 返回值类型 方法名 (形参类型1 形参名1,形参类型2 形参名2,…) {
​ 方法体语句
​ return 返回值;//有返回值则返回给调用者,无则由return结束方法
​ }

方法的传参和返回

传参: 调用者方法的==数据 > 自定义方法返回: 自定义方法的==结果 > 调用者方法 声明前的两个明确

返回值类型:

基本数据类型引用数据类型没有返回值

形参列表:

需要用到调用者方法中的几个数据每个数据类型的数据类型和变量名 方法特点

不调用不执行

方法的调用方式(3*3)

如果方法属于类,调用方式:
类名.方法名(实参);

如果方法属于对象,调用方式:

​ 对象名.方法名(实参);

(以上类和对象未学)

---

如果调用同一个类中方法:

单独调用(直接调用)
方法名(实参);输出调用(打印调用)
System.out.println(方法名(实参));赋值调用
数据类型 变量名 = 方法名(实参);

调用举例:通过方法完成两个整数求和计算

代码

public class MethodDemo02 {
	public static void main (String[] args) {
		//单独调用(直接调用)
		//getSum(3,4);
		//输出调用
		//System.out.println(getSum(3,4));
		//赋值调用
		int sum = getSum(3,4);
		System.out.println(sum);
	}

	
	public static int getSum (int a , int b) {
		int sum = a + b;
		return sum;
	}
}

方法调用的内存图解
void关键字

声明方法时,如果方法没有返回值,返回值类型的位置也不能空着,需要使用void关键字进行占位(void即表示方法没有返回值)当方法返回值类型是void时,调用方式只能是单独调用,否则编译报错当方法返回值类型是void时,return语句可以省略不写

举例说明:打印指定次数的HelloWorld

*/
public class MethodDemo05 {
	public static void main (String[] args) {
		print(10);
	}

	

	public static void print (int num) {
		for (int i = 1; i <= num ; i++ ) {
			System.out.println("HelloWorld");
		}

		return;
        //System.out.println("111111");return后不能写代码,return结束了方法
	}
}

方法的重载

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

方法重载的注意事项:

方法重载的注意事项:
1.必须在同一个类中(或子父类继承关系中)
2.方法名必须相同
3.形参列表必须不同(必须满足以下至少一点)
a.形参的个数不同
b.形参的数据类型不同
c.形参数据类型的顺序不同
4.重载方法的调用取决于调用方法时的实参,根据实参匹配合适的方法

方法重载练习

public class MethodDemo07 {
	public static void main (String[] args) {
        method(123);
        
		//method(3,4);//A int double B double int//虚拟机不知道提升3还是4,报错 
		//System.out.println(null);//引用不明确,报错,同上
	}
    public static void method (int a , double b) {
		System.out.println("int double");
	}

	public static void method (double a, int b) {
		System.out.println("double int");
	}
    
    //针对以上两种方法,若实参为(3,4.5),输出double double
    public static void method (byte num) {
		System.out.println("byte");
	}
	
	public static void method (short num) {
		System.out.println("short");
	}

	public static void method (int num) {
		System.out.println("int");
	}

	public static void method (long num) {
		System.out.println("long");
	}
}	

方法的总结

​ 1.方法声明的位置:类中,方法外;在程序中不可以形成方法的嵌套
​ 2.当进行方法声明的时候,返回值类型如果没有的话,也不能空着,需要使用void关键字进行替代
​ 3.当方法返回值类型是void时,方法中return关键字可以省略不写
​ 4.在方法中可以存在多个return语句,但是最终执行的只有唯一的一个
​ 5.当方法返回值类型是void时,方法的调用方式"只能"使用单独调用(直接调用)
​ 当方法返回值类型不是void时,方法的调用方式"推荐"使用赋值调用

​ 6.方法的形参可以没有

方法的递归

方法的递归:在程序中出现方法自身调用自身的一种现象

递归分类

直接递归:方法自身调用自身间接递归:方法A调用方法B,B调用方法C,方法C调用方法A 使用递归的前提条件

​ 使用递归必须给其添加结束条件,否则会导致栈内存溢出
​ 递归的层数不能过多,即使添结束条件,也会导致栈内存溢出

递归的好处

​ 可以帮助我们解决一些使用循环语句无法解决的问题
​ 例如:
​ *** 作多级文件夹
​ 伪代码:
​ public static void getPath (路径) {
​ 获取当前路径所有的文件以及文件夹

			遍历获取的容器
			if (是否为文件) {
				打印文件路径
			} else {
				打印文件夹路径
				getPath(新路径);
			}
		}

求1到指定数之前的累加和

public class MethodDemo10 {
	public static void main (String[] args) {
		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);
	}


	public static int add (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 class MethodDemo11 {
	//声明方法调用次数的变量
	static long count = 0;
	public static void main (String[] args) {
		//获取此时以纳秒为单位的时间  1秒=1000毫秒 1毫秒=1000微秒 1微秒=1000纳秒
		long start = System.nanoTime();
		long num = getNum02(50);
		//获取此时以纳秒为单位的时间
		long end = System.nanoTime();
		
		System.out.println("兔子的总对数:" + num);
		System.out.println("方法调用次数:" + count);
		System.out.println("程序运行时间:" + (end - start));
	}

	

	
	// 动态规划
	public static long getNum02 (int month) {
		count++;

		//当前月份兔子的对数
		long temp = 0;
		//上个月兔子的对数
		long a = 1;
		//上上个月兔子的对数
		long b = 1;

		if (month == 1 || month == 2) {
			return 1;
		}

		for (int i = 3; i <= month ; i++) {
			temp = a + b;
			b = a;
			a = temp;
		}

		return temp;
	}

	
	public static long getNum01 (int month) {
		count++;

		if (month == 1 || month == 2) {
			return 1;
		}

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