JAVA基础（4.运算符、选择结构、循环结构）

松君呐

已于 2023-05-15 09:25:26 修改

阅读量562

点赞数

分类专栏： JAVA基础文章标签： java

于 2023-05-15 08:56:45 首次发布

本文链接：https://blog.csdn.net/weixin_45707083/article/details/130676702

版权

JAVA基础专栏收录该内容

13 篇文章 1 订阅

订阅专栏

1.0 运算符

1.1 位运算【了解】

1.2 逻辑运算【掌握】

1.2.1 逻辑运算（Logical Operation）

1.2.2 逻辑运算符作用

1.2.3 逻辑运算符运算规则【掌握】

1.2.4 &&、||和 &、| 的区别？

4.2.2 do...while循环【掌握】

1.0 运算符

1.1 位运算【了解】

位运算：

程序中的所有数在计算机内存中都是以二进制的形式储存的。位运算就是直接对整数在内存中的二进制位进行操作。

位运算符：

~n:	按位取反，运算的规律：0 -> 1, 1 -> 0。
记住公式：n的按位取反结果是： -(n + 1)。
~3计算过程，先将3转换为二进制0000 0011，再进行位运算
0000 0011
---------	
1111 1100 => -4
			
&: 按位与，运算的规律：有0即0。
3 & 5 = 1
0011  => 3
0101  => 5
---- &
0001  => 1
		
|:按位或，运算的规律：有1即1。
3 | 5 = 7
0011  => 3
0101  => 5
---- |
0111  => 7
		
^:按位异或，运算的规律：同0异1。常常用来交换两个变量的值。
3 ^ 5 = 6
0011  => 3
0101  => 5
----  ^
0110  => 6
			
m << n: 按位左位移，运算的规律：如果m是正数，右边补0，是负数就补1  相当于* 2 ^ n 次方，有溢出风险。
3 << 2 = 12	 * 2 ^ 2
0011  => 3
----  <<
1100  => 12		
		
m >> n: 按位右位移，运算的规律：如果m是正数，左边补0，是负数就补1  相当于/ 2 ^ n 次方。
3 >> 2 = 0	/ 2 ^ 2
0011  => 3
----  >>
0000  => 0		
			
m >>> n: 无符号右位移，运算的规律：不管m是正数还是负数，左边永远补0，这样的话，负数移动后就变成了正数，失去了数学意义。

代码案例：

public class _13BitOperation {

public static void main(String[] args) {
	System.out.println(~3);// -4
	System.out.println(~-4);// 3
		
	System.out.println(3 ^ 5);// 6
	System.out.println(3 & 5);// 1
	System.out.println(3 | 5);// 7
	System.out.println(3 << 2);// 12
	System.out.println(3 >> 2);
	System.out.println(3 >>> 2);
		
	// 交换变量a和b的值
	int a = 3;
	int b = 5;
	a = a ^ b;
	b = a ^ b;
	a = a ^ b;
	System.out.println(a);// 5 
	System.out.println(b);// 3
		
}

}

反码和补码今天不做讨论。

1.2 逻辑运算【掌握】

1.2.1 逻辑运算（Logical Operation）

用来连接布尔类型的两个值或表达式，逻辑运算两边必须是布尔类型的值或者是布尔类型表达式。通常配合循环和条件语句使用，最终结果也位布尔类型。

1.2.2 逻辑运算符作用

应用于多个条件的组合判断。

1.2.3 逻辑运算符运算规则【掌握】

& ：逻辑单与，表示并且，有假即假，没有短路功能，有位运算功能，两边都为true ，结果为true。

| ：逻辑单或，表示或者，有真即真，没有短路功能，有位运算功能，只要有一边为true，结果为true。

&& ：逻辑双与，表示并且，有假即假，有短路功能，没有位运算功能，两边都为true ，结果为true。

|| : 逻辑双或，表示或者，有真即真，有短路功能，没有位运算功能，只要有一边为true，结果为true。

^ : 逻辑异或，同假异真【了解现实开发，基本不用】，两边不一样，结果为true ，否则为false。

! ：逻辑非，表示取反，非真即假，非假即真 (操作一个变量/值)。

优先级问题：! > &&(&) > ||(|)

