# 运算符&选择语句
**目标：**
- 能够知道每种运算符的作用及使用特点
- 能够理解+操作的三种情况
- 能够知道顺序结构语句的执行流程
- 能够使用Debug查看程序的执行流程
- 能够根据需求选择合适的if语句实现
- 能够知道switch语句执行流程和注意事项
## 1：运算符
前面我们学过了通过字面量和变量来表示一个数据，这里呢，我们来学习对数据进行运算。而对数据运算就要用到我们这里要讲解的运算符，而在讲解具体的运算符之前，我们对运算符和表达式做一个简单的描述：
**运算符：**对字面量或者变量进行操作的符号**
**表达式：**用运算符把字面量或者变量连接起来，符合java语法的式子就可以称为表达式。不同运算符连接的表达式体现的是不同类型的表达式。
举例说明：
int a = 10;
int b = 20;
int c = a + b;
### 1.1 算术运算符
Java中的算术运算符有如下5种：
了解了Java中的算术运算符之后，下面我们到IDEA中去使用一下：
```java
/*
算术运算符
*/
public class OperatorDemo {
public static void main(String[] args) {
//定义两个int类型的变量
int a = 6;
int b = 4;
System.out.println(a + b);//10
System.out.println(a - b);//2
System.out.println(a * b);//24
System.out.println(a / b);//1.5? 1
System.out.println(a % b);//2
//整数相除只能得到整数，要想得到小数，必须有浮点数的参与
System.out.println(6.0 / 4);
}
}```
### 1.2 案例数值拆分
需求：定义一个三位数，将其拆分为个位、十位、百位后，输出在控制台
什么意思呢？下面我们举例来说明一下：
举例：int number = 123；
在控制台输出结果：
个位是：3
十位是：2
百位是：1
知道了要做什么后，下面我们来分析一下如何获取个位，十位，百位：
分析：
① 个位的计算：数值 % 10
123 除以 10（商12，余数为3）
② 十位的计算：数值 / 10 % 10
123 除以 10 （商12，余数为3，整数相除只能得到整数）
12 除以 10 （商1，余数为2）
③ 百位的计算：数值 / 10 / 10 % 10
123 / 10 / 10 % 10（123 / 10 得到12，12 / 10 得到1，1 % 10 得到 1）
分析完毕之后，下面我们到IDEA中去实现一下：
```java
/*
需求：定义一个三位数，将其拆分为个位、十位、百位后，输出在控制台
*/
public class OperatorTest {
public static void main(String[] args) {
//定义一个三位数
int number = 123;
//获取个，十，百位数据
int ge = number % 10;
int shi = number / 10 % 10;
int bai = number / 100 % 10;
//输出结果
System.out.println("个位是：" + ge);
System.out.println("十位是：" + shi);
System.out.println("百位是：" + bai);
}
}```
讲解完毕后，大家赶快动手练习一下吧。
### 1.3 +操作的三种情况
#### 1.3.1 数字相加(类型转换)
在Java程序中，数据参与运算，要求类型一致。这里就涉及到了数据的类型转换。而类型转换又分为两种：
1. 隐式转换
2. 强制转换
**隐式转换：**把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量
**强制转换：**把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量
格式：数据类型 变量名 = (目标数据类型)(数值或者变量)
IDEA中代码演示如下：
```java
/*
数字相加
*/
public class OperatorDemo01 {
public static void main(String[] args) {
int a = 10;
double b = 13.14;
System.out.println(a + b);
int c = (int)(a + b);
System.out.println(c);
// double d = a + b;
short s = 10;
int i = 20;
int j = s + i;
// short ss = s + i;
short ss = (short) (s + i);
}
}```
讲解完毕后，大家赶快动手练习一下吧。
#### 1.3.2 字符相加
来，继续啊，这里我们再来说一下字符参与+操作。
先到IDEA中去讲解，然后再回来总结。
IDEA中代码演示如下：
```java
/*
字符相加
*/
public class OperatorDemo02 {
public static void main(String[] args) {
//定义两个变量
int i = 10;
char ch = 'A';//'A'的值是65
ch = 'a';//'a'的值是97
ch = '0';//'0'的值是48
System.out.println(i + ch);
}
}```
代码演示完毕后，回到资料总结：
字符参与+操作，其实就是拿字符在计算机底层对应的数值来进行计算的，这里我们了解一下英文大小写字符和数字字符对应的数据值：
- ‘A’ 65 A-Z是连续的
- ‘a’ 97 a-z是连续的
- ‘0’ 48 0-9是连续的
这里也给大家准备了一张ASCII码表，里面有常用的字符及其对应的数值关系：
#### 1.3.3 字符串相加
接下来，我们继续讲解字符串相加，先到IDEA中去讲解，然后再回来总结。
IDEA中代码演示如下：
```java
/*
字符串相加
*/
public class OperatorDemo03 {
public static void main(String[] args) {
System.out.println("it" + "heima");
System.out.println("itheima" + 666);
System.out.println(666 + "itheima");
System.out.println("itheima" + 6 + 66);
System.out.println(1 + 99 + "年itheima");
}
}```
代码演示完毕后，回到资料总结：
- 当“+”操作中出现字符串时，这个“+”是字符串连接符，而不是算术运算
- “zhongguo”+ 666
- 当连续进行“+”操作时，从左到右逐个执行
- 1 + 9999 + “岁zhongguo”
讲解完毕后，大家赶快动手练习一下吧。
### 1.4 赋值运算符
下面呢，我们来学习赋值运算符。
Java中的赋值运算符有如下6种：
了解了Java中的赋值运算符之后，下面我们到IDEA中去使用一下：
```java
/*
赋值运算符
*/
public class OperatorDemo {
public static void main(String[] args) {
int a = 10;
System.out.println("a:" + a);
// += : 把左边和右边的数据相加，最后把结果赋值给左边
// a += 20;
a = a + 20;
System.out.println("a:" + a);
//注意：扩展的赋值运算符底层隐含了强制类型转换
short s = 1;
// s += 2;
s = (short) (s + 2);
System.out.println("s:" + s);
}
}```
最后，我们来总结一下，刚才在演示代码的时候有个注意事项：
讲解完毕后，大家赶快动手练习一下吧。
## 2：选择语句
来，继续啊，为了控制程序的执行流程，Java 就提供了一些流程控制语句，我们先来举例说明一下：
**顺序结构：**从上往下，依次执行
**选择结构：**
QQ界面的登录，填写账号和密码正确，展示好友列表界面。填写账号或者密码有误，提示：你输入的账号或密码不正确。
这就是通过选择结构来实现的，实际开发中，类似这种逻辑判断的情况非常常见。
**循环结构：**
比如说，京东商城中，查询手机数据，京东就会返回给你一堆符合你查询要求的数据。
假如，每一部手机数据的展示需要5行代码，如果最终返回了1000部手机，你就需要编写5000行代码来实现数据展示。
这样就太麻烦了，那么，有没有一种流程语句，能够简化这种操作呢？答案肯定是有的，就是我们的循环结构，它就可以通过一个比较简单的结构来控制我们的手机展示1000次。
比如说，带着这样写就可以了，这就是循环结构。
### 2.1 顺序结构
**顺序结构：**是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行
**执行流程图：**
了解完顺序结构后，下面我们到IDEA中去演示一下：
```java
/*
顺序结构语句
*/
public class OrderDemo {
public static void main(String[] args) {
System.out.println("开始");
System.out.println("语句A");
System.out.println("语句B");
System.out.println("语句C");
System.out.println("结束");
}
}```
这个比较简单，也没什么好练习的。就不练了，我们继续往下学习。
### 2.2 Debug的基本使用
为了帮助大家更好的理解程序的执行流程，我们来学习Debug，那什么是Debug呢？
**Debug：**是供程序员使用的程序调试工具，它可以用于查看程序的执行流程，也可以用于追踪程序执行过程来调试程序
它的两大作用，查看程序执行流程，调试程序。由于目前我们每个程序的代码内容还比较少，
所以，今天重点掌握查看程序执行流程，当代码复杂的时候，我们需要通过debug来调试程序。那么，debug操作的流程是什么样子的呢？
在讲解操作流程前，我们来说一下：
Debug，又被称为**断点调试**，断点其实是一个标记，告诉我们从哪里开始查看
知道了Debug被称为断点调试后，我们来讲一下Debug的操作流程：
① 如何加断点
选择要设置断点的代码行，在行号的区域后面单击鼠标左键即可。如图
② 如何运行加了断点的程序
在代码区域右键Debug执行
③ 看哪里
看Debugger窗口，看Console窗口
④ 点哪里
点(Step Over F8) 开始，点(Stop)结束
⑤ 如何删除断点
选择要删除的断点，单击鼠标左键即可。也就是把第一步的动作，再做一次即可。
总结一下，Debug的使用流程：
①如何加断点：选择要设置断点的代码行，在行号的区域后面单击鼠标左键即可
②如何运行加了断点的程序：在代码区域右键Debug执行
③看哪里：看Debugger窗口，看Console窗口
④点哪里：点(Step Over F8) 开始，点(Stop)结束
⑤如何删除断点：选择要删除的断点，单击鼠标左键即可
讲解完毕后，大家赶快动手练习一下吧。
通过Debug的方式看一下，如下代码的执行流程：
```java
/*
Debug查看程序执行流程
*/
public class DebugDemo {
public static void main(String[] args) {
//定义一个int类型的变量，用来表示价格
int price = 998;
//输出变量
System.out.println(price);
//修改变量的值
price = 888;
//再次输出变量的值
System.out.println(price);
}
}```
### 2.3 选择语句之if
选择语句有两种结构：
1. if语句
2. switch语句
这里我们先来学习if语句，它会根据判定的结果（真或假）决定执行某个分支的代码
下面呢，我们通过if语句来实现过马路的信号灯判断，而if语句呢，有三种格式，这里我们首先来学习第一种格式
#### 2.3.1 if语句格式1
**格式：**
**范例：**
了解完if语句格式1之后，下面我们到IDEA中去使用一下：
```java
/*
if语句格式1
*/
public class IfDemo01 {
public static void main(String[] args) {
//定义一个变量，用来表示绿灯的状态
boolean isGreen = true;
isGreen = false;
if(isGreen) {
System.out.println("绿灯行");
}
}
}```
讲解完毕后，大家赶快动手练习一下吧。
#### 2.3.2 if语句格式2和格式3
刚才我们通过if语句格式1进行了判断，是绿灯的时候，可以通行，但是不是绿灯的时候，没有告诉我不可以通行啊。所以，这里就产生了if语句的第二种格式，先在代码中演示，再回去总结：
```java
/*
if语句格式2
*/
public class IfDemo02 {
public static void main(String[] args) {
//定义一个变量，用来表示绿灯的状态
boolean isGreen = true;
isGreen = false;
if (isGreen) {
System.out.println("绿灯行");
} else {
System.out.println("不是绿灯，不允许行使");
}
}
}```
演示完毕后，我们来说一下，if语句格式2：
**格式：**
**范例：**
**执行流程：**
讲解完if语句格式2之后，我们到IDEA中再去看一段代码：
```java
public class IfDemo03 {
public static void main(String[] args) {
//定义三个变量，表示交通信号灯的三种状态
boolean isRed = true;
boolean isGreen = true;
boolean isYellow = true;
if (isRed) {
System.out.println("红灯停");
}
if (isGreen) {
System.out.println("绿灯行");
}
if (isYellow) {
System.out.println("黄灯亮了等一等");
}
}
}```
很明显，这是不合理的，因为我们把三种状态都设置为true了，而实际生活中，只会有一种状态为true，怎么解决呢多种情况的判断呢？这个时候就产生了if语句的第三种格式，先在代码中演示，再回去总结：
```java
/*
if语句格式3
*/
public class IfDemo03 {
public static void main(String[] args) {
//定义三个变量，表示交通信号灯的三种状态
boolean isRed = true;
boolean isGreen = true;
boolean isYellow = true;
//红灯
// isGreen = false;
// isYellow = false;
//绿灯
// isRed = false;
// isYellow = false;
//黄灯
// isRed = false;
// isGreen = false;
//出现了故障，信号灯都不亮了
isRed = false;
isGreen = false;
isYellow = false;
if(isRed) {
System.out.println("红灯停");
}else if(isGreen) {
System.out.println("绿灯行");
}else if(isYellow) {
System.out.println("黄灯亮了等一等");
} else {
System.out.println("交通信号灯故障，请在保证安全的情况下通行");
}
}
}```
演示完毕后，我们来说一下，if语句格式3：
if语句格式3：
**格式：**
**执行流程：**
讲解完毕后，大家赶快动手练习一下吧。
#### 2.3.3 案例1(交通信号灯)
需求：交通信号灯由红灯、绿灯、黄灯组成，请通过程序实现不同的信号灯给出不同的提示。
提示信息：红灯停、绿灯行、黄灯亮了等一等
首先，我们来简单的分析一下：
**分析：**
① 用哪种类型来表示信号灯的三种状态呢？
用int类型来表示信号灯的三种状态(1表示红灯，2表示绿灯，3表示黄灯)
② 用if语句的哪种格式来实现该需求呢？
一般来说：1种情况的判断用if格式1,2种情况的判断用if格式2，多种情况的判断用if格式3
③ if语句判断的表达式该怎么写呢？
int light = 1;
if(light == 1) {…}
==：是关系运算符，用来判断两个数据是否相等，如果相等，结果为true，否则为false
分析完毕后，我们来说一下实现步骤：
**实现步骤：**
① 定义一个int类型的变量用来表示信号灯的状态(1表示红灯，2表示绿灯，3表示黄灯)
② 用if语句格式3进行多种情况的判断
③ 根据不同的情况给出不同的提示信息
知道了实现步骤，下面我们到IDEA中去实现一下：
```java
/*
需求：交通信号灯由红灯、绿灯、黄灯组成，请通过程序实现不同的信号灯给出不同的提示。
提示信息：红灯停、绿灯行、黄灯亮了等一等
*/
public class IfTest01 {
public static void main(String[] args) {
//1:定义一个int类型的变量用来表示信号灯的状态(1表示红灯，2表示绿灯，3表示黄灯)
int light = 1;
light = 2;
light = 3;
light = 4;
//2:用if语句格式3进行多种情况的判断
//3:根据不同的情况给出不同的提示信息
if (light == 1) {
System.out.println("红灯停");
} else if (light == 2) {
System.out.println("绿灯行");
} else if (light == 3) {
System.out.println("黄灯亮了等一等");
} else {
System.out.println("交通信号灯故障，请在保证安全的情况下通行");
}
}
}```
讲解完毕后，大家赶快动手练习一下吧。
#### 2.3.4 关系运算符
Java中的关系运算符有如下几种：
了解了Java中的关系运算符之后，下面我们到IDEA中去使用一下：
```java
/*
关系运算符
*/
public class OperatorDemo01 {
public static void main(String[] args) {
//定义三个int类型的变量
int i = 10;
int j = 20;
int k = 10;
//等于：==
System.out.println(i == j);//false
System.out.println(i == k);//true
System.out.println("--------");
//不等于：!=
System.out.println(i != j);//true
System.out.println(i != k);//false
System.out.println("--------");
//大于：>
System.out.println(i > j);//false
System.out.println(i > k);//false
System.out.println("--------");
//大于等于：>=
System.out.println(i >= j);//false
System.out.println(i >= k);//true
System.out.println("--------");
//千万不要把==写成了=
System.out.println(i = j); //20
}
}```
#### 2.3.5 案例2(奇偶数)
需求：给定一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该整数是奇数还是偶数
提示：偶数是能够被2整除的整数
首先，我们来简单的分析一下：
**分析：**
① 如何判断一个整数是奇数还是偶数？
整数对2进行取余，余数为0是偶数，否则为奇数
② 用if语句的哪种格式来实现该需求呢？
该整数要么是偶数，要么是奇数，2种情况，所以用if语句格式2
分析完毕后，我们来说一下实现步骤：
**实现步骤：**
① 定义一个int类型的整数
② 用if语句格式2进行判断
③ 根据是否是偶数给出不同的提示信息
知道了实现步骤，下面我们到IDEA中去实现一下：
```java
/*
需求：给定一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该整数是奇数还是偶数
*/
public class IfTest02 {
public static void main(String[] args) {
//1:定义一个int类型的整数
int number = 10;
number = 9;
//2:用if语句格式2进行判断
//3:根据是否是偶数给出不同的提示信息
if (number % 2 == 0) {
System.out.println(number + "是偶数");
} else {
System.out.println(number + "是奇数");
}
}
}```
讲解完毕后，大家赶快动手练习一下吧。
#### 2.3.6 案例3(手机以旧换新)
需求：张三想买一台7988元的新手机，他的旧手机在二手市场能卖1500元，而手机专卖店推出以旧换新优惠，把他旧手机交给店家，新手机就能够打8折优惠。
为了更省钱，要不要以旧换新？请通过程序告诉张三
首先，我们来简单的分析一下：
**分析：**
① 计算不使用以旧换新的花费
7988 - 1500
② 计算使用以旧换新的花费
7988 * 0.8
③ 用if语句的哪种格式来实现该需求呢？
if语句格式2
分析完毕后，我们来说一下实现步骤：
**实现步骤：**
① 定义变量(money1)纪录不使用以旧换新的花费
② 定义变量(money2)纪录使用以旧换新的花费
③ 用if语句格式2进行判断 money1是否大于money2
④ 根据判断结果，给出相应的提示
知道了实现步骤，下面我们到IDEA中去实现一下：
```java
/*
需求：张三想买一台7988元的新手机，他的旧手机在二手市场能卖1500元，而手机专卖店推出以旧换新优惠，
把他的旧手机交给店家，新手机就能够打8折优惠。为了更省钱，要不要以旧换新？请通过程序告诉张三
*/
public class IfTest03 {
public static void main(String[] args) {
//1:定义变量(money1)纪录不使用以旧换新的花费
int money1 = 7988 - 1500;
//2:定义变量(money2)纪录使用以旧换新的花费
double money2 = 7988 * 0.8;
//3:用if语句格式2进行判断 money1是否大于money2
//4:根据判断结果，给出相应的提示
if (money1 > money2) {
System.out.println("使用以旧换新更省钱");
} else {
System.out.println("不使用以旧换新更省钱");
}
}
}
```
讲解完毕后，大家赶快动手练习一下吧。
#### 2.3.7 案例4(你是青年人吗)
需求：给出你的年龄，通过程序判断你是否属于青年人？
提示：世界卫生组织，经过对全球人体素质和平均寿命进行测定，对年龄划分标准作出了新的规定
首先，我们来简单的分析一下：
**分析：**
① 如何判断一个年龄是否属于青年人？
年龄要大于等于18，并且小于等于65
② 在Java中如何表示并且的关系呢？
age >=18 && age<=65
**<font color='red'>&&</font>：是逻辑运算符，用来连接两个结果为boolean类型的表达式，都为true，结果为true，否则为false**
分析完毕后，我们来说一下实现步骤：
**实现步骤：**
① 定义一个int类型的变量来表示你的年龄
② 用if语句格式2进行判断看你是否属于青年人
③ 根据是否是青年人给出不同的提示信息
知道了实现步骤，下面我们到IDEA中去实现一下：
```java
/*
需求：给出你的年龄，通过程序判断你是否属于青年人？
提示：青年人的年龄范围 18~65
*/
public class IfTest04 {
public static void main(String[] args) {
//1:定义一个int类型的变量来表示你的年龄
int age = 22;
age = 100;
//2:用if语句格式2进行判断看你是否属于青年人
//3:根据是否是青年人给出不同的提示信息
if(age>=18 && age<=65) {
System.out.println("你是青年人");
} else {
System.out.println("你不是青年人");
}
}
}```
讲解完毕后，大家赶快动手练习一下吧。
#### 2.3.8 逻辑运算符
Java中常用的逻辑运算符有如下几种：
了解了Java中的逻辑运算符之后，下面我们到IDEA中去使用一下：
```java
/*
逻辑运算符
*/
public class OperatorDemo02 {
public static void main(String[] args) {
//定义变量
int i = 10;
int j = 20;
int k = 30;
//逻辑与：&&
System.out.println((i>j) && (i>k));//false && false
System.out.println((i<j) && (i>k));//true && false
System.out.println((i>j) && (i<k));//false && true
System.out.println((i<j) && (i<k));//true && true
System.out.println("-----------------------");
//逻辑或：||
System.out.println((i>j) || (i>k));//false || false
System.out.println((i<j) || (i>k));//true || false
System.out.println((i>j) || (i<k));//false || true
System.out.println((i<j) || (i<k));//true || true
System.out.println("-----------------------");
//逻辑非：!
System.out.println(!(i>j));//!false
System.out.println(!!(i>j));//!!false
System.out.println(!!!(i>j));//!!!false
System.out.println(!!!!(i>j));//!!!!false
}
}```
讲解完毕后，大家赶快动手练习一下吧。
#### 2.3.9 三元运算符
来，继续啊，下面我们来学习三元运算符：
**格式：**关系表达式 ？表达式1 ：表达式2；
**范例：**a > b ? a : b;
**执行流程：**
- 首先计算关系表达式的值
- 如果值为true，表达式1的值就是运算结果
如果值为false，表达式2的值就是运算结果
了解了三元运算符的执行流程后，下面我们到IDEA中去使用一下：
```java
/*
三元运算符
*/
public class OperatorDemo03 {
public static void main(String[] args) {
int a = 10;
int b = 20;
int max = a > b ? a : b;
System.out.println("较大的值是：" + max);
}
}
```
讲解完毕后，大家赶快动手练习一下吧。
#### 2.3.10 三元运算符和if语句格式2的区别
这里呢，我们来讲解一下三元运算符和if语句格式2的区别，它们有什么区别呢？我们先到IDEA中进行讲解，然后再回来总结：
```java
/*
三元运算符和if语句格式2的区别
*/
public class OperatorTest {
public static void main(String[] args) {
//定义两个int类型的变量
int a = 10;
int b = 20;
//需求：获取两个数中的较大值
//if语句实现
// int max;
// if (a > b) {
// max = a;
// } else {
// max = b;
// }
// System.out.println("较大的值是：" + max);
if(a > b) {
System.out.println("较大的值是：" + a);
}else {
System.out.println("较大的值是：" + b);
}
//三元运算符实现
int max = a > b? a: b;
System.out.println("较大的值是：" + max);
}
}
```
讲解完毕之后，回来总结一下：
- 如果if语句控制的内容：是用变量纪录数据值，可以通过三元运算符改进
- 如果if语句控制的内容是：是通过输出语句直接输出数据值，无法通过三元运算符改进
好了，关于三元运算符和if语句格式2的区别我们就讲到这里。这个知识大家先了解一下，方便我们后面在适合的场景选择合适的实现方案。
### 2.4 选择语句之switch
来，继续啊，下面我们来学习选择语句中的switch语句。
**格式：**
**格式说明：**
**执行流程：**
了解完switch语句后，下面我们到IDEA中去使用一下：
```java
/*
switch语句
*/
public class SwitchDemo {
public static void main(String[] args) {
//定义一个int类型的变量用来表示信号灯的状态(1表示红灯，2表示绿灯，3表示黄灯)
int light = 1;
// light = 2;
// light = 3;
// light = 4;
//用switch语句实现交通信号灯案例
switch (light) {
case 1:
System.out.println("红灯停");
break;
case 2:
System.out.println("绿灯行");
break;
case 3:
System.out.println("黄灯亮了等一等");
break;
default:
System.out.println("交通信号灯故障，请在保证安全的情况下通行");
break;
}
}
}```
最后，我们来总结一下，刚才在演示代码的时候有个注意事项：
**注意：**在switch语句中，如果case控制的语句体后面不写break，将出现穿透现象，在不判断下一个case值的情况下，向下运行，直到遇到break，或者整个switch语句结束
# 循环语句
**目标：**
- 能够理解循环语句的四个组成部分
- 能够知道三种循环的各自格式和执行流程
- 能够知道三种循环的区别
- 能够使用循环语句完成今日案例
- 能够知道跳转语句的使用场景
## 1：for循环结构
来，继续啊，下面我们来学习循环结构语句，循环结构有三种语句，分别是：
1. for循环
2. while循环
3. do…while循环
这三种循环可以做相同的事情，当然它们也有小的区别，至于它们的应用及区别，我们后面会详细讲解。这里我们来学习for循环
### 1.1 for循环结构
for循环语句是由这几部分组成。
**格式：**
**格式说明：**
- 初始化语句：这里可以是一条或者多条语句，这些语句用来完成初始化操作**(int i=1)**
- 条件判断语句：这里使用一个结果值为boolean类型的表达式，这个表达式能决定是否执行循环体语句**(i<=1000)**
- 循环体语句：这里可以是任意语句
- 条件控制语句：这里通常是使用一条语句来改变变量的值，从而达到控制循环是否继续向下执行的效果
**范例：**
**执行流程：**
知道了for循环的格式和执行流程后，下面我们到IDEA中去演示一下：
```java
/*
for循环结构
*/
public class ForDemo {
public static void main(String[] args) {
for(int i=1; i<=5; i+=1) {
System.out.println("HelloWorld");
}
}
}
```
代码演示后，通过Debug查看了一下程序的执行流程，让我们更清晰for循环的执行流程。
讲解完毕后，大家赶快动手练习一下吧。
### 1.2 案例1(输出数据)
需求：在控制台输出1-5的数据
首先，我们来简单的分析一下：
**分析：**
① 反复进行输出的动作，使用循环结构
② 从1开始到5结束，设置初始化从1开始
③ 从1开始到5结束，设置判断条件为没有到5的时候继续执行，执行到超过5程序结束
④ 从1到5，每次增加1，设置条件控制每次+1
⑤ 将反复进行的事情写入循环结构内部，打印对应数据
分析完毕之后，我们到IDEA中去实现一下：
```java
/*
需求：在控制台输出1-5的数据
*/
public class ForTest01 {
public static void main(String[] args) {
System.out.println(1);
System.out.println(2);
System.out.println(3);
System.out.println(4);
System.out.println(5);
System.out.println("--------------");
for (int i = 1; i <= 5; i += 1) {
System.out.println(i);
}
System.out.println("--------------");
for (int i = 1; i <= 5; i += 2) {
System.out.println(i);
}
System.out.println("--------------");
//自增运算符：++
//它跟在变量的后面表示变量的值+1
for (int i = 1; i <= 5; i++) {
System.out.println(i);
}
System.out.println("--------------");
for (int i = 1; i <= 5; i++,i++) {
System.out.println(i);
}
System.out.println("--------------");
//我要获取数据5-1该怎么办呢？
for (int i=5; i>=1; i-=1) {
System.out.println(i);
}
System.out.println("--------------");
for (int i=5; i>=1; i--) {
System.out.println(i);
}
}
}
```
在讲解的过程中，我们还提出了自增运算符：++和自减运算符：--，并且演示了如何获取数据5-1。
讲解完毕后，大家赶快动手练习一下吧。
### 1.3 案例2(求和思想)
需求：求1-5之间的数据和，并把求和结果在控制台输出
首先，我们先到IDEA中去实现一下，然后再回来总结。
```java
/*
需求：求1-5之间的数据和，并把求和结果在控制台输出
*/
public class ForTest02 {
public static void main(String[] args) {
//定义一个求和变量，用于保存求和的结果
int sum = 0;
//我们通过for循环实现获取数据1-5
for (int i=1; i<=5; i++) {
//i,1,2,3,4,5
// sum = sum + i;
sum += i;
/*
第一次求和：sum = sum + i = 0 + 1 = 1
第二次求和：sum = sum + i = 1 + 2 = 3
第三次求和：sum = sum + i = 3 + 3 = 6
第四次求和：sum = sum + i = 6 + 4 = 10
第五次求和：sum = sum + i = 10 + 5 = 15
*/
}
//输出结果
System.out.println("1-5的求和结果是：" + sum);
}
}
```
最后，我们来总结一下求和思想的实现步骤：
**实现步骤：**
① 求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
② 从1开始到5结束的数据，使用循环结构完成
③ 将反复进行的事情写入循环结构内部
此处反复进行的事情是将数据 i 加到用于保存最终求和的变量 sum 中
④ 当循环执行完毕时，将最终数据打印出来
讲解完毕后，大家赶快动手练习一下吧。
### 1.4 案例3(求偶数和)
需求：求1-100之间的偶数和，并把求和结果在控制台输出
首先，我们来简单的分析一下：
**分析：**
① 对1-100的数据求和与1-5的数据求和几乎完全一样，仅仅是结束条件不同
② 对1-100的偶数求和，需要对求和操作添加限制条件
③ 限制条件是偶数才参与运算，因此条件应该是判断是否是偶数
④ 当循环执行完毕时，将最终数据打印出来
分析完毕之后，我们到IDEA中去实现一下：
```java
/*
需求：求1-100之间的偶数和，并把求和结果在控制台输出
*/
public class ForTest03 {
public static void main(String[] args) {
//1:求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
int sum = 0;
//2:对1-100的数据求和与1-5的数据求和几乎完全一样，仅仅是结束条件不同
for (int i=1; i<=100; i++) {
//3:对1-100的偶数求和，需要对求和操作添加限制条件，判断是否是偶数
if(i % 2 == 0) {
sum += i;
}
}
//4:当循环执行完毕时，将最终数据打印出来
System.out.println("1-100之间的偶数和是：" + sum);
}
}
```
讲解完毕后，大家赶快动手练习一下吧。
### 1.5 案例4(水仙花数)
需求：在控制台输出所有的“水仙花数”
看到这个需求，我们首先要解决的问题就是，什么样的数据是“水仙花数”？它满足如下两个条件：
① 水仙花数是一个三位数
比如：111 222 333 370 371 520 999
② 水仙花数的个位、十位、百位的数字立方和等于原数
比如：
知道了什么是水仙花数后，我们再来回顾一下如何获取一个数据的个位，十位，百位：
假设一个三位数为x，则
- 个位：x%10
- 十位：x/10%10
- 百位：x/100%10
了解了水仙花数相关的基础知识后，下面我们来说一下这个案例的实现步骤：
**实现步骤：**
① 获取三位数，通过循环实现
② 获取每一个三位数的个位，十位，百位
③ 判断该三位数是否是水仙花数
④ 输出水仙花数
知道了实现步骤，下面我们到IDEA中去实现一下：
```java
/*
需求：在控制台输出所有的“水仙花数”
*/
public class ForTest04 {
public static void main(String[] args) {
//1:获取三位数，通过循环实现
// for (int i=100; i<=999; i++) {
//
// }
for (int i = 100; i < 1000; i++) {
//2:获取每一个三位数的个位，十位，百位
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 100 % 10;
//3:判断该三位数是否是水仙花数
if ((ge * ge * ge + shi * shi * shi + bai * bai * bai) == i) {
//4:输出水仙花数
System.out.println(i);
}
}
}
}
```
讲解完毕后，大家赶快动手练习一下吧。
### 1.6 案例5(统计思想)
需求：统计“水仙花数”一共有多少个，并在控制台输出个数
首先，我们先到IDEA中去实现一下，然后再回来总结。
```java
/*
需求：统计“水仙花数”一共有多少个，并在控制台输出个数
*/
public class ForTest05 {
public static void main(String[] args) {
//定义一个统计变量，用于数据的统计，初始化值为0
int count = 0;
for (int i = 100; i < 1000; i++) {
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 100 % 10;
if ((ge * ge * ge + shi * shi * shi + bai * bai * bai) == i) {
// System.out.println(i);
//1,2,3,...
count++;
}
}
//输出水仙花的个数
System.out.println("水仙花数一共有：" + count + "个");
}
}
```
最后，我们来总结一下统计思想的实现步骤：
**实现步骤：**
① 定义统计变量count，初始化值为0
② 在判定水仙花数的过程中，满足条件不再输出，更改为修改count的值，使count+1
③ 输出统计变量的值
讲解完毕后，大家赶快动手练习一下吧。
### 1.7 案例6(回文数)
需求：输出所有五位数的回文数
看到这个需求，我们首先要解决的问题就是，什么样的数据是“回文数”？
那什么是“回文数”呢？一个数，无论是从左往右读,还是从右往左读，读起来都相同的数,叫做“回文数”
举例：
10101，12321：是回文数
12345：不是回文数
规律：
个位 = 万位
十位 = 千位
和百位无关
了解了回文数相关的基础知识后，我们来说一下这个案例的实现步骤：
**实现步骤：**
① 获取五位数，通过循环实现
② 获取每一个五位数的个位，十位，千位，万位
③ 判断该五位数是否是回文数
④ 输出回文数
知道了实现步骤，下面我们到IDEA中去实现一下：
```java
/*
需求：输出所有五位数的回文数
*/
public class ForTest06 {
public static void main(String[] args) {
//1:获取五位数，通过循环实现
for (int i = 10000; i < 100000; i++) {
//2:获取每一个五位数的个位，十位，千位，万位
int ge = i % 10;
int shi = i / 10 % 10;
int qian = i / 1000 % 10;
int wan = i / 10000 % 10;
//3:判断该五位数是否是回文数
if ((ge == wan) && (shi == qian)) {
//4:输出回文数
System.out.println(i);
}
}
//练习：统计五位数的回文数个数，并在控制台输出个数
}
}
```
在案例的最后，我们留下了一个练习，大家记得完成哦。
讲解完毕后，大家赶快动手练习一下吧。
### 1.8 案例7(逢七过)
需求：朋友聚会的时候可能会玩一个游戏：逢七过。
规则是：从任意一个数字开始报数，当你要报的数字包含7或者是7的倍数时都要说：过。
为了帮助大家更好的玩这个游戏，这里我们直接在控制台打印出1-100之间的满足逢七必过规则的数据。
这样，大家将来在玩游戏的时候，就知道哪些数据要说：过。
首先，我们来简单的分析一下：
**分析：**
① 数据的范围1-100之间，用循环很容易实现
② 要满足的条件是：数字包含7(个位是7，或者十位是7)，或者是7的倍数
假如有一个数据：x
判断个位为7：x%10 == 7
判断十位为7：x/10%10 == 7
判断是7的倍数：x%7 == 0
分析完毕后，我们来说一下实现步骤：
**实现步骤：**
① 获取1-100之间的数据，通过循环实现
② 判断数字包含7或者是7的倍数
判断数据：要么个位是7，要么十位是7，要么能够被7整除
③ 在控制台输出满足条件的数据
知道了实现步骤，下面我们到IDEA中去实现一下：
```java
/*
需求：朋友聚会的时候可能会玩一个游戏：逢七过。
*/
public class ForTest07 {
public static void main(String[] args) {
//1:获取1-100之间的数据，通过循环实现
for (int i = 1; i <= 100; i++) {
//2:判断数字包含7或者是7的倍数(判断数据：要么个位是7，要么十位是7，要么能够被7整除)
if ((i % 10 == 7) || (i / 10 % 10 == 7) || (i % 7 == 0)) {
//3:在控制台输出满足条件的数据
System.out.println(i);
}
}
}
}
```
讲解完毕后，大家赶快动手练习一下吧。
## 2：while循环结构
### 2.1 while循环结构
接下来，我们学习while循环结构语句
**格式：**
**范例：**
知道了while循环的格式后，下面我们到IDEA中去演示一下：
```java
/*
while循环结构
*/
public class WhileDemo {
public static void main(String[] args) {
int i = 1;
while (i<=5) {
System.out.println("HelloWorld");
i++;
}
}
}
```
代码演示后，通过Debug查看了一下程序的执行流程，让我们更清晰while循环的执行流程。
最后，我们再来总结一下while循环的执行流程：
**执行流程：**
讲解完毕后，大家赶快动手练习一下吧。
### 2.2 案例1(求奇数和)
需求：求1-100之间的奇数和，并把求和结果在控制台输出
首先，我们来简单的分析一下：
**分析：**
① 对1-100的奇数求和，和前面讲解的偶数求和几乎是完全一样，仅仅是判断条件不同
② 判断条件是奇数才参与运算，因此条件应该是判断是否是奇数
③ 当循环执行完毕时，将最终数据打印出来
分析完毕之后，我们到IDEA中去实现一下：
```java
/*
需求：求1-100之间的奇数和，并把求和结果在控制台输出
*/
public class WhileTest01 {
public static void main(String[] args) {
//定义求和变量，初始化值为0
int sum = 0;
//获取1-100之间的数据
// int i = 1;
// while (i<=100) {
// //判断数据是否是奇数
if(i%2 != 0) {
sum += i;
}
//
// if(i%2 == 1) {
// sum += i;
// }
//
// i++;
// }
int i = 1;
while (i <= 100) {
sum += i;
i += 2; //1,3,5,7...99,101
}
//输出结果
System.out.println("1-100之间的奇数和是：" + sum);
}
}
```
讲解完毕后，大家赶快动手练习一下吧。
### 2.3 案例2(珠穆朗玛峰)
需求：世界最高峰珠穆朗玛峰(8848.86m)，我现在有一张足够大的纸张，厚度为：0.001m。请问，我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度?
首先，我们来简单的分析一下：
**分析：**
① 因为要反复折叠，所以要使用循环，该选for循环还是while循环呢？
<font color='red'>**小技巧：循环次数明确，使用for循环；循环次数不明确，使用while循环**</font>
这里不知道折叠多少次，这种情况下更适合使用while循环
② 纸张每折叠一次，厚度加倍，因此要先定义纸张厚度，在循环中使厚度加倍
③ 什么时候就停止折叠了呢？直到纸张的厚度大于等于珠峰的高度，反言之，就要折叠
④ 要求的是统计折叠次数，所以会用到统计思想
分析完毕后，我们来说一下实现步骤：
**实现步骤：**
① 定义统计变量，初始化值为0
② 定义纸张厚度变量和珠峰高度变量
③ 用while循环实现反复折叠，判断条件是纸张厚度小于珠峰高度
④ 循环体中要做两件事情：一是纸张厚度加倍，二是统计变量+1
⑤ 当循环结束，输出统计变量的值
知道了实现步骤，下面我们到IDEA中去实现一下：
```java
/*
需求：世界最高峰珠穆朗玛峰(8848.86m)，我现在有一张足够大的纸张，厚度为：0.001m。
请问，我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度?
*/
public class WhileTest02 {
public static void main(String[] args) {
//1:定义统计变量，初始化值为0
int count = 0;
//2:定义纸张厚度变量和珠峰高度变量
double paper = 0.001;
double zf = 8848.86;
//3:用while循环实现反复折叠，判断条件是纸张厚度小于珠峰高度
while (paper < zf) {
//4:循环体中要做两件事情：一是纸张厚度加倍，二是统计变量+1
paper *= 2;
count++;
}
//5:当循环结束，输出统计变量的值
System.out.println("要折叠" + count + "次");
}
}
```
讲解完毕后，大家赶快动手练习一下吧。
## 3：do-while循环结构
### 3.1 do-while循环结构
接下来，我们学习do-while循环结构语句
**格式：**
**范例：**
知道了do-while循环的格式后，下面我们到IDEA中去演示一下：
```java
/*
do...while循环结构
*/
public class DoWhileDemo {
public static void main(String[] args) {
int i = 1;
do {
System.out.println("HelloWorld");
i++;
} while (i<=5);
}
}
```
代码演示后，通过Debug查看了一下程序的执行流程，让我们更清晰do-while循环的执行流程。
最后，我们再来总结一下do-while循环的执行流程：
**执行流程：**
讲解完毕后，大家赶快动手练习一下吧。
### 3.2 三种循环的区别
前面我们讲解了三种循环语句的格式和执行流程，下面我们来讲解这三种循环语句的区别。
而关于这三种循环语句的区别，我们先到IDEA中去讲解，然后再回来总结：
```java
/*
三种循环的区别
*/
public class LoopTest {
public static void main(String[] args) {
// //for循环
// for (int i = 3; i < 3; i++) {
// System.out.println("我爱Java");
// }
// System.out.println("--------");
//
// //while循环
// int j = 3;
// while (j < 3) {
// System.out.println("我爱Java");
// j++;
// }
// System.out.println("--------");
//
// //do...while循环
// int k = 3;
// do {
// System.out.println("我爱Java");
// k++;
// } while (k < 3);
// //for循环
// for (int i = 1; i < 3; i++) {
// System.out.println("我爱Java");
// }
System.out.println(i);
// System.out.println("--------");
//
// //while循环
// int j = 1;
// while (j < 3) {
// System.out.println("我爱Java");
// j++;
// }
// System.out.println(j);
// System.out.println("--------");
//死循环
// for (;;) {
// System.out.println("for...");
// }
// while (true) {
// System.out.println("while...");
// }
do {
System.out.println("do...while...");
} while (true);
}
}
```
讲解完毕后，回到资料，我们总结一下：
**三种循环语句的区别：**
for循环和while循环<font color='red'>**先判断条件是否成立**</font>，然后决定是否执行循环体（先判断后执行）
do...while循环<font color='red'>**先执行一次循环体**</font>，然后判断条件是否成立，是否继续执行循环体（先执行后判断）
**for和while的区别：**
条件控制语句所控制的自增变量，在for循环结束后，就<font color='red'>**不可以继续使用**</font>了
条件控制语句所控制的自增变量，在while循环结束后，<font color='red'>**还可以继续使用**</font>
**死循环格式：**
for(;;){}
<font color='red'>**while(true) {}**</font>
do{}while(true);
由于循环语句的区别，只是大家需要理解的知识点，故这里不需要练习，我们在后面的使用中，在慢慢体会即可。
## 4：continue和break
### 4.1 continue和break
来，继续啊，下面我们来学习跳转控制语句，为了讲解跳转控制语句，这里我们给出几个场景看一看：
场景一：周一到周五上班，周六日不上班
场景二：成人后一直工作到60岁，60岁之后就可以退休养老了
刚才的场景中，重点介绍了两个跳转关键字：
- **continue** 用在循环中，基于条件控制，跳过某次循环体内容的执行，继续下一次的执行
- **break** 用在循环中，基于条件控制，终止循环体内容的执行，也就是说结束当前的整个循环
了解了这两个跳转关键字之后，下面我们到IDEA中去体验一下：
```java
/*
continue:用在循环中，基于条件控制，跳过某次循环体内容的执行，继续下一次的执行
break:用在循环中，基于条件控制，终止循环体内容的执行，也就是说结束当前的整个循环
*/
public class ControlDemo {
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
if (i % 2 == 0) {
// continue;
break;
}
System.out.println(i);
}
}
}
```
讲解完毕后，大家赶快动手练习一下吧。
### 4.2 综合案例(小芳存钱)
需求：小芳的妈妈每天给她2.5元钱，她都会存起来，但是，每当这一天是存钱的第5天或者5的倍数的话，
她都会花去6元钱，请问，经过多少天，小芳才可以存到100元钱。
关于这个案例呢，我们到IDEA中一边分析，一边实现：
```java
/*
需求：小芳的妈妈每天给她2.5元钱，她都会存起来，但是，每当这一天是存钱的第5天或者5的倍数的话，她都会花去6元钱，请问，经过多少天，小芳才可以存到100元钱。
*/
public class ControlTest {
public static void main(String[] args) {
//小芳的妈妈每天给她2.5元钱
double dayMoney = 2.5;
//她都会存起来，涉及到了求和思想，定义求和变量，初始化值为0
double sumMoney = 0;
//存到100元钱
int result = 100;
//定义一个统计变量，用来纪录存钱的天数，初始化值为1
int dayCount = 1;
//因为不知道要多少天才能够存到100元，所以，这里我们采用死循环来实现，当存到100元的时候，通过break跳转语句让循环结束
while (true) {
//存钱
sumMoney += dayMoney;
//判断存的钱是否大于等于100了，如果是，就退出循环
if(sumMoney >= result) {
break;
}
//每当这一天是存钱的第5天或者5的倍数的话，她都会花去6元钱
if(dayCount%5 == 0) {
sumMoney -= 6;
System.out.println("第" + dayCount + "天花了6元");
}
dayCount++;
}
//输出统计天数的变量
System.out.println("共花了" + dayCount + "天存了100元");
}
}
```
讲解完毕后，大家赶快动手练习一下吧。
扫一扫
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
