Java流程控制(二)

⭐ 循环结构

循环结构分两大类，一类是当型，一类是直到型。

🐟 当型：
当布尔表达式条件为 true 时，反复执行某语句，当布尔表达式的值为 false 时才停止循环，比如：while 与 for 循环。
🐟 直到型：
先执行某语句， 再判断布尔表达式，如果为 true，再执行某语句，如此反复，直到布尔表达式条件为 false 时才停止循环，比如 do-while 循环。

while 循环

语法结构：

	while(布尔表达式){
		循环体;
}

🐟 在循环刚开始时，会计算一次“布尔表达式”的值，若条件为真，执行循环体。而对于后来每一次额外的循环，都会在开始前重新计算一次。
🐟 语句中应有使循环趋向于结束的语句，否则会出现无限循环–––"死"循环。

【eg】while 循环结构：求 1 到 100 之间的累加和

		public class Test {
		public static void main(String[ ] args) {
			int i = 0;
			int sum = 0;
		// 1+2+3+…+100=?
			while (i <= 100) {
			sum += i;//相当于 sum = sum+i;
			i++;
		}
		System.out.println("Sum= " + sum);
	}
}

执行结果如图所示：

do-while 循环

语法结构：

	do{
	循环体
	}while(布尔表达式);

do-while 循环结构会先执行循环体，然后再判断布尔表达式的值，若条件为真，执行循环体，当条件为假时结束循环。do-while 循环的循环体至少执行一次。

【eg】do-while 循环结构：求 1-100 之间的累加和

	public class Test {
		public static void main(String[ ] args) {
		int i = 0;
		int sum = 0;
		do {
		sum += i; // sum = sum + i
		i++;
		} while (i <= 100); //此处的；不能省略
		System.out.println("Sum= " + sum);
	}
}

执行结果如下所示：

【eg】while 与 do-while 的区别

		public class Test {
		public static void main(String[ ] args) {
		//while 循环：先判断再执行
		int a = 0;
			while (a < 0) {
				System.out.println(a);
		a++;
	}
		System.out.println("-----");
		//do-while 循环：先执行再判断
		a = 0;
		do {
		System.out.println(a);
		a++;
		} while (a < 0);
		}
}
//	运行结构，可以看出 do-while 总是保证循环体至少会被执行一次！

循环结构(for)

语法结构：

	for (初始表达式; 布尔表达式; 迭代因子) {
 		循环体;
}

🐟 初始化部分设置：循环变量的初值
🐟 条件判断部分为：布尔表达式
🐟 迭代因子：控制循环变量的增减

for 循环在执行条件判定后，先执行的循环体部分，再执行步进。

【eg】for 循环

	public class Test {
		public static void main(String args[ ]) {
		int sum = 0;
	//1.求 1-100 之间的累加和
		for (int i = 0; i <= 100; i++) {
		sum += i;
	}
		System.out.println("Sum= " + sum);
	//2.循环输出 9-1 之间的数
		for(int i=9;i>0;i--){
		System.out.print(i+"、");
	}
	System.out.println();
	//3.输出 90-1 之间能被 3 整除的数
		for(int i=90;i>0;i-=3){
		System.out.print(i+"、");
		}
	System.out.println();
	}
}

执行结果如下所示：

【eg】逗号运算符

	public class Test {
		public static void main(String[ ] args) { 
			for(int i = 1, j = i + 10; i < 5; i++, j = i * 2) {
			System.out.println("i= " + i + " j= " + j); 
 		} 
	}
}

执行结果如下所示：

【eg】无限循环

	public class Test {
		public static void main(String[ ] args) { 
		for ( ; ; ) { // 无限循环: 相当于 while(true)
		 System.out.println("北京");
		}
	}
}

编译器将 while(true)与 for(;;)看作同一回事，都指的是无限循环。

【eg】初始化变量的作用域

		public class Test {
			public static void main(String[] args) {
			for(int i = 1; i < 10; i++) {
				System.out.println(i+" ");
		}
				System.out.println(i);//编译错误，无法访问在 for 循环中定义的变量 i
		}
}

⭐ 嵌套循环

循环语句内部，再写一个或多个循环，称为嵌套循环。一般工作中多见的就是两层。

【eg】嵌套循环

		public class Test {
			public static void main(String args[ ]) {
			for (int i=1; i <=5; i++) {
			 for(int j=1; j<=5; j++){
 			System.out.print(i+" ");
		 }
		System.out.println();
		}
	}
}