代码案例

public class _11LogicalOperation {

public static void main(String[] args) {
	// 苍苍老师，数学成绩100并且语文成绩100，奖励大飞机
	int mathScore = 99;// 声明一个int类型变量mathScore表示数学成绩，赋值100
	int chineseScore = 100;// 声明一个int类型变量chineseScore表示语文成绩，赋值100
	// 用三目运算，表示上面的关系
	String str = mathScore == 100 && chineseScore == 100 ? "奖励大飞机" : "打屁股";
	System.out.println(str);
		
	// !:逻辑非， 表示取反，非真即假，非假即真 (操作一个变量/值)
	System.out.println(!true);// false
	System.out.println(!false);// true
		
	System.out.println("================== && ====================");
	System.out.println(true && true);//true
	System.out.println(true && false);//false
	// 下面两句代码 &&前发生了短路。当整个表达式结果可以确定的时候发生短路.可以提高效率
	System.out.println(false && true);//false
	System.out.println(false && false);//false
		
	System.out.println("================== & ====================");
	System.out.println(true & true);//true
	System.out.println(true & false);//false
	// 下面两句代码 &前没有短路，后面还要计算。单与逻辑运算效率低下
	System.out.println(false & true);//false
	System.out.println(false & false);//false
		
		
	System.out.println("================== || ====================");
	System.out.println(false || true);//true
	System.out.println(false || false);//false
	// 下面两句代码 ||前发生了短路。当整个表达式结果可以确定的时候发生短路.可以提高效率
	System.out.println(true || true);//true
	System.out.println(true || false);//true
		
	System.out.println("================== | ====================");
	System.out.println(false | true);//true
	System.out.println(false | false);//false
	// 下面两句代码 |前没有短路。单或逻辑运算效率低下
	System.out.println(true | true);//true
	System.out.println(true | false);//true
		
	System.out.println("================= ^【了解】 ================");
	// ^:逻辑异或， 同假异真【用的很少】
	System.out.println(false ^ true);//true
	System.out.println(false ^ false);//false
	// 下面两句代码 |前没有短路。单或逻辑运算效率低下
	System.out.println(true ^ true);//false
	System.out.println(true ^ false);//true
		
}

}

1.2.4 &&、||和 &、| 的区别？

&&、|| ：有短路功能

&、| ：没有短路功能

什么是短路？

短路问题：当逻辑运算左边能够确定整个表达式结果值的时候，就会发生短路，不会再计算后面的结果了，这样可以提供程序运算效率。

例如：

&&当左边为false时，右边的就短路了

||当左边为true时，右边的就短路了

验证代码:【了解】

public class _12LogicalOperation {

public static void main(String[] args) {
	// 验证短路，怎么验证短路？
	int a = 1;
	System.out.println(a > 2 && ++a == 2);
	System.out.println(a);// 1，说明&&后面没有运算，证明了短路。
	
	int b = 1;
	System.out.println(b > 2 & ++b == 2);
	System.out.println(b);// 2，说明&后面运算了，证明了没有短路。
	
   // 验证优先级，结果为false，表示||优先级高或者相等。true表示&&优先级高。
	System.out.println(a > 0 || true && false );// true
}

}

2.0 选择结构

概念：

选择结构就是让程序有选择的执行，满足条件就执行，不满足就不执行。根据判断的结果来控制程序的流程，是属于流程控制语句。其它两个流程控制语句是顺序结构（程序的执行是从左到右，从上到下）、循环结构（程序重复的干一件事）。

作用：

让程序有选择的执行。例如：用户登录的时候，只有用户名和密码都输入正确才能登录成功等。

2.1. if选择条件语句

基本语法：

if(判断条件) {
语句;
}

判断条件: 布尔类型的值或者表达式

执行语句：当条件满足时执行语句（可以是一条语句，也可以是一组语句）

代码案例

public class _01If {
public static void main(String[] args) {
	// 需求1：需要让智能机器人自动充电，充电条件电量低于10
	// 声明一个int类型的变量power表示电量，赋值9。
	int power = 9;
	if (power < 10) {// if条件判断，电量power < 10
		// 用一个打印语句表示，打印：主人，我被玩没电了，请插我充电！
		System.out.println("主人，我被玩没电了，请插我充电！");
	}
}
}

