【Java】流程控制 - 顺序结构、 选择（分支）结构(单分支、双分支、多分支、嵌套)、循环结构（for、while、do...while)、跳转语句（break、continue）
流程控制语句结构
文章目录
流程控制语句结构分为：
1、顺序结构：从上到下依次执行，顺序执行。
2、分支结构：多个分支选择其中一个分支执行，就是根据选择不同，执行不同的代码。if…else和switch…case
3、循环结构：重复执行某些代码，是根据条件循环重复执行某段代码。for（普通for和增强for）、while和do…while三种
顺序 分支选择 循环
一、 顺序结构
执行过程：从上到下顺序执行
（在同一个方法中）从上往下执行
1、 输出语句
1、System.out.print(输出内容); #输出内容后不换行
2、System.out.println(输出内容); #输出内容后换行
public class Test01_order {
public static void main(String[] args) {
// 输出常量
System.out.print(1);
System.out.print('菜');
System.out.print(2.0);
System.out.print(true);
System.out.print("菜鸡文");
System.out.println(false);
//1菜2.0true菜鸡文false
// 输出变量
int a = 1;
boolean b = true;
char c = '牛';
double d = 3.14;
String school = "菜鸟文大学";
System.out.print(a);
System.out.print(c);
System.out.print(d);
System.out.print(b);
System.out.print(school);
System.out.println();
//1牛3.14true菜鸟文大学
// 输出拼接结果
System.out.print("a = " + a);
System.out.print("c = " + c);
System.out.print("d = " + d);
System.out.print("b = " + b);
System.out.print("school = " + school);
//a = 1c = 牛d = 3.14b = trueschool = 菜鸟文大学
}
}
2、 输入语句
键盘输入代码的三个步骤：
1、准备Scanner类型的变量
2、提示输入xx
3、接收输入内容
示例代码：
//1、准备Scanner类型的变量
java.util.Scanner input = new java.util.Scanner(System.in);//System.in默认代表键盘输入
//2、提示输入xx
System.out.print("请输入一个整数：");
//3、接收输入内容
int num = input.nextInt();
//列出各种数据类型的输入
int num = input.nextInt();
long bigNum = input.nextLong();
double d = input.nextDouble();
boolean b = input.nextBoolean();
String s = input.next();
char c = input.next().charAt(0);//先按照字符串接收，然后再取字符串的第一个字符（下标为0）
3、code
Statement
顺序、选择、循环
class Test01_Statement{
public static void main(String[] args){
int a = 10;
// a;//Error:(22, 9) java: 不是语句
//a;//没有意义，什么也没干
//你这干了什么吗 有啥意义 要有事做
//a>0?true:false;//这个表达式算完后，没有做具体的事情，例如：打印还是赋值等这些事情
System.out.println("a = " + a);
if(a%2==0){
System.out.println(a+"是偶数");
}else{
System.out.println(a+"是奇数");
}
for(int i=1; i<=5; i++){
System.out.println("柳江雪老师真漂亮！");
System.out.println("超级喜欢你呢！");
}
}
}
/*
一、顺序结构
整个程序总体来说都是顺序执行的，从main()主方法开始，顺序往下走
比较有代表性：输入和输出
1、输出语句
System.out.println(xx); //输出xx之后换行
System.out.print(xx);//输出xx之后不换行
2、输入语句
步骤：
（1）准备一个数据的扫描仪（对象），指定数据的来源
java.util.Scanner input = new java.util.Scanner(System.in);
回忆：
数据类型 变量名 = 值;
*/
class Test02_Order{
public static void main(String[] args){
/*
（1）java.util.Scanner：是一个扫描仪的类型，是引用数据类型，首字母是大写
其中java.util是包
（2）input是一个变量名，它代表这个扫描仪
（3）new java.util.Scanner(System.in)是给input赋值的，它是一个新的对象
（4）(System.in)是指定了数据的来源，System.in默认代表键盘输入
（5）整个语句中，唯一可以自己修改的就是input这个变量名
如果你把input修改为其他了，那么下面的代码，凡是input的地方就修改为你自己命名的变量名
*/
java.util.Scanner input = new java.util.Scanner(System.in);
// Scanner s = new Scanner(System.in);
System.out.print("请输入年龄：");//这个语句在输入之前执行
/*
nextInt()是input这个对象的方法，所以Int的I是大写，因为方法名和变量名一样，从第二个单词开始首字母大写
因为它是方法，所以()不能省略
*/
int age = input.nextInt();//从扫描仪中获取一个int的值，赋值给age这个变量
System.out.println("age = " + age);//输出age变量的值
System.out.print("请输入姓名：");
String name = input.next();//因为String输入太常用了，所以方法名简化了，没有用nextString
// String password = input.nextString();
//Error:(49, 32) java: 找不到符号
// 符号: 方法 nextString()
// 位置: 类型为java.util.Scanner的变量 input
System.out.print("请输入体重：");
double weight = input.nextDouble();
System.out.print("请输入是否漂亮：");
boolean beautiful = input.nextBoolean();
System.out.print("请输入性别：");
char gender = input.next().charAt(0);//因为输入单个char太少用了，Scanner中没有提供输入单个char的方法，那么我们只能变通，先按字符串接收，然后取第一个字符
System.out.println("姓名：" + name);
System.out.println("年龄：" + age);
System.out.println("体重：" + weight);
System.out.println("性别：" + gender);
System.out.println("是否漂亮：" + beautiful);
//请输入年龄：22
//age = 22
//请输入姓名：牛菜文
//请输入体重：75
//请输入是否漂亮：true
//请输入性别：女
//姓名：牛菜文
//年龄：22
//体重：75.0
//性别：女
//是否漂亮：true
//
//Process finished with exit code 0
}
}
二、复合语句
与C语言及其他语言相同，Java语言的复合语句是以整个块区为单位的语句，所以又称为块语句。复合语句由开括号“{”开始，闭括号“}”结束。
复合语句中的每一语句都是从上到下执行。复合语句以整个块为单位，并且在复合语句中可以嵌套复合语句。
Java代码结构：
class 类{
{
//代码块
}
方法签名{
//方法体
}
内部类{
内部类体
}
}
复合语句为变量创建了一个作用域。在该作用域中某个变量被创建并能够使用，如果在某个变量的作用域外使用该变量，则会发生错误。
/*
问题3：格式问题（为了好看）
（1）{}问题
风格1：推荐风格
class 类名{
方法{
System.out.println();
}
}
从右边往左边看，结尾要么是{，}，要么是;
风格2：延续老的C语言风格
class 类名
{
方法
{
}
}
不建议混搭
风格3：不建议
class 类名{
public static void main(String[] args){
System.out.println("hello");
}}
（2）缩进问题
class 类名{
Tab键public static void main(String[] args){
Tab键Tab键System.out.println("xxx");
Tab键}
}
往右缩进：Tab键
往左回缩：Shift + Tab键
*/
class Problem3{
public static void main(String[] args){
System.out.println("xxx");
for(int i=0; i<5; i++){
System.out.println("yyy");
}
}
}
三、 分支结构
分支结构：根据条件选择性的执行某些代码
分为：
1、条件判断：if…else系列
2、选择结构：switch…case系列
分支 根据条件选择性的执行某些代码
分支 选择
1、 条件判断
1、单分支结构
语法格式：
if(条件表达式){
当条件表达式成立(true)时需要执行的语句块;
}
执行过程：
条件成立，就执行{}其中的语句块，不成立就不执行。
注意：
（1）if(条件表达式)中的条件表达式的结果必须是boolean类型
（2）当{}中的语句只有一个语句（简单的语句，也可以是一个复合语句）时，可以省略{}，但是我们不建议省略
//省略{}的情况
if(score<0 || score>100)
System.out.println("输入有误！");//简单的语句
else
//复合语句
if(score==100){
System.out.println("满分");
}else if(score>=80){
System.out.println("优秀");
}else if(score>=60){
System.out.println("及格");
}else{
System.out.println("不及格");
}
示例代码：
int year = 2019;
int days = 28;
if(year%4==0 && year%100!=0 || year%400==0){
days= 29;
}
2、双分支结构
语法格式：
if(条件表达式){
当条件表达式成立(true)时需要执行的语句块1;
}else{
当条件表达式不成立(false)时需要执行的语句块2;
}
执行过程：
当条件表达式成立(true)时执行语句块1，否则执行语句块2
注意：
（1）if(条件表达式)中的条件表达式的结果必须是boolean类型
（2）当{}中的语句只有一个语句（简单的语句，也可以是一个复合语句）时，可以省略{}，但是我们不建议
示例代码：
int num = 10;
if(num%2==0){
System.out.println(num + "是偶数")；
}else{
System.out.println(num + "是奇数")；
}
3、多分支结构
语法格式：
if(条件表达式1){
当条件表达式1成立的时候，执行的语句块1；
}else if(条件表达式2){
当条件表达式1不成立，
条件表达式2成立的时候，执行的语句块2；
}else if(条件表达式3){
当条件表达式1不成立，
条件表达式2也不成立，
条件表达式3成立的时候，执行的语句块3；
}
。。。
【else{
当以上所有的条件表达式都不成立，需要执行的语句块n+1;
}】
执行过程：
（1）多个条件顺序往下判断，如果上面有一个条件成立了，下面的条件就不看了
（2）多个分支也只会执行其中的一个
注意：
（1）每一个条件表达式都必须是boolean值
（2）当{}中只有一个语句时，也可以省略{}，但不建议省略
（3）当多个条件是“互斥”关系（没有重叠部分），顺序可以随意；
当多个条件是“包含”关系（有重叠部分），顺序不能随意，小的在上，大的在下面
示例代码：
int score = 78;
if(score==100){
System.out.println("满分");
}else if(score>=80){
System.out.println("优秀");
}else if(score>=60){
System.out.println("及格");
}else{
System.out.println("不及格");
}
4、嵌套
执行过程：
当嵌套在if中，就是当外面的if成立时，才会看里面的条件判断；
当嵌套在else中，就当外面的else满足时，才会看里面的条件判断；
2、 选择结构
语法格式：
switch(表达式){
case 常量值1:
语句块1;
【break;】
case 常量值2:
语句块2;
【break;】
。。。
【default:
语句块n+1;
【break;】
】
}
执行过程：
（1）入口
①当switch(表达式)的值与case后面的某个常量值匹配，就从这个case进入；
②当switch(表达式)的值与case后面的所有常量值都不匹配，寻找default分支进入;
（2）一旦从“入口”进入switch，就会顺序往下执行，直到遇到“出口”
（3）出口
①自然出口：遇到了switch的结束}
②中断出口：遇到了break等
注意：
（1）switch(表达式)的值的类型，只能是：4种基本数据类型（byte,short,int,char），两种引用数据类型（枚举、String）
（2）case后面必须是常量值，而且不能重复
示例代码：
int month = 4;
switch(month){
case 3:
case 4:
case 5:
System.out.println("春季");
break;
case 6:
case 7:
case 8:
System.out.println("夏季");
break;
case 9:
case 10:
case 11:
System.out.println("秋季");
break;
case 12:
case 1:
case 2:
System.out.println("冬季");
break;
default:
System.out.println("输入有误！");
}
3、code
分支结构
/*
二、分支结构
1、条件判断：if..else
2、选择结构：switch...case
（一）条件判断
1、单分支条件判断
语法格式：
if(条件表达式){
当该条件表达式成立时，需要执行的语句
}
说明：
（1）if()中表达式必须是boolean类型的结果
①本身就是boolean类型的值
②比较表达式
③逻辑表达式
（2）当{}中的语句只有一句时，可以省略{}
但是我们不建议省略{}
提醒：
学习流程控制语句结构：
（1）语法格式
（2）执行特点
*/
class Test03_If{
public static void main(String[] args){
//1、从键盘输入一个年份
//(1)准备Scanner扫描仪对象
java.util.Scanner input = new java.util.Scanner(System.in);
//(2)提示输入年份
System.out.print("请输入年份：");
//(3)输入并接收一个整数作为年份
int year = input.nextInt();
//2、需求：判断这个年份是否是闰年，然后显示它的2月份的总天数
/*闰年的条件：（1）被4整除但不能被100整除或（2）被400整除
*/
int days = 28;//平年
//如果是闰年，days 修改为29
/*
if(year%4==0 && year%100!=0 || year%400==0){
days = 29;
}
*/
if(year%4==0 && year%100!=0 || year%400==0)
days = 29;
System.out.println(year+"的2月份的总天数有：" + days);
}
}
分支结构 条件判断
/*
二、分支结构
1、条件判断：if..else
2、选择结构：switch...case
（一）条件判断
1、单分支条件判断
2、双分支条件判断
if(条件表达式){
当条件表达式成立时，要执行的语句块;
}else{
当条件表达式不成立时，要执行的语句块;
}
说明：
（1）条件表达式必须是boolean值
（2）当{}中的语句只有一句时，可以省略{}
不建议省略{}
*/
class Test04_IfElse{
public static void main(String[] args){
/*
从键盘输入一个整数，判断是偶数还是奇数
*/
//1、键盘输入
java.util.Scanner input = new java.util.Scanner(System.in);
System.out.print("请输入一个整数：");
int num = input.nextInt();
//2、判断
/*
if(num%2==0){
System.out.println(num + "是偶数");
}else{
System.out.println(num + "是奇数");
}
*/
if(num%2==0)
System.out.println(num + "是偶数");
else
System.out.println(num + "是奇数");
}
}
练习
/*
1、从键盘输入一个分数，如果60分（含）以上，就打印合格，如果60分以下，就打印不合格
提示：从键盘输入
代码 一些空行 阅读
*/
class Test05_Exer1{
public static void main(String[] args){
//1、从键盘输入一个分数
java.util.Scanner input = new java.util.Scanner(System.in);
java.util.Scanner x = new java.util.Scanner(System.in);
System.out.print("请输入成绩：");
int score = input.nextInt();
//2、判断
if(score >= 60){
System.out.println("合格");
}else{
System.out.println("不合格");
}
}
}
条件判断
/*
二、分支结构
1、条件判断：if..else
2、选择结构：switch...case
（一）条件判断
1、单分支条件判断
2、双分支条件判断
3、多分支条件判断
语法格式：
if(条件表达式1){
当条件表达式1成立时，要执行的语句块1;
}else if(条件表达式2){
当条件表达式1不成立，
当条件表达式2成立时，要执行的语句块2;
}else if(条件表达式3){
当条件表达式1不成立，
当条件表达式2不成立，
当条件表达式3成立时，要执行的语句块3;
}。。。
【
else{
当以上所有的条件都不成立时，要执行的语句块n+1；
}
】
说明：
（1）所有条件表达式必须是boolean值
（2）当{}中的语句只有一句时，可以省略{}
不建议省略{}
执行特点：
（1）不管有几个分支，最终只会执行其中的一个
（2）这么多条件表达式是顺序往下判断的，
如果上面有条件成立了，下面的就不看了；
如果上面的条件不成立，才会去看下面条件。
当多个条件的范围是“互斥”（没有重叠部分），顺序可以随意；
当多个条件的范围是“包含”（有重叠部分），顺序不能随意，小的在上，大的在下
*/
class Test06_IfElseIf{
public static void main(String[] args){
/*从键盘输入成绩：假设成绩输入[0,100]的合法成绩，这里先不讨论不合法的情况
成绩分为：
100分，输出满分
90-99，输出优秀
70-89，输出良好
60-69，输出及格
60以下，输出不及格
平常我是直接一个个的
score == 100
score >= 90 && score <=99
我可以这样
score == 100
score >=90
score >=70
*/
//1、从键盘输入成绩：
java.util.Scanner input = new java.util.Scanner(System.in);
System.out.print("请输入成绩：");
int score = input.nextInt();
//2、判断
if(score == 100){
System.out.println("满分");
}else if(score>=90 && score<=99){
System.out.println("优秀");
}else if(score>=70 && score<=89){
System.out.println("良好");
}else if(score>=60 && score<=69){
System.out.println("及格");
}else{
System.out.println("不及格");
}
/*
if(score == 100){
System.out.println("满分");
}else if(score>=90){
System.out.println("优秀");
}else if(score>=70){
System.out.println("良好");
}else if(score>=60){
System.out.println("及格");
}else{
System.out.println("不及格");
}
*/
}
}
练习
三个整数排序
/*
3、编写程序：由键盘输入三个整数分别存入变量num1、num2、num3，
对它们进行排序(使用 if-else if-else),并且从小到大输出。
*/
class Test08_Exer3{
public static void main(String[] args){
//1、键盘输入三个整数
java.util.Scanner input = new java.util.Scanner(System.in);
System.out.print("请输入num1：");
int num1 = input.nextInt();
System.out.print("请输入num2：");
int num2 = input.nextInt();
System.out.print("请输入num3：");
int num3 = input.nextInt();
//2、判断
/*
利用这样排序 3 2 1 6种情况来判断下 4 3 2 1 24
三个数排序，6种情况
num1 <= num2 <= num3
num1 <= num3 <= num2
num2 <= num1 <= num3
num2 <= num3 <= num1
num3 <= num2 <= num1
num3 <= num1 <= num2
*/
if(num1<=num2 && num2<=num3){
System.out.println(num1 + "<=" + num2 + "<=" + num3);
}else if(num1<=num3 && num3<=num2){
System.out.println(num1 + "<=" + num3 + "<=" + num2);
}else if(num2<=num1 && num1<=num3){
System.out.println(num2 + "<=" + num1 + "<=" + num3);
}else if(num2<=num3 && num3<=num1){
System.out.println(num2 + "<=" + num3 + "<=" + num1);
}else if(num3<=num2 && num2<=num1){
System.out.println(num3 + "<=" + num2 + "<=" + num1);
}else{
System.out.println(num3 + "<=" + num1 + "<=" + num2);
}
}
}
/*
4、大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，
当然要提出一定的条件：高：180cm以上；富：财富1千万以上；帅：是。
如果这三个条件同时满足，则：“我一定要嫁给他!!!”
如果三个条件中有为真的情况，则：“嫁吧，比上不足，比下有余。”
如果三个条件都不满足，则：“不嫁！”
婚姻 爱情
我是fw 废了 好好努力吧 撸码撸码 不断
想办法满足一个条件 那就是......嘿嘿
提示：从键盘输入
Scanner input=new Scanner(System.in);
input.nextInt();//接收从键盘输入的一个整数
input.next();输入一个字符串
input.nextDouble();//输入一个小数
input.nextBoolean();//输入一个布尔值
*/
class Test09_Exer4{
public static void main(String[] args){
//1、输入男方的条件
java.util.Scanner input = new java.util.Scanner(System.in);
System.out.print("请输入身高（单位：cm）：");
int height = input.nextInt();
System.out.print("请输入财富（单位：千万）：");
double money = input.nextDouble();
System.out.print("请输入是否帅（true/false）：");
boolean handsom = input.nextBoolean();
//2、判断
/*
高：180cm以上；富：财富1千万以上；帅：是。
如果这三个条件同时满足，则：“我一定要嫁给他!!!”
如果三个条件中有为真的情况，则：“嫁吧，比上不足，比下有余。”
如果三个条件都不满足，则：“不嫁！”
*/
//if(height>=180 && money>=1 && handsom==true){
if(height>=180 && money>=1 && handsom){
System.out.println("我一定要嫁给他!!!");
}else if(height>=180 || money>=1 || handsom){
System.out.println("嫁吧，比上不足，比下有余。");
}else{
System.out.println("不嫁！");
}
}
}
随机数
class Test11_Random{
public static void main(String[] args){
//使用Math.random() 产生随机数
System.out.println(Math.random());
/*
Math.random()：产生的随机数是[0,1)的小数
*/
//如果我想要产生[1,10]之间的整数
double rand = Math.random();//[0,1)的小数
rand = rand * 10; //[0,10)的小数
rand = rand + 1; //[1,11)的小数
int num = (int)rand;//[1,10]的整数
System.out.println(num);
int m = (int)(Math.random()*10 + 1);
System.out.println("m = " + m);
// 随机产生一个两位数 整数 [10,99]
int r = (int)(Math.random()*90 + 10);
System.out.println("r = " + r);
}
}
/*
6、假设你想开发一个玩彩票的游戏，
程序随机地产生一个两位数的彩票，提示用户输入一个两位数，
然后按照下面的规则判定用户是否能赢。
1)如果用户输入的数匹配彩票的实际顺序，奖金10 000美元。
相等
2)如果用户输入的所有数字匹配彩票的所有数字，但顺序不一致，奖金 3 000美元。
我的个位=你的十位 && 我的十位=你的个位
3)如果用户输入的一个数字仅满足顺序情况下匹配彩票的一个数字，奖金1 000美元。
个 个 || 十 个
4)如果用户输入的一个数字仅满足非顺序情况下匹配彩票的一个数字，奖金500美元。
个 十 || 十 个
5)如果用户输入的数字没有匹配任何一个数字，则彩票作废。
提示：使用Math.random() 产生随机数
Math.random() 产生[0,1)范围的随机值
两位数的范围：[10,99]
Math.random() * 90：[0,90)
Math.random() * 90 + 10：[10,100) 即得到 [10,99]
使用(int)(Math.random() * 90 + 10)产生一个两位数的随机数。
*/
class Test12_Exer6{
public static void main(String[] args){
//1、随机地产生一个两位数的彩票
int rand = (int)(Math.random() * 90 + 10);//[10,99]
//2、提示用户输入一个两位数
java.util.Scanner input = new java.util.Scanner(System.in);
System.out.print("请输入两位数的彩票号码：");
int num = input.nextInt();
//3、处理数字
int randShi = rand/10;
int randGe = rand%10;
int numShi = num/10;
int numGe = num%10;
//4、判断
/*
1)如果用户输入的数匹配彩票的实际顺序，奖金10 000美元。
2)如果用户输入的所有数字匹配彩票的所有数字，但顺序不一致，奖金 3 000美元。
3)如果用户输入的一个数字仅满足顺序情况下匹配彩票的一个数字，奖金1 000美元。
4)如果用户输入的一个数字仅满足非顺序情况下匹配彩票的一个数字，奖金500美元。
5)如果用户输入的数字没有匹配任何一个数字，则彩票作废。
*/
if(num == rand){
System.out.println("奖金10 000美元");
}else if(randShi == numGe && randGe == numShi){
System.out.println("奖金3 000美元");
}else if(randShi == numShi || randGe == numGe){
System.out.println("奖金1 000美元");
}else if(randShi == numGe || randGe == numShi){
System.out.println("奖金500美元");
}else{
System.out.println("彩票作废");
}
System.out.println("本次号码：" + rand);
}
}
switch
/*
二、分支结构
1、条件判断：if..else
2、选择结构：switch...case
（一）条件判断
1、单分支条件判断
2、双分支条件判断
3、多分支条件判断
4、嵌套条件判断
（二）选择结构
语法结构：
switch(表达式){
case 常量值1:
语句块1;
【break;】
case 常量值2:
语句块2;
【break;】
...
【default:
语句块n+1;
【break;】
】
}
要求：
（1）case后面必须是常量值
（2）case后面的常量值不能重复
（3）switch()中的表达式的类型有要求：
允许4种基本数据类型：byte,short,int,char
允许2种引用数据类型：枚举（JDK1.5之后）、String（JDK1.7之后）
表达式的类型是由要求的 char short int char
枚举1.5 String 1.7
执行特点：
（1）入口
①当switch()中的表达式的值与某一个case后面的常量值“相等”，就会从这个case进入
②当switch()中的表达式的值与所有的case后面的常量值都“不相等”，就会寻找default进入
（2）出口
①自然出口：switch的结束}
②中断出口：break （或后面要讲的return等）
（3）一旦找到“入口”就会顺序往下执行，直到遇到“出口”
（4）default的位置不一定在最后，习惯上我们写在最后
switch：开关
一档二档三档等等
*/
class Test13_switch{
public static void main(String[] args){
/*
请输入星期的数字，输出对应的英语单词
*/
java.util.Scanner input = new java.util.Scanner(System.in);
System.out.print("请输入星期（1-7）：");
int week = input.nextInt();
//要break结束的 都不等于 才default
//int a = 1;
switch(week){
default:
System.out.println("输入有误");
break;
//case a:// a不是常量
//常量表达式
case 1:
System.out.println("Monday");
break;
case 2:
System.out.println("Tuesday");
break;
case 3:
System.out.println("Wednesday");
break;
case 4:
System.out.println("Thursday");
break;
case 5:
System.out.println("Friday");
break;
case 6:
System.out.println("Saturday");
break;
case 7:
System.out.println("Sunday");
break;
// default:
// System.out.println("输入有误");
// break;
}
}
}
//8、使用 switch 把阿拉伯数字转为“零、壹、贰、叁、肆、伍、陆、柒、捌、玖”；其它的都输出 “other”。
class Test14_Exer8{
public static void main(String[] args){
//1、输入0-9的数字
java.util.Scanner input = new java.util.Scanner(System.in);
System.out.print("请输入0-9的数字：");
int num = input.nextInt();
//switch(num){
// case 1:
// xxx
// break;
// }
//2、转为中文大写数字
switch(num){
case 0:
System.out.println("零");
break;
case 1:
System.out.println("壹");
break;
case 2:
System.out.println("贰");
break;
case 3:
System.out.println("叁");
break;
case 4:
System.out.println("肆");
break;
case 5:
System.out.println("伍");
break;
case 6:
System.out.println("陆");
break;
case 7:
System.out.println("柒");
break;
case 8:
System.out.println("捌");
break;
case 9:
System.out.println("玖");
break;
default:
System.out.println("other");
}
}
}
/*
9、根据用于指定月份，打印该月份所属的季节。
3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12, 1, 2 冬季
*/
class Test15_Exer9{
public static void main(String[] args){
//1、输入月份
java.util.Scanner input = new java.util.Scanner(System.in);
System.out.print("请输入月份：");
int month = input.nextInt();
System.out.println(13|14);//按位或运算符 15
switch(month){
// case 13|14:
// System.out.println("15");
// break;
case 3:
case 4:
case 5:
System.out.println("春季");
break;
case 6:
case 7:
case 8:
System.out.println("夏季");
break;
case 9:
case 10:
case 11:
System.out.println("秋季");
break;
case 12:
case 1:
case 2:
System.out.println("冬季");
break;
default:
System.out.println("输入有误！");
}
}
}
输入年、月、日，判断这一天是当年的第几天
/*
11、从键盘分别输入年、月、日，判断这一天是当年的第几天
注：判断一年是否是闰年的标准：
1）可以被4整除，但不可被100整除
2）可以被400整除
*/
class Test16_Exer11{
public static void main(String[] args){
//1、从键盘分别输入年、月、日
java.util.Scanner input = new java.util.Scanner(System.in);
System.out.print("年：");
int year = input.nextInt();
System.out.print("月：");
int month = input.nextInt();
System.out.print("日：");
int day = input.nextInt();
//判断这一天是当年的第几天==>从1月1日开始，累加到xx月xx日这一天
//(1)[1,month-1]个月满月天数
//(2)第month个月的day天
//(3)单独考虑2月份是否是29天（依据是看year是否是闰年）
//2、声明一个变量days，用来存储总天数
//int days = 0;
//累加第month个月的day天
//days += day;
//修改上面的代码，直接把days初始化为day
int days = day;
//3、累加[1,month-1]个月满月天数
/*
switch(month){
//case 1://不需要累加满月天数
case 2:
//累加1月的满月天数
days += 31;
break;
case 3:
//累加1月和2月的满月天数
days += 31 + 28;
break;
case 4:
//累加1月、2月、3月的满月天数
days += 31 + 28 + 31;
break;
....
}
*/
switch(month){
case 12:
//累加的1-11月
days += 30;//这个30是代表11月份的满月天数
//这里没有break，继续往下走
case 11:
//累加的1-10月
days += 31;//这个31是代表10月的满月天数
//这里没有break，继续往下走
case 10:
days += 30;//9月
case 9:
days += 31;//8月
case 8:
days += 31;//7月
case 7:
days += 30;//6月
case 6:
days += 31;//5月
case 5:
days += 30;//4月
case 4:
days += 31;//3月
case 3:
days += 28;//2月
//4、在这里考虑是否可能是29天
if(year%4==0 && year%100!=0 || year%400==0){
days++;//多加1天
}
case 2:
days += 31;//1月
}
//5、输出结果
System.out.println(year + "年" + month + "月" + day + "日是这一年的第" + days + "天");
}
}
随机游戏
/*
7、赌数游戏：随机产生3个1-6的整数，
如果三个数相等，那么称为“豹子”，
如果三个数之和大于9，称为“大”，
如果三个数之和小于等于9，称为“小”，
用户从键盘输入押的是“豹子”、“大”、“小”，并判断是否猜对了
*/
class Test17_Exer7{
public static void main(String[] args){
//1、随机产生3个1-6的整数
int a = (int)(Math.random()*6 + 1);
int b = (int)(Math.random()*6 + 1);
int c = (int)(Math.random()*6 + 1);
System.out.println("a="+a);
System.out.println("b="+b);
System.out.println("c="+c);
//2、判断随机产生的数的结果是什么
String result;
if(a == b && b == c){
result = "豹子";
}else if(a + b + c > 9){
result = "大";
}else{
result = "小";
}
//3、用户从键盘输入押的是“豹子”、“大”、“小”
java.util.Scanner input = new java.util.Scanner(System.in);
System.out.print("请押宝（豹子、大、小）：");
String ya = input.next();
//4、判断用户的输入是否猜对了
//比较ya与result是否相同
//if(result==ya){
if(result.equals(ya)){
System.out.println("猜对了");
}else{
System.out.println("猜错了");
}
}
}
随机游戏 猜大小豹子
/*
7、赌数游戏：随机产生3个1-6的整数，
如果三个数相等，那么称为“豹子”，
如果三个数之和大于9，称为“大”，
如果三个数之和小于等于9，称为“小”，
用户从键盘输入押的是“豹子”、“大”、“小”，并判断是否猜对了
*/
class Test17_Exer7_2{
public static void main(String[] args){
//1、随机产生3个1-6的整数
int a = (int)(Math.random()*6 + 1);
int b = (int)(Math.random()*6 + 1);
int c = (int)(Math.random()*6 + 1);
//2、判断随机产生的数的结果是什么
int result;
if(a == b && b == c){
result = 1;//假设豹子为1
}else if(a + b + c > 9){
result = 2;//假设大为2
}else{
result = 3;//假设小为3
}
//3、用户从键盘输入押的是“豹子”、“大”、“小”
java.util.Scanner input = new java.util.Scanner(System.in);
System.out.println("1、豹子");
System.out.println("2、大");
System.out.println("3、小");
System.out.print("请选择：");
int ya = input.nextInt();
//4、判断用户的输入是否猜对了
//比较ya与result是否相同
if(result==ya){
System.out.println("猜对了");
}else{
System.out.println("猜错了");
}
System.out.println("三个数是：" + a + "，" + b + "，" + c);
}
}
四、 循环结构
循环结构：
“重复”执行某些代码
循环结构的分类：
1、for循环
2、while循环
3、do…while循环
1、 for循环
语法格式：
for(;;){
循环体语句块；
if(条件表达式){
break;
}
}
for(初始化表达式; 循环条件; 迭代表达式){
循环体语句块；（需要重复执行的代码）
}
执行过程：
（1）初始化表达式;
（2）判断循环条件;
（3）如果循环条件成立，先执行循环体语句块；然后执行迭代表达式，再回到（2）…
（4）如果循环条件不成立，会结束for；
或者在当前循环中遇到break语句，也会结束当前for循环;
注意：
（1）for(;;)中的两个；是不能多也不能少
（2）循环条件必须是boolean类型
示例代码：
//遍历1-100之间的偶数
for(int i=1; i<=100; i++){//每次循环的步幅是1
if(i%2==0){
System.out.println(i);
}
}
//遍历1-100之间的偶数
for(int i=2; i<=100; i+=2){//每次循环的步幅是2
System.out.println(i);
}
2、 while循环
语法格式：
while(循环条件){
循环体语句块;
}
经典的形式：
while(true){
循环体语句块;
if(条件表达式){
break;
}
}
执行过程：
（1）先判断循环条件
（2）如果循环条件成立，就执行循环体语句块；然后回到（1）
（3）如果循环条件不成立，就结束while循环；
如果在循环体语句块中，遇到break，也会结束while循环；
注意：
（1）while(循环条件)中循环条件必须是boolean类型
示例代码：
//遍历1-100之间的偶数
int num = 2;
while(num<=100){
System.out.println(num);
num+=2;
}
3、 do…while循环
语法格式：
do{
循环体语句块;
}while(循环条件);
执行过程：
（1）先执行一次循环体语句块；
（2）判断循环条件
（3）如果循环条件成立，再次执行循环体语句块；然后回到（2）…
（4）如果循环条件不成立，就结束do…while循环；
如果在循环体语句块中，遇到break，也会结束do…while循环；
注意：
（1）while(循环条件)中循环条件必须是boolean类型
（2）do{}while();最后有一个分号
（3）do…while结构的循环体语句是至少会执行一次，这个和for和while是不一样的
示例代码：
//从键盘输入整数，统计正数、负数的个数，输入0结束
java.util.Scanner input = new java.util.Scanner(System.in);
int num;
int positive = 0;
int negative = 0;
do{
System.out.print("请输入整数（0结束）：");
num = input.nextInt();
if(num > 0){
positive++;
}else if(num < 0){
negatvie++;
}
}while(num!=0);
System.out.println("正数的个数：" + positive);
System.out.println("负数的个数：" + negatvie);
4、 三种循环的选择
原则：三种循环之间是可以互相转换的，都能实现循环的功能
建议（习惯上）：当我们次数比较明显的时候，或者说从几循环到几的时候，一般先考虑for；
当循环体语句块至少要执行一次的时候，一般先考虑do…while；
当循环条件比较明显，但是次数不明显，循环体语句块也不是至少执行一次，那么可以考虑while结构；
三种循环结构都具有四要素：
（1）循环变量的初始化表达式
（2）循环条件
（3）循环变量的修改的迭代表达式
（4）循环体语句块
5、 跳转语句
1、break
用于：
（1）switch结构
作用：结束switch结构
（2）循环结构
作用：结束当前循环
2、continue
用于：
只能用于循环结构
作用：提前结束本次循环，继续下一次循环
3、return
方法结束、程序结束
6、code
for循环
/*
流程控制语句结构：
1、顺序结构
2、分支结构
3、循环结构：重复执行某些代码时
三、循环结构
1、for循环
2、while循环
3、do...while循环
4、foreach增强循环（后面再讲）
（一）for循环
1、语法结构
形式一：
for(;;){
需要重复执行的语句（换句话说，不需要重复执行的语句，就不要放到{}中
}
形式二：
for(循环变量初始化表达式①; 循环条件表达式②; 循环变量迭代表达式③){
循环体语句④：需要重复执行的语句
}
注意：
（1）for(;;)其中的两个;不能多也不能少
（2）循环条件表达式②要么不写，要么必须是boolean类型
执行的过程：
（1）执行循环变量初始化表达式①;
（2）进行循环条件表达式②判断
（3）如果循环条件表达式②成立，执行循环体语句④，然后再执行循环变量迭代表达式③，完事后回到（2）
如果循环条件表达式②不成立，结束整个for
*/
class Test02_For{
public static void main(String[] args){
//fori
for (int i = 0; i < 3; i++) {
System.out.println("菜鸟文你是真的鸡");
}
//for(;;){//死循环，无限循环
// System.out.println("柴老师真漂亮！");
//}
/*
需求：打印5遍的：柴老师真漂亮！
i就是循环变量，既然是变量，就要声明，而且需要初始化
*/
for(int i=1; i<=5; i++){
System.out.println("柳江雪老师真漂亮！");
}
/*
（1）int i=1;
（2）i<=5;
（3）条件成立，执行 System.out.println("柳江雪老师真漂亮！");
（4）然后i++， i=2
（5）i<=5;
（6）条件成立，执行 System.out.println("柳江雪老师真漂亮！");
（7）然后i++， i=3
（8）i<=5;
（9）条件成立，执行 System.out.println("柳江雪老师真漂亮！");
（10）然后i++， i=4
（11）i<=5;
（12）条件成立，执行 System.out.println("柳江雪老师真漂亮！");
（13）然后i++， i=5
（14）i<=5;
（15）条件成立，执行 System.out.println("柳江雪老师真漂亮！");
（16）然后i++， i=6
（17）i<=5;
（18）条件不成立，结束for
*/
/*
执行：i=1,i=3,i=5
*/
for(int i=1; i<=5; i+=2){
System.out.println("柳江雪老师真漂亮！2");
}
/*
执行：i=1,i=2,i=4
*/
for(int i=1; i<=5; i*=2){
System.out.println("柳江雪老师真漂亮！3");
}
}
}
for循环练习
求1-100的和
//1、求1-100的和
class Test03_Exer1{
public static void main(String[] args){
/*
需要几个变量？
（1）循环变量：i从1变到100
（2）总和：sum
*/
int sum = 0;
//循环要执行100次，依次是i=1,i=2,i=3,i=4....i=100，当i=101时因为条件不满足结束
for(int i=1; i<=100; i++){
//循环体语句：把每一个i的值累加到sum中
sum += i;
}
//输出最后的结果，不用在循环体中，因为在循环结束后最后输出一次
System.out.println("sum = " + sum);
System.out.println("用公式");
System.out.println("1-100的和：" + (1+100)*100/2);
}
}
打印1-100的偶数
*
2、打印1-100的偶数
Ctrl + 鼠标滚轮 调节编辑框字的大小
一天从早到晚 伤眼睛
*/
class Test04_Exer2{
public static void main(String[] args){
//需要几个变量，1个变量，循环变量
//循环变量i的变化是从1-100
for(int i=1; i<=100; i++){
if(i%2==0){
System.out.println(i);//这句话有条件执行
}
}
System.out.println("-----------------------");
for(int i=2; i<=100; i+=2){
System.out.println(i);
}
}
}
while循环
（二）while循环
语法格式：
while(循环条件){
循环体语句块
}
执行过程：
（1）先判断循环条件
（2）如果循环条件成立，那么就执行循环体语句，再回到（1）
如果循环条件不成立，那么就结束while循环
仔细分析，仍然有四个要素：
（1）循环变量的初始化，例如：int i = 1;
（2）循环条件，例如：i<=100
（3）循环体语句，例如： sum+=i;
（4）迭代语句，例如：i++
结论：
各种循环之间是可以互相替换的，只不过，在某些场景，那么某一中循环更合适（可读性方面）
for循环一般用于：次数比较明显，以及后面数组等遍历
while循环一般用于：条件比较明显，次数不太明显
*/
class Test05_While{
public static void main(String[] args){
//1、求1-100的和
/*
两个变量：
（1）sum：存总和
（2）循环变量，从1-100
*/
int sum = 0;
int i = 1;
while(i<=100){
sum+=i;//需要重复执行的语句，累加每一个i
i++;
}
System.out.println("sum = " + sum);
}
}
输出所有的水仙花数
5、输出所有的水仙花数，
所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。
例如： 153 = 1*1*1 + 5*5*5 + 3*3*3
*/
class Test06_Exer5{
public static void main(String[] args){
System.out.println("所有的水仙花数如下：");
//水仙花数是指一个3位数==>水仙花数的范围[100,999]
for(int i=100; i<=999; i++){
/*
对于每一个i的值，我们要干什么？
（1）求出i的百、十、个位的值
（2）判断i的百位的立方+十位的立方+个位的立方是否等于i，
如果相等，就输出i
*/
//（1）求出i的百、十、个位的值
int bai = i/100;
int shi = i/10%10;
int ge = i%10;
//（2）判断i的百位的立方+十位的立方+个位的立方是否等于i，
// 如果相等，就输出i
if(i == bai*bai*bai + shi*shi*shi + ge*ge*ge){
System.out.println(i);
}
}
}
}
输出所有的水仙花数 变化
/*
5、输出所有的水仙花数，
所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。
例如： 153 = 1*1*1 + 5*5*5 + 3*3*3
*/
class Test06_Exer5_2{
public static void main(String[] args){
System.out.println("所有的水仙花数如下：");
//水仙花数是指一个3位数==>水仙花数的范围[100,999]
int i=100;
while( i<=999 ){
/*
对于每一个i的值，我们要干什么？
（1）求出i的百、十、个位的值
（2）判断i的百位的立方+十位的立方+个位的立方是否等于i，
如果相等，就输出i
*/
//（1）求出i的百、十、个位的值
int bai = i/100;
int shi = i/10%10;
int ge = i%10;
//（2）判断i的百位的立方+十位的立方+个位的立方是否等于i，
// 如果相等，就输出i
if(i == bai*bai*bai + shi*shi*shi + ge*ge*ge){
System.out.println(i);
}
i++;
}
}
}
从1循环到150并在每行打印一个值，
另外在每个3的倍数行上打印出“foo”,在每个5的倍数行上打印“biz”,
在每个7的倍数行上打印输出“baz”。
/*
6、从1循环到150并在每行打印一个值，
另外在每个3的倍数行上打印出“foo”,在每个5的倍数行上打印“biz”,
在每个7的倍数行上打印输出“baz”。
*/
class Test07_Exer6{
public static void main(String[] args){
//从1循环到150
for(int i=1; i<=150; i++){
//在每行打印一个i的值
//System.out.println(i);//输出i之后，立刻换行
System.out.print(i);//只打印i的值
//每个3的倍数行上打印出“foo”
if(i%3==0){
//System.out.println("foo");//输出foo后立刻换行
System.out.print("\tfoo");//这里加\t是为了好看
}
//在每个5的倍数行上打印“biz”
if(i%5==0){
System.out.print("\tbiz");
}
//在每个7的倍数行上打印输出“baz”
if(i%7==0){
System.out.print("\tbaz");
}
//最后把这一行的事全部完成后，再换行
//System.out.print("\n");
System.out.println();//只打印换行
}
}
}
do…while
/*
循环结构：
1、for
for(初始化; 循环条件; 迭代语句){
循环体语句块;
}
2、while
while(循环条件){
循环体语句块;
}
3、do...while
语法结构：
do{
循环体语句块：需要重复的代码
}while(循环条件);
说明：
（1）do{}while(循环体条件);后面的;要注意
执行过程：
（1）先执行一次循环体语句块
（2）然后再判断条件，看是否继续下一次
（3）如果条件成立，再次执行循环体语句块；然后回到（2）
如果条件不成立，直接结束do...while
do...while循环与for和while的最大区别：它的循环体语句块是至少执行一次。
*/
class Test08_DoWhile{
public static void main(String[] args){
/*
3、从键盘输入整数，输入0结束，统计输入的正数、负数的个数。
*/
//从键盘输入整数=>java.util.Scanner
java.util.Scanner input = new java.util.Scanner(System.in);
int num;//声明提升到外面的目的，是为了在do{}外面仍然可以使用num
int positive = 0;//统计正数的个数
int negative = 0;//统计负数的个数
do{
//因为从键盘输入整数是重复做，所以放到循环体中
System.out.print("请输入整数（0表示结束）：");
num = input.nextInt();
//统计输入的正数、负数的个数
if(num>0){
positive++;
}else if(num<0){
negative++;
}
}while(num!=0);
//循环条件 想：条件满足，继续执行循环体语句，条件不满足，结束循环
//此时循环条件，num!=0
System.out.println("正数的个数：" + positive);
System.out.println("负数的个数：" + negative);
}
}
for
/*
循环结构：
1、for
for(初始化; 循环条件; 迭代语句){
循环体语句块;
}
2、while
while(循环条件){
循环体语句块;
}
3、do...while
语法结构：
do{
循环体语句块：需要重复的代码
}while(循环条件);
说明：
（1）do{}while(循环体条件);后面的;要注意
执行过程：
（1）先执行一次循环体语句块
（2）然后再判断条件，看是否继续下一次
（3）如果条件成立，再次执行循环体语句块；然后回到（2）
如果条件不成立，直接结束do...while
do...while循环与for和while的最大区别：它的循环体语句块是至少执行一次。
*/
class Test08_DoWhile_For{
public static void main(String[] args){
/*
3、从键盘输入整数，输入0结束，统计输入的正数、负数的个数。
*/
//从键盘输入整数=>java.util.Scanner
java.util.Scanner input = new java.util.Scanner(System.in);
int positive = 0;//统计正数的个数
int negative = 0;//统计负数的个数
//num初始化为1的目的，就是为了第一次可以进入循环
for(int num = 1;num!=0; ){
//因为从键盘输入整数是重复做，所以放到循环体中
System.out.print("请输入整数（0表示结束）：");
num = input.nextInt();//可以作为迭代语句，修改num的值
//统计输入的正数、负数的个数
if(num>0){
positive++;
}else if(num<0){
negative++;
}
}
//循环条件 想：条件满足，继续执行循环体语句，条件不满足，结束循环
//此时循环条件，num!=0
System.out.println("正数的个数：" + positive);
System.out.println("负数的个数：" + negative);
}
}
while
/*
循环结构：
1、for
for(初始化; 循环条件; 迭代语句){
循环体语句块;
}
2、while
while(循环条件){
循环体语句块;
}
3、do...while
语法结构：
do{
循环体语句块：需要重复的代码
}while(循环条件);
说明：
（1）do{}while(循环体条件);后面的;要注意
执行过程：
（1）先执行一次循环体语句块
（2）然后再判断条件，看是否继续下一次
（3）如果条件成立，再次执行循环体语句块；然后回到（2）
如果条件不成立，直接结束do...while
do...while循环与for和while的最大区别：它的循环体语句块是至少执行一次。
*/
class Test08_DoWhile_While{
public static void main(String[] args){
/*
3、从键盘输入整数，输入0结束，统计输入的正数、负数的个数。
*/
//从键盘输入整数=>java.util.Scanner
java.util.Scanner input = new java.util.Scanner(System.in);
int positive = 0;//统计正数的个数
int negative = 0;//统计负数的个数
//num初始化为1的目的，就是为了第一次可以进入循环
int num = 1;
while(num!=0){
//因为从键盘输入整数是重复做，所以放到循环体中
System.out.print("请输入整数（0表示结束）：");
num = input.nextInt();//可以作为迭代语句，修改num的值
//统计输入的正数、负数的个数
if(num>0){
positive++;
}else if(num<0){
negative++;
}
}
//循环条件 想：条件满足，继续执行循环体语句，条件不满足，结束循环
//此时循环条件，num!=0
System.out.println("正数的个数：" + positive);
System.out.println("负数的个数：" + negative);
}
}
练习
随机生成一个100以内的整数，猜数字游戏
/*
4、随机生成一个100以内的整数，猜数字游戏
从键盘输入数，如果大了提示，大了，如果小了，提示小了，如果对了，就不再猜了，
并统计一共猜了多少次
*/
class Test09_Exer4{
public static void main(String[] args){
//随机生成一个100以内的整数,[0,100)
/*
Math.random() -->[0,1)的小数
Math.random()*100 -->[0,100)的小数
[0,100)的整数 (int)(Math.random()*100 )
*/
int randNum = (int)(Math.random()*100);
// System.out.println(randNum);
//从键盘输入数，如果大了提示，大了，如果小了，提示小了，如果对了，就不再猜了，
java.util.Scanner input = new java.util.Scanner(System.in);
int num;//挪到do{}上面，提升作用域
int count = 0;//统计次数
do{
System.out.print("猜数（范围[0,100)：");
num = input.nextInt();
count++;//输入一次，就代表猜一次
if(num > randNum){
System.out.println("大了");
}else if(num<randNum){
System.out.println("小了");
}
}while(num!=randNum);//条件成立，重复执行循环体语句
System.out.println("一共猜了：" + count + "次");
}
}
Math类中提供了random()来产生随机数，Math.random(),
在java.util.Random类中也提供产生随机数的方法。
/*
在Java的核心类库中，除了在Math类中提供了random()来产生随机数，
Math.random()
还在java.util.Random类中也提供产生随机数的方法。
*/
class Test10_Random2{
public static void main(String[] args){
//(1)先准备产生随机数的工具
java.util.Random tools = new java.util.Random();
//(2)用工具获取随机数
int num = tools.nextInt();
System.out.println("随机整数：" + num) ;//eg:随机整数：-884011449
double d = tools.nextDouble();
System.out.println("随机小数：" + d) ;//eg:随机小数：0.3367837139245098
//(3)用工具获取一定范围内的随机值
int rangeNum = tools.nextInt(10);//[0,10)
System.out.println("随机[0,10)整数：" + rangeNum) ;//eg:随机[0,10)整数：1
}
}
break
/*
break：
（1）用于switch..case
作用：结束switch
（2）用于循环结构
作用：结束当前循环
结论：结束一个循环有两种情况（1）循环条件不满足（2）遇到了break等中断
*/
class Test11_Break{
public static void main(String[] args){
//3、从键盘输入整数，输入0结束，统计输入的正数、负数的个数。
//因为需要从键盘输入
java.util.Scanner input = new java.util.Scanner(System.in);
int positive = 0;
int negative = 0;
while(true){//true，表示条件成立，while(true)条件永远成立
System.out.print("请输入整数：");
int num = input.nextInt();
if(num>0){
positive++;
}else if(num<0){
negative++;
}else{//num=0
//结束当前循环
break;
}
}
System.out.println("正数的个数：" + positive);
System.out.println("负数的个数：" + negative);
//for(;;){
//}
}
}
continue
/*
continue：继续（了解）
只能用于循环结构
作用：提前结束本次循环，继续下一次循环
提前结束本次循环 本次循环之后的就不执行了
但下次循环继续执行
*/
class Test12_Continue{
public static void main(String[] args){
//2、打印1-100的偶数
for(int i=1; i<=100; i++){
/*
遇到奇数，提前结束当次循环，跳过了continue后面的循环体语句，直接去执行i++，为下一次循环做准备
*/
if(i%2!=0){
continue;
}
System.out.println(i);
// //or
// if (i%2==0){
// System.out.println(i);
// }
}
}
}
练习
/*
8、打印1-100之间数，其中3、5、7的倍数不打印
*/
class Test13_Exer8{
public static void main(String[] args){
/*
不使用continue
*/
for(int i=1; i<=100; i++){
//其中3、5、7的倍数不打印
//如果这个数不是3，5,7的倍数就打印
//这还有争议吗 什么的打印
if(i%3!=0 && i%5!=0 && i%7!=0){
System.out.println(i);
}
}
System.out.println("-----------------------");
/*
使用continue
*/
for(int i=1; i<=100; i++){
//其中3、5、7的倍数不打印
//如果是3,5,7的倍数就跳过打印语句
if(i%3==0 || i%5==0 || i%7==0){
//break;//如果用break，那么只打印1和2
continue;
}
System.out.println(i);
}
}
}
求最大公约数和最小公倍数
/*
7、输入两个正整数m和n，求其最大公约数和最小公倍数
*/
//要考虑多多的 别那么肤浅 垃圾
class Test14_Exer7{
public static void main(String[] args){
//输入两个正整数m和n
java.util.Scanner input = new java.util.Scanner(System.in);
int m;
while(true){
System.out.print("请输入第一个正整数m的值：");
m = input.nextInt();
if(m<=0){
System.out.println(m + "不是正整数，请重写输入！");
}else{
break;
}
}
int n;
while(true){
System.out.print("请输入第一个正整数n的值：");
n = input.nextInt();
if(n<=0){
System.out.println(n + "不是正整数，请重写输入！");
}else{
break;
}
}
System.out.println("两个正整数：" + m + "," + n);
//求m和n的最大公约数和最小公倍数
/*
1、概念
公约数：能够把m和n都整除，就是它俩的公约数
例如：6和9，公约数：1,3
9和18，公约数：1,3,9
5和13，公约数：1
公倍数：能够被m和n都整除的，就是它俩的公倍数
例如：6和9，公倍数：18,36....
9和18，公倍数：18,36...
5和13，公倍数：65,....
2、如何找最大公约数
例如：6和9
从6开始，9%6==0? 6%6==0?
9%5==0? 6%5==0?
9%4==0? 6%4==0?
9%3==0? 6%3==0? binggou找到了 结束查找
例如：9和18
从9开始 9%9==0? 18%9==0? binggou找到了 结束查找
例如：5和13
从5开始 5%5==? 13%5==0?
5%4==? 13%4==0?
5%3==? 13%3==0?
5%2==? 13%2==0?
5%1==? 13%1==0? binggou找到了 结束查找
其实只要找到5的平方根就可以了
*/
//第一步：找出m和n中最大值和最小值
int max = m>=n ? m : n;
int min = m<n ? m : n;
//第二步：从小的开始查找
//这里的1也可以修改为min的平方根
int maxYue = 1;
for(int i=min; i>=1; i--){
//看i是否能够同时把m和n都整除
if(m%i==0 && n%i==0){
maxYue = i;
break;
}
}
System.out.println(maxYue +"是" + m + "和" + n + "的最大公约数");
//最小公倍数 = m*n / 最大公约数
//System.out.println(m*n/maxYue +"是" + m + "和" + n + "的最小公倍数");
//如果不知道这个公式
//从max开始找，一直找到m*n
for(int i=max; i<=m*n; i++){
if(i%m==0 && i%n==0){
System.out.println(i +"是" + m + "和" + n + "的最小公倍数");
break;
}
}
}
}
循环的嵌套
/*
循环的嵌套：
执行过程：外循环循环一次，内循环整个循环一轮
例如：
*****
*****
*****
*****
*/
class Test15_NestLoop{
public static void main(String[] args){
for(int i=1; i<=4; i++){
//System.out.println("*****");
/*
上面的语句做了两件事：
（1）连续打印5颗*
（2）换行
*/
//（1）连续打印5颗*
for(int j=1; j<=5; j++){
System.out.print("*");
}
//（2）换行
System.out.println();
}
/*
（1）执行外循环的int i=1;
（2）执行外循环的i<=4;
（3）条件成立执行外循环的循环体语句
for(int j=1; j<=5; j++){
System.out.print("*");
}
System.out.println();
（4）执行内循环的int j=1;
（5）执行内循环的j<=5;
（6）条件成立，执行内循环的循环体语句 System.out.print("*");
（7）执行内循环的迭代语句 j++ j=2
（8）执行内循环的j<=5;
（9）条件成立，执行内循环的循环体语句 System.out.print("*");
（10）执行内循环的迭代语句 j++ j=3
（11）执行内循环的j<=5;
（12）条件成立，执行内循环的循环体语句 System.out.print("*");
（13）执行内循环的迭代语句 j++ j=4
（14）执行内循环的j<=5;
（15）条件成立，执行内循环的循环体语句 System.out.print("*");
（16）执行内循环的迭代语句 j++ j=5
（17）执行内循环的j<=5;
（18）条件成立，执行内循环的循环体语句 System.out.print("*");
（19）执行内循环的迭代语句 j++ j=6
（20）执行内循环的j<=5;
（21）内循环条件不成立，结束内循环
（22）System.out.println(); 它是属于外循环的循环体语句
（23）执行外循环的迭代语句i++ i=2
（24）执行外循环的i<=4;
（25）条件成立，再次执行外循环的循环体语句
for(int j=1; j<=5; j++){
System.out.print("*");
}
System.out.println();
（26）内循环再来一轮 j=1,j=2,j=3,j=4,j=5 打印5个*
（27）System.out.println();
（28）执行外循环的迭代语句i++ i=3
。。。。。。
*/
}
}
练习
/*
9、一个数如果恰好等于它的因子之和，这个数就称为"完数"。（因子：除去这个数本身的约数）
例如6=1＋2＋3.编程 找出1000以内的所有完数
*/
class Test17_Exer9{
public static void main(String[] args){
//找出1000以内的所有完数
for(int i=1; i<1000; i++){
//判断i是否是完数，如果是就打印i
/*
完数？
一个数如果恰好等于它的因子之和
例如：6的因子：1,2,3
1,2,3,6是6的约数，能够把6给整除了
因子：除了6本身以外的约数
例如：18的因子：1,2,3,6,9
如何判断i是否是完数？
（1）先找出i的所有的因子，并且累加它的所有的因子
（2）判断因子之和与i是否相等，如果相等就是完数
*/
//（1）先找出i的所有的因子，并且累加它的所有的因子
int iSum = 0;
for(int j=1; j<i; j++){
//如果j能够把i整除了，j就是i的因子
if(i%j==0){
iSum += j;
}
}
//（2）判断因子之和与i是否相等，如果相等就是完数
if(i == iSum){
System.out.println(i);
}
}
}
}
找素数（质数）
找出1-100之间所有的素数（质数）
//12、找出1-100之间所有的素数（质数）
class Test18_Exer12{
public static void main(String[] args){
//找出1-100之间所有的素数（质数）
//1-100之间
for(int i=1; i<=100; i++){
//里面的代码会运行100遍
//每一遍i的值是不同的，i=1,2,3,4,5...100
//每一遍都要判断i是否是素数，如果是，就打印i
/*
如何判断i是否是素数
（1）找出i的所有的约数，并累加它们的和
例如：
i=5，它的约数有1和5，约数和：6
i=11，它的约数有1和11，约数和：12
i=18，它的约数有1,2,3,6,9,18，约数和：39
（2）如果某个i的约数和 == i+1，那么i就是素数
*/
//（1）找出i的所有的约数，并累加它们的和
int iSum = 0;
for(int j=1; j<=i; j++){
if(i%j==0){
//j是i的约数
iSum += j;
}
}
//（2）如果某个i的约数和 == i+1，那么i就是素数
if(iSum == i+1){
System.out.println(i);
}
}
}
}
//12、找出1-100之间所有的素数（质数）
class Test18_Exer12_2{
public static void main(String[] args){
//找出1-100之间所有的素数（质数）
//1-100之间
for(int i=1; i<=100; i++){
//里面的代码会运行100遍
//每一遍i的值是不同的，i=1,2,3,4,5...100
//每一遍都要判断i是否是素数，如果是，就打印i
/*
如何判断i是否是素数
（1）找出i在[2,i-1]之间的约数的个数
（2）如果这个个数是0，那么i就是素数
*/
int iCount = 0;
for(int j=2; j<i; j++){
if(i%j==0){//j是i在[2,i-1]之间的约数
iCount++;
}
}
//（2）如果这个个数是0，那么i就是素数
if(iCount == 0){
System.out.println(i);
}
}
}
}
//12、找出1-100之间所有的素数（质数）
class Test18_Exer12_3{
public static void main(String[] args){
//找出1-100之间所有的素数（质数）
//1-100之间
for(int i=1; i<=100; i++){
//里面的代码会运行100遍
//每一遍i的值是不同的，i=1,2,3,4,5...100
//每一遍都要判断i是否是素数，如果是，就打印i
/*
如何判断i是否是素数
（1）假设i是素数
boolean flag = true;//true代表素数
（2）找i不是素数的证据
如果在[2,i-1]之间只要有一个数能够把i整除了，说明i就不是素数
修改flag = false;
（3）判断这个flag
*/
//（1）假设i是素数
boolean flag = true;//true代表素数
//（2）找i不是素数的证据
for(int j=2; j<i; j++){
if(i%j==0){
flag = false;//找到一个就可以了
break;
}
}
//（3）判断这个flag
if(flag){
System.out.println(i);
}
}
}
}