执行结果如下图所示：

【eg】使用嵌套循环实现九九乘法表

	public class Test {
		public static void main(String args[ ]) {
		for (int i = 1; i < 10; i++) { // i 是一个乘数
		for (int j = 1; j <= i; j++) { // j 是另一个乘数
 		System.out.print(j + "*" + i + "=" + (i * j < 10 ? (" " + i * j) : i * j) + " ");
		}
		System.out.println();
		}
	}
}

执行结果如下图所示：

⭐ break 语句和 continue 语句

🐟	break 用于强行退出整个循环
🐟	continue 用于结束本次循环，继续下一次

【eg】break 语句

//产生 100 以内的随机数，直到随机数为 88 时终止循环
	public class Test {
		public static void main(String[ ] args) {
		int total = 0;//定义计数器
		System.out.println("Begin");
		while (true) {
		total++;//每循环一次计数器加 1
		int i = (int) Math.round(100 * Math.random());
		//当 i 等于 88 时，退出循环
		if (i == 88) {
		break;
		}
	}
		//输出循环的次数
		System.out.println("Game over， used " + total + " times.");
		}
}

执行结果如下所示：

continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

【eg】continue 语句

//把 100~150 之间不能被 3 整除的数输出，并且每行输出 5 个
	public class Test {
		public static void main(String[ ] args) {
		int count = 0;//定义计数器
		for (int i = 100; i < 150; i++) {
		//如果是 3 的倍数，则跳过本次循环，继续进行下一次循环
		if (i % 3 == 0){
		continue;
	}
	//否则（不是 3 的倍数），输出该数
		System.out.print(i + "、");
		count++;//每输出一个数，计数器加 1
		//根据计数器判断每行是否已经输出了 5 个数
		if (count % 5 == 0) {
		System.out.println();
			}
		}
	}
}

执行结果如下所示：

带标签的 continue 语句

🐟	“标签”是指后面跟一个冒号的标识符，例如：“label:”。对 Java 来说唯一用到标签的地方是在循环语句之前。
🐟	“goto 有害”论中，最有问题的就是标签，而非 goto，随着标签在一个程序里数量的增多，产生错误的机会也越来越多。但 Java 标签不会造成这方面的问题，因为它们的活动场所已被限死，不可通过特别的方式到处传递程序的控制权。

【eg】带标签的 continue

	//控制嵌套循环跳转(打印 101-150 之间所有的质数)
	public class Test {
		public static void main(String args[ ]) {
		outer: for (int i = 101; i < 150; i++) {
		for (int j = 2; j < i / 2; j++) {
		if (i % j == 0){
		continue outer; //符合某条件，跳到外部循环继续
		}
	}
		System.out.print(i + " ");
		}
	}
}

执行结果如下所示：

⭐ 方法

语句块

🐟	语句块（也叫复合语句）。语句块中定义的变量只能用于自己，外部不能使用。
🐟	语句块可以使用外部的变量，而外部不能使用语句块的变量；

【eg】语句块

	public class Test {
		public static void main(String[ ] args) {
		int n;
		int a;
		{
			int k;
			int n; //编译错误：不能重复定义变量 n
			} //变量 k 的作用域到此为止
		}
}

方法

⭐	方法(method)：一段用来完成特定功能的代码片段，类似于其它语言的函数(function)。
⭐	方法用于定义该类或该类的实例的行为特征和功能实现。
⭐	面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。
⭐	面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。

方法声明格式：

		[修饰符 1 修饰符 2 …] 返回值类型 方法名(形式参数列表){
		 Java 语句；… … …
}

方法的调用方式：

方法的详细说明

⭐	形式参数：在方法声明时用于接收外界传入的数据。（方法定义时）
⭐	实参：调用方法时实际传给方法的数据。 (方法调用时)
⭐	返回值：执行完毕后，返还给调用它的环境的数据。
⭐	返回值类型：事先约定的返回值的数据类型，如无返回值，则为 void。