2.2. if ...else双条件语句

基本语法：

if(判断条件) {
   if语句;
} else {
  else语句;
}

判断条件: 布尔类型的值或者表达式

执行语句：当条件满足时执行if中的语句,不满足则执行else中的语句

代码案例：

public class _01If {
public static void main(String[] args) {
	// 需求2：智能机器人在充电条件电量低于10的时候，自动充电。不小于10，则提醒主人，一起玩耍！
	// 声明一个int类型的变量power2表示电量，赋值11。
	int power2 = 11;
	if (power2 < 10) {// if条件判断，电量power2 < 10
		// 用一个打印语句表示，打印：主人，我被玩没电了，请插我充电！
		System.out.println("主人，我被玩没电了，请插我充电！");
	} else {// else表示power 不小于 10
		// 用一个打印语句表示，打印：主人，我们一起耍一下！
		System.out.println("主人，我们一起耍一下！");
	}
}
}

2.3. if ...else双条件语句

基本语法：

if(判断条件1) {
	语句1;
} else if(判断条件2) {	
	语句2;
} else if(判断条件3) {
	语句3;
} ...
else { 
  else语句
}

判断条件: 布尔类型的值或者表达式

执行语句：按照从上到下顺序匹配条件，如果满足条件1，就执行语句1；如果满足条件2，就执行语句2；如果满足条件3，就执行语句3；

注意：只会执行一个满足的条件，哪怕下面有其它的满足条件的也不会执行了。所有条件都不满足就执行else语句中代码。

代码案例：

public class _01If {
public static void main(String[] args) {
/*
	 *  需求3：智能机器人在充电条件电量低于10的时候，自动充电。
	 *  power >= 10 并且< 60 提醒主人，一起看片，陶冶情操！
	 *  power >= 60 并且< 80 提醒主人，实践检验一下！
	 *  power >= 80 并且<= 100 提醒主人，我们来一点激烈的运动！
	 */
	// 声明一个int类型的变量power3表示电量，赋值69。
	int power3 = 69;
	if (power3 >= 0 &&power3 < 10) {// if条件判断，电量power3 < 10
		// 用一个打印语句表示，打印：主人，我被玩没电了，请插我充电！
		System.out.println("主人，我被玩没电了，请插我充电！");
	} else if(power3 >= 10 && power3 < 60) {// 判断条件：power3 >= 10 && power3 < 60
		// 用一个打印语句表示，打印：主人，一起看片，陶冶情操！
		System.out.println("主人，一起看片，陶冶情操！");
	} else if(power3 >= 60 && power3 < 80) {// 判断条件：power3 >= 60 && power3 < 80
		// 用一个打印语句表示，打印：主人，实践检验一下！
		System.out.println("主人，实践检验一下！");
	} else if(power3 >= 80 && power3 <= 100) {// 判断条件：power3 >= 80 && power3 <= 100
		// 用一个打印语句表示，打印：主人，我们来一点激烈的运动！
		System.out.println("主人，我们来一点激烈的运动！");
	} else {// 所有条件都不满足会执行else
		// 用一个打印语句表示，打印：主人，我被你玩坏了！
		System.out.println("主人，我被你玩坏了！");
	}
}
}

2.4. 注意事项

1. 选择结构是从上到下开始匹配，一旦匹配上一个条件后，整个条件语句就结束了，

哪怕后面也能匹配上条件也不会执行了。

2. if 和 if else 语句，后面可以不写{},但是不建议，因为不写{} ,只能控制一行代码。

3. if(){} else if(){}后可以不写 else，一般根据业务需求决定。

代码案例：

public class _04If {
public static void main(String[] args) {
	/*
	 * 1. 选择结构是从上到下开始匹配，一旦匹配上一个条件后，整个条件语句就结束了，
			哪怕后面也能匹配上条件也不会执行了
	 */
	if (true) {
		System.out.println("if");
	} else if (true) {
		System.out.println("else if - 1");
	} else if (true) {
		System.out.println("else if - 2");
	}
		
	/*
	 * 2. if 和 if else 语句，后面可以不写{},但是不建议
			因为不写{} ,只能控制一行代码
	 */
	if (false) // 只能控制一行代码
		System.out.println("if true");
	System.out.println("if true  后语句");
		
	if (false) // 只能控制一行代码,并且if后不能再写其他代码，否则语法报错
		System.out.println("if true");
//	System.out.println("if true");// 破坏了if else结构，报错
	else // 只能控制一行代码
		System.out.println("if true  后语句");
		
}
}

3.0 swtich 选择结构【掌握】

先看需求：

public class _02Switch {
public static void main(String[] args) {
	/*
	 * 请设计一个一周工作计划
	 * 	周一： 好好学习
	 * 	周二：看片学习
	 * 	周三： 实践学习
	 * 	周四： 吃药补补身体！
	 * 	周五： 爬山锻炼身体！
	 * 	周六： 休息，给身体放个假
	 * 	周日：总结一周所得！ 
	 */
	// 声明一个int类型变量weekDay，表示一周中的某一天。赋值4
	int weekDay = 4;
	if (weekDay == 1) {// 判断weekDay是否==1
		System.out.println("周一： 好好学习");
	} else if (weekDay == 2) {// 判断weekDay是否==2
		System.out.println("周二：看片学习");
	} else if (weekDay == 3) {// 判断weekDay是否==3
		System.out.println("周三： 实践学习");
	} else if (weekDay == 4) {// 判断weekDay是否==4
		System.out.println("周四： 吃药补补身体！");
	} else if (weekDay == 5) {// 判断weekDay是否==5
		System.out.println("周五： 爬山锻炼身体！");
	} else if (weekDay == 6) {// 判断weekDay是否==6
		System.out.println("周六： 休息，给身体放个假");
	} else if (weekDay == 7) {// 判断weekDay是否==7
		System.out.println("周日：总结一周所得！");
	} else {
		System.out.println("出错了！");
	}
}
}

上面的需求我们可以根据学过的if结构实现，但是大家可以发现一个问题，现在上面的判断条件都是一些固定的值，并且代码可读性很差，我们有没有什么方式可以优化一下代码呢？

用switch结构

3.1 switch基本语法

声明变量
switch(变量){
	case 值1:
		功能语句1
		功能语句2...
		break;
	case 值2:
		功能语句1
		功能语句2...
		break;
	case 值3:
		功能语句1
		功能语句2...
		break;
					
	default:// 相当于条件语句中else，所有的case匹配不上执行default
		default语句
		break;
}

变量：可以是局部变量或常量

switch中变量支持的数据类型：

byte/ short / int / char / String（JDK1.7） / 枚举类型（JDK1.5）

执行流程：

switch语句优先从case开始匹配，只有case都没有匹配上才匹配default语句，如果匹配上一个case，则会找最近的break，如果没有，则会一直向下执行，就不会匹配了，直到找到break或者到switch语句结束为止。

代码案例：

public class _02Switch {
public static void main(String[] args) {
	// 通过switch结构优化上面案例代码
	// 声明一个int类型变量weekDay2，表示一周中的某一天。赋值4
	int weekDay2 = 4;
	switch (weekDay2) {// switch()中写变量weekDay2
		case 1: // 表示匹配weekDay的是1的情况
			System.out.println("周一： 好好学习");
			System.out.println("周一： 好好学习");
			System.out.println("周一： 好好学习");
			break;// break表示破坏，这里结束当前switch结构
		case 2: // 表示匹配weekDay2的是2的情况
			System.out.println("周二：看片学习");
			break;
		case 3: // 表示匹配weekDay2的是3的情况
			System.out.println("周三： 实践学习");
			break;
		case 4: // 表示匹配weekDay2的是4的情况
			System.out.println("周四： 吃药补补身体！");
			break;
		case 5: // 表示匹配weekDay2的是5的情况
			System.out.println("周五： 爬山锻炼身体！");
			break;
		case 6: // 表示匹配weekDay2的是6的情况
			System.out.println("周六： 休息，给身体放个假");
			break;
		case 7: // 表示匹配weekDay2的是7的情况
			System.out.println("周日：总结一周所得！");
			break;
		default: // 所有情况都不匹配会执行default
			System.out.println("出错了");
			break;
	}
}
}