【eg】方法的声明及调用

	public class Test {
/** main 方法：程序的入口 */
		public static void main(String[ ] args) {
		int num1 = 10;
		int num2 = 20;
//调用求和的方法：将 num1 与 num2 的值传给 add 方法中的 n1 与 n2
// 求完和后将结果返回，用 sum 接收结果
		int sum = add(num1, num2);
		System.out.println("sum = " + sum);//输出：sum = 30
	//调用打印的方法：该方法没有返回值
		print();
}
		/** 求和的方法 */
	public static int add(int n1, int n2) {
	int sum = n1 + n2;
	return sum;//使用 return 返回计算的结果
	}
	/** 打印的方法 */
	public static void print() {
		System.out.println("北京...");
	}
}

注意

🐟	实参必须和形参列表匹配。
🐟	return：终止方法运行，并返回的数据。
🐟	Java 中传递参数，遵循值传递的原则(传递的都是数据的副本)：
🐟	基本类型传递的是该数据值的 copy 值。
🐟	引用类型传递的是该对象引用的 copy 值，但指向的是同一个对象。

⭐ 方法的重载(overload)

重载：一个类中可以定义多个名称相同，但形式参数列表不同的方法。

构成方法重载的条件：

🐟	形参列表不同的含义：形参类型、形参个数、形参顺序不同
🐟	只有返回值不同不构成方法的重载
如：int a(String str){}与 void a(String str){}不构成方法重载
🐟	只有形参的名称不同，不构成方法的重载
如：int a(String str){}与 int a(String s){}不构成方法重载

【eg】方法重载

	public class Test {
		public static void main(String[ ] args) {
		System.out.println(add(3, 5));// 8
		System.out.println(add(3, 5, 10));// 18
		System.out.println(add(3.0, 5));// 8.0
		System.out.println(add(3, 5.0));// 8.0
		// 我们已经见过的方法的重载
		System.out.println();// 0 个参数
		System.out.println(1);// 参数是 1 个 int
		System.out.println(3.0);// 参数是 1 个 double
	}
	/** 求和的方法 */
	public static int add(int n1, int n2) {
		int sum = n1 + n2;
		return sum;
	}
	// 方法名相同，参数个数不同，构成重载
	public static int add(int n1, int n2, int n3) {
		int sum = n1 + n2 + n3;
		return sum;
	}
	// 方法名相同，参数类型不同，构成重载
	public static double add(double n1, int n2) {
		double sum = n1 + n2;
		return sum;
	}
	// 方法名相同，参数顺序不同，构成重载
	public static double add(int n1, double n2) {
		double sum = n1 + n2;
		return sum;
	}
	//编译错误：只有返回值不同，不构成方法的重载
	public static double add(int n1, int n2) {
		double sum = n1 + n2;
		return sum;
	}
	//编译错误：只有参数名称不同，不构成方法的重载
	public static int add(int n2, int n1) {
		double sum = n1 + n2;
		return sum;
	}
}

⭐ 递归结构

🐟	递归是一种常见的算法思路，在很多算法中都会用到。比如：深度优先搜索（DFS:Depth First Search）等。
🐟	递归的基本思想就是“自己调用自己”。

递归结构包括两个部分：

🐟	定义递归头。 解决：什么时候不调用自身方法。如果没有头，将陷入死循环，也就是递归的结束条件。
🐟	递归体。 解决：什么时候需要调用自身方法。

【eg】使用递归求 n!

	public class Test {
		public static void main(String[ ] args) {
			long d1 = System.currentTimeMillis(); 
			factorial(10);
			long d2 = System.currentTimeMillis();
		System.out.printf("递归费时:"+(d2-d1)); //耗时：32ms
	}
	/** 求阶乘的方法*/
		static long factorial(int n){
		if(n==1){//递归头
		return 1;
		}else{//递归体
		return n*factorial(n-1);//n! = n * (n-1)!
		}
	}
}

执行结果如下所示：

执行结果如下所示：

递归的缺陷
❗算法简单是递归的优点之一。但是递归调用会占用大量的系统堆栈，内存耗用多，在递归调用层次多时速度要比循环慢的多，所以在使用递归时要慎重。

比如上面的递归耗时 558ms(看电脑配置)。但是用普通循环的话快得多，如下所示。

【eg】使用循环求 n!

	public class Test {
		public static void main(String[ ] args) {
			long d3 = System.currentTimeMillis();
			int a = 10;
			int result = 1;
			while (a > 1) {
			result *= a * (a - 1);
			a -= 2;
	}
			long d4 = System.currentTimeMillis();
		System.out.println(result);
		System.out.printf("普通循环费时："+(d4 - d3));
		}
}

执行结果如下所示：