3.2 注意事项

1. 每个case之间顺序可以交换，不影响代码运行。

2. default不一定放在末尾在所有case失效的时候就会被执行到。

3. case中值与 key类型必须一致。

4. 最后一个break可以省略，但不建议。

5. break可以省略，但会导致后续case条件判断失效，按照从上到下顺序执行，直到找到第一个break跳出switch结构，如果没有找则执行到末尾后结束switch结构

4.0 循环结构

为什么要学习循环？

先来看一个需求：

// 请打印10句，我爱Java，Java让我快乐！
System.out.println("我爱Java，Java让我快乐！");
System.out.println("我爱Java，Java让我快乐！");
System.out.println("我爱Java，Java让我快乐！");
System.out.println("我爱Java，Java让我快乐！");
System.out.println("我爱Java，Java让我快乐！");
System.out.println("我爱Java，Java让我快乐！");
System.out.println("我爱Java，Java让我快乐！");
System.out.println("我爱Java，Java让我快乐！");
System.out.println("我爱Java，Java让我快乐！");
System.out.println("我爱Java，Java让我快乐！");

很明显这样写代码，非常浪费时间，可读性也不好，所以，我们要学习循环解决这样的问题。

4.1 循环概念

定义：循环结构是指在程序中需要重复执行某个功能的一种结构，是一种常见的控制流程。

循环结构需要有一个结束条件，否则会形成死循环，导致内存溢出。

4.2 循环作用

循环结构可以复用代码。

4.3 循环分类

4.3.1 while循环【掌握】

特点：先判断，如果满足条件再循环。

基本语法：

1.初始化条件（根据条件判断是否要写）
while(2.循环条件判断){
   3.循环体（重复干的事）
   4.循环控制（根据条件判断是否要写）
}

循环条件判断：布尔类型的值或者表达式。

循环体：当循环条件为true时执行循环体，当为false时终止循环，不执行循环体

。

执行流程：

第1次：1. 初始化条件语句 => 2.条件判断语句 => 3. 循环体 => 4. 循环控制语句

第2次：2.条件判断语句 => 3. 循环体 => 4. 循环控制语句

第3次：2.条件判断语句 => 3. 循环体 => 4. 循环控制语句

...

最后1次： 2.条件判断语句

代码案例：

// 请打印10句，我爱Java，Java让我快乐！
// 声明一个int类型变量count表示次数，赋值1
int count = 1;// 1. 初始化条件
while (count <= 10) {// count <= 10是 2.循环条件判断
	// 打印：我爱Java，Java让我快乐！
	System.out.println("我爱Java，Java让我快乐！ : " + count);// 3.循环体 【重复干的事】
	count++;// 次数count+1 4.循环控制语句
}

4.2.2 do...while循环【掌握】

特点：先执行一次循环体，然后再判断，如果满足条件再循环，只会预执行一次。

一般用在扫雷、获取连接数据库、远程控制、坦克大战、打飞机游戏等场景。

基本语法:

1.初始化条件（根据条件判断是否要写）
do {
	3.循环体（重复干的事）
4.循环控制（根据条件判断是否要写）
} while (2.条件判断);// 注意分号

循环条件判断：布尔类型的值或者表达式。

循环体：当循环条件为true时执行循环体，当为false时终止循环，不执行循环体

。

执行流程：

第1次：1. 初始化条件语句 => 3. 循环体 => 4. 循环控制语句

第2次：2.条件判断语句 => 3. 循环体 => 4. 循环控制语句

第3次：2.条件判断语句 => 3. 循环体 => 4. 循环控制语句

...

最后1次： 2.条件判断语句

代码案例:

public class _05While {
public static void main(String[] args) {
		// 请打印10句，我爱Java，Java让我快乐！
// 声明一个int类型变量count2表示次数，赋值1
	int count2 = 1;// 1. 初始化条件
	do {
		// 打印：我爱Java，Java让我快乐！
		System.out.println("我爱Java，Java让我快乐！ : " + count2);// 3.循环体 【重复干的事】
		count2++;// 次数count+1 4.循环控制语句
	} while (count2 <= 10);// ()后的分号必须写。
}
}

练习：

1. 输出 1-10的所有的数。

2. 求出 1-10的所有偶数的和。

3. 求出1-10中2的倍数的数字和个数。

答案代码如下：

public class _06While {
public static void main(String[] args) {
	// 1.输出 1-10的所有的数
	/*
	 *  while(条件判断){
			循环体（重复干的事）
		}
			
		do{
			循环体（重复干的事）
		}while(条件判断);//注意分号
	 */
	int num = 1;
	while (num <= 10) {
		System.out.println(num);
		num++;
	}
		
	// 2.输出 1-10的所有偶数
	/*
	 * 思路：
	 * 	1. 先输出1-10所有数字
	 *  2. 在循环体中判断这个数字是否为偶数，如果是才输出
	 */
	int num2 = 1;
	while (num2 <= 10) {
		// 判断当前num2是否是偶数
		if (num2 % 2 == 0) {
			System.out.println(num2);
		}
		// 循环控制语句：num2++
		num2++;
	}
		
	int num3 = 1;
	do {
		// 判断当前num2是否是偶数
		if (num3 % 2 == 0) {
			System.out.println(num3);
		}
		// 循环控制语句：num2++
		num3++;
	} while (num3 <= 10);
		
		
	// 3.求出 1-10的所有偶数的和
	int num4 = 1;
	int sum = 0;// 声明一个int类型变量sum赋值0，保存和。
	while (num4 <= 10) {
		// 判断当前num4是否是偶数
		if (num4 % 2 == 0) {
			// 如果是偶数，将所有偶数累加到和sum中
			sum += num4;
		}
		// 循环控制语句：num4++
		num4++;
	}
	System.out.println("和：" + sum);
		
	int num5 = 1;
	int sum2 = 0;// 声明一个int类型变量sum赋值0，保存和。
	do {
		// 判断当前num是否是偶数
		if (num5 % 2 == 0) {
			// 如果是偶数，将所有偶数累加到和sum中
			sum2 += num5;
		}
		// 循环控制语句：num++
		num5++;
	} while (num5 <= 10);
	System.out.println("和：" + sum2);
	
}
}

for(1.初始化条件语句;2.条件判断语句;4.循环控制语句) {
    3. 循环体
}

5.0 循环结构-for【重点】

1.1 for循环【重点】

for循环结构，其实就是对while循环的一种特殊简化。在实际开发中使用非常多，必须掌握扎实。

基本语法：

for(1.初始化条件语句;2.条件判断语句; 4.循环控制语句) {
    3. 循环体
}

执行流程：【重点】

第1次：1. 初始化条件语句 => 2.条件判断语句 => 3. 循环体 => 4. 循环控制语句

第2次：2. 条件判断语句 => 3. 循环体 => 4. 循环控制语句

第3次：2. 条件判断语句 => 3. 循环体 => 4. 循环控制语句

...

最后1次： 2.条件判断语句

代码案例：

public class _05While {
public static void main(String[] args) {
	    // 请打印10句，我爱Java，Java让我快乐！
// 声明一个int类型变量count表示次数，赋值1
//	int count = 1;// 1. 初始化条件
//	while (count <= 10) {// count <= 10是 2.循环条件判断
// 打印：我爱Java，Java让我快乐！
//	System.out.println("我爱Java，Java让我快乐！ : " + count);// 3.循环体 【重复干的事】
//	count++;// 次数count+1 4.循环控制语句
//	}
// for循环就是将while循环中部分条件移动到()中
for (int count = 1; count <= 10; count++) {
		// 打印：我爱Java，Java让我快乐！
		System.out.println("我爱Java，Java让我快乐！ : " + count);// 3.循环体 【重复干的事】
	}
 }
}

注意事项：

特殊写法：
初始条件中变量的作用域

练习:

1. 输出 1-10的所有的数。
2. 输出 1-10的所有偶数。
3. 求1-10的所有偶数和。
4. 分析题
int i = 0;
for(;i++ < 10;i += 2){
System.out.println(++i);
}
System.out.println("i = " + i);
上面的代码打印的值？
循环了几次？
判断了几次？
最后i的值是多少？
5. 用for循环计算1-10的积。
6. 求1-10的阶乘和(1! + 2! + 3! + 4! + 5! +...)。
7. 求出20以内3的倍数的数字和个数。

代码实现：

public class _08For {
public static void main(String[] args) {
	// 1.输出 1-10的所有的数
	for (int i = 1; i < 11; i++) {
		System.out.println(i);
	}
		
	// 2.输出 1-10的所有偶数
	for (int i = 1; i < 11; i++) {
		if (i % 2 == 0) {
			System.out.println(i);
		}
	}
		
	// 3.求 1-10的所有偶数和
	int sum = 0;// 声明一个int类型变量，赋值0，保存和
	for (int i = 1; i < 11; i++) {
		if (i % 2 == 0) {
			sum += i;
		}
	}
	System.out.println("和：" + sum);
		
	// 4. 
	int i = 0;
	for(;i++ < 10;i += 2){
		System.out.println(++i);
	}
	System.out.println("i = " + i);
	// 上面的代码打印的值？2、6、10
	// 循环了几次？3
	// 判断了几次？4
	// 最后i的值是多少？13
		
	// 5.用for循环计算1-10的积
	int product = 1;// 声明一个int类型变量product，赋值1，表示乘积
	for (int j = 1; j < 11; j++) {
		// 将每一个数字j累乘到product中。
		product *= j;// j = 1
	}
	System.out.println("乘积：" + product);
		
	// 6.求1-10的阶乘和(1! + 2! + 3! + 4! + 5! +...)
	int product2 = 1;// 声明一个int类型变量product2，赋值1，表示乘积
	int sum2 = 0;// 声明一个int类型变量sum2，赋值0，表示和
	for (int j = 1; j < 11; j++) {
		// 将每一个数字j累乘到product中。
		product2 *= j;// product就是当前j的阶乘
		// 将每一个j的阶乘product2累加到sum2中
		sum2 += product2;
	}
	System.out.println("阶乘和：" + sum2);
		
	// 7.求出20以内3的倍数的数字和个数。
	int count = 0;// 声明一个int类型变量count，赋值0，计数个数
	for (int j = 1; j <= 20; j++) {
		// 判断j是否是3的倍数
		if (j % 3 == 0) {
			System.out.println(j);
			// 计算器+1
			count++;
		}
	}
	System.out.println("个数：" + count);
		
}
}

5.2 循环注意事项

/**
  * 循环注意事项测试：（了解）
	1. while(false){}语法错误
	2. 死循环后面不能紧跟任何代码
		while(true){}
		for(;;){}
	
	3. while(条件判断);可以不写循环体
	4. for循环
		4.1 for(){}中的条件都可以拿到外部，且可以不写{}
		4.2 for(){}死循环是第二个条件判断不写，就是死循环
		4.3 for(); 可以不写循环体
*/
public class _11ForWhile {
public static void main(String[] args) {
	//1. while(false){}语法错误
		//	while (false) {}
		
	//2. 死循环后面不能紧跟任何代码
	//	while(true){}
	//	for (;;) {}
		
	//3. while(条件判断);可以不写循环体
//	while(true);
//	for (;;);
	int i = 1;
	for (; i < 11; ) {
		System.out.println(i);
		i++;
	}
  }
}

5.3 嵌套循环【了解】

顾名思义，嵌套循环指的是循环中嵌套一个循环【其实就是外层循环的循环体是另外一个循环而已】，但最好嵌套不要超过3层，否则效率太低。

双层循环总结的规律：（当成是轮子，可以直接使用）

外层循环执行一次，内层循环执行所有次

外层循环负责行数，内层负责每一行中列数

循环可以是while、 do while、 for循环任意一种，下面以for循环举例

public class _10ForFor {
public static void main(String[] args) {
	/*
	 * 请打印如下图案：5 * 5 的星星
	 * 	*****
	 * 	*****
	 * 	*****
	 * 	*****
	 * 	*****
	 */
//	for (int i = 1; i <= 5; i++) {
//		System.out.println("*****");
//	}
	/*
	// 每次只能打印一个*
	// 第1行： *****
	for (int i = 1; i <= 5; i++) {
		// 打印一行中 的每一个 星星
		System.out.print("*");
	}
	// 换行
	System.out.println();
		
	// 第2行： *****
	for (int i = 1; i <= 5; i++) {
		// 打印一行中 的每一个 星星
		System.out.print("*");
	}
	// 换行
	System.out.println();
		
	// 第3行： *****
	for (int i = 1; i <= 5; i++) {
		// 打印一行中 的每一个 星星
		System.out.print("*");
	}
	// 换行
	System.out.println();
		
	// 第4行： *****
	for (int i = 1; i <= 5; i++) {
		// 打印一行中 的每一个 星星
		System.out.print("*");
	}
	// 换行
	System.out.println();
		
	// 第5行： *****
	for (int i = 1; i <= 5; i++) {
		// 打印一行中 的每一个 星星
		System.out.print("*");
	}
	// 换行
	System.out.println();
	用循环继续优化代码
	*/
	// 外层循环控制总行数
	for (int j = 1; j <= 5; j++) {
		// 内存for循环控制列数，负责 每一行中 列的输出： *****
		for (int i = 1; i <= 7; i++) {
			// 打印一行中 的每一个 星星
			System.out.print("*");
		}
		// 换行
		System.out.println();
	}
		
	/*
	 *	利用好总结出来的规律
	 *		外层循环执行一次，内层循环执行所有次
			外层循环负责行数，内层负责每一行中列数		
		 * 		 	行i	 列j	
		 **		    1	  1
		 ***		2	  2
		 ****		3	  3
		 *****		4	  4
		 ******	    5	  5
	 */
	for (int i = 1; i < 6; i++) {
		for (int j = 1; j <= i; j++) {
			System.out.print("*");
		}
		System.out.println();
	}		
}
}

执行流程分析图：

5.4 循环控制语句【掌握】

5.4.1 概念

对整个循环流程进行控制，可提前终止或跳出循环

5.4.2 控制语句分类【掌握】

5.4.2.1 break

作用：表示结束当前层循环

5.4.2.2 continue

作用：表示跳过当前次循环，继续下一次循环

5.4.2.3 return

作用：表示结束的当前方法

代码案例：

public class _09ForControl {
public static void main(String[] args) {
	// 1. 请打印1-200所有6的倍数中前7个
	int count = 0;// 声明一个int类型计算器count赋值0
	for (int i = 1; i <= 200; i++) {
		if (i % 6 == 0) {
			System.out.println(i);
			// 每次找到一个6的倍数计算器+1
			count++;
			// 判断当前计算器count是否==7，如果是则停止循环
			if (count == 7) {
				break;// 表示结束当前层循环
			}
		}
	}
	System.out.println("===============================");

	// continue使用跳过当前i=5这一次的打印，继续后面的打印
	for (int i = 1; i <= 10; i++) {
		if (i == 5) {
//			continue;
			return; // 表示结束的当前方法
//			int a = 1;// 在以上三个控制语句后，不能紧跟任何代码，因为永远执行不到
		}
		System.out.println(i);
	}
	System.out.println("循环外部的代码");
		
	// 2. 求1—100之间不能被3整除的数之和大于(或等于)100的第一个数字 continue/break
	int sum = 0;// 声明一个int类型变量sum，赋值0，保存和
	for (int i = 1; i <= 100; i++) {
		if (i % 3 != 0) {
			// 打印不是3的倍数的数字i
			System.out.println(i);
			// 累加到sum中
			sum += i;
			if (sum >= 100) {// 判断sum>=100的时候结束循环
				// 打印当前结束的时候i的值
				System.out.println("最后：" + i);
				break;
			}
		}
	}
	System.out.println("和：" + sum);
		
	int sum2 = 0;// 声明一个int类型变量sum2，赋值0，保存和
	for (int i = 1; i <= 100; i++) {
		// 判断当前i是否是3的倍数，如果是，则跳过这一次循环
		if (i % 3 == 0) {
			continue;
		}
		// 打印不是3的倍数的数字i
		System.out.println(i);
		// 累加到sum2中
		sum2 += i;
		if (sum2 >= 100) {// 判断sum2>=100的时候结束循环
			// 打印当前结束的时候i的值
			System.out.println("最后：" + i);
			break;
		}
	}
	System.out.println("和：" + sum2);
	
}
}