流程控制语句结构

流程控制语句结构分为：

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的变量 inputSystem.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 + "是偶数");elseSystem.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 == 100score >= 90 && score <=99我可以这样score == 100score >=90score >=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 <= num3num1 <= num3 <= num2num2 <= num1 <= num3num2 <= num3 <= num1num3 <= num2 <= num1num3 <= 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);//按位或运算符 15switch(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初始化为dayint 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++){//每次循环的步幅是1if(i%2==0){System.out.println(i);}
}//遍历1-100之间的偶数
for(int i=2; i<=100; i+=2){//每次循环的步幅是2System.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){//forifor (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-100for(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;//需要重复执行的语句，累加每一个ii++;}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，// 如果相等，就输出iif(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，//   如果相等，就输出iif(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循环到150for(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...whiledo...while循环与for和while的最大区别：它的循环体语句块是至少执行一次。
*/
class Test08_DoWhile{public static void main(String[] args){/*3、从键盘输入整数，输入0结束，统计输入的正数、负数的个数。*///从键盘输入整数=>java.util.Scannerjava.util.Scanner input = new java.util.Scanner(System.in);int num;//声明提升到外面的目的，是为了在do{}外面仍然可以使用numint 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!=0System.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...whiledo...while循环与for和while的最大区别：它的循环体语句块是至少执行一次。
*/
class Test08_DoWhile_For{public static void main(String[] args){/*3、从键盘输入整数，输入0结束，统计输入的正数、负数的个数。*///从键盘输入整数=>java.util.Scannerjava.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!=0System.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...whiledo...while循环与for和while的最大区别：它的循环体语句块是至少执行一次。
*/
class Test08_DoWhile_While{public static void main(String[] args){/*3、从键盘输入整数，输入0结束，统计输入的正数、负数的个数。*///从键盘输入整数=>java.util.Scannerjava.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!=0System.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:随机整数：-884011449double 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和2continue;}System.out.println(i);}}
}

求最大公约数和最小公倍数

/*
7、输入两个正整数m和n，求其最大公约数和最小公倍数
*/
//要考虑多多的  别那么肤浅   垃圾
class Test14_Exer7{public static void main(String[] args){//输入两个正整数m和njava.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,39和18，公约数：1,3,95和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*nfor(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,31,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，约数和：6i=11，它的约数有1和11，约数和：12i=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）判断这个flagif(flag){System.out.println(i);}}}
}

【Java】流程控制 - 顺序结构、 选择（分支）结构(单分支、双分支、多分支、嵌套)、循环结构（for、while、do...while)、跳转语句（break、continue）相关推荐

1. Java入门之顺序、选择、循环结构

   Java入门之顺序.选择.循环结构 顺序结构: package com.LynnStudy.scanner; import java.util.Scanner; /*** @Author hql* @ ...

2. 狂神说学习笔记 Java流程控制

   目录 Java流程控制 1.用户交互Scanner Scanner对象 next() nextLine(): 2.顺序结构 3.选择结构 4.循环结构 5.Break & Continue 6 ...

3. Java基础教程【第四章：Java流程控制】

   章节目录 1. 顺序结构 2. 分支语句 2.1 if 语句 2.2 if-else 语句 2.3 if-else if - -else语句 2.4 Switch 语句 3. 循环语句 3.1 whi ...

4. 流程控制语句—顺序、选择、循环

   流程控制语句-顺序.选择.循环 1.  概述 在一个程序执行的过程中,各条语句的执行顺序对程序的结果是有直接影响的.也就是说程序的流程对运行结果有直接的影响.在清楚每条语句的执行流程的前提下,才能通过 ...

5. JAVA流程控制(2021-07-11)

   Java流程控制 图片来源 01 用户交互Scanner public class demo01 {public static void main(String[] args) {//创建一个扫描器对 ...

6. 【四】Java流程控制

   Java流程控制 1. 顺序结构 2. 选择结构 3. 循环结构 `while` 语法 `do-while`循环语法: `for` 循环 三种循环结构的应用场景 `break` 跳出循环 `conti ...

7. Java流程控制相关知识（四）

   Java流程控制 1.用户交互Scanner Scanner对象 Java提供了一个工具,我们可以获取用户的输入.java.util.Scanner 是 Java5 的新特征,我们可以通过Scanne ...

8. java 流程控制_Java流程控制

   依旧是用Xmind来显示Java流程控制的大致内容: ---------------------------------------------------- Variable举例: public c ...

9. 《快乐编程大本营》java语言训练班-第4课:java流程控制

   <快乐编程大本营>java语言训练班-第4课:java流程控制 第1节. 顺序执行语句 第2节. 条件分支语句:if条件语句 第3节. 条件分支语句:switch 条件语句 第4节. 条件 ...

10. Java流程控制和方法

    文章目录 顺序结构 选择结构 if选择结构 switch选择结构 循环结构 while结构 do-while结构 for结构 增强型for循环 循环嵌套 break/continue关键字 方法 设计 ...

最新文章

1. 1093 Count PAT‘s (25 分)【难度: 一般 / 知识点: 前缀和 组合数】
2. javascript设计模式实践之模板方法--具有百叶窗切换图片效果的JQuery插件（二）...
3. 安装visual studio 2013--【转】
4. 盗取cookie终极代码
5. Android 自定义 ListView 显示网络上 JSON 格式歌曲列表
6. 用python写的简单的http文件服务器demo
7. java从哪学到哪_Java JVM怎么学习啊？从哪方面入手?
8. oracle 表 上限,Oracle分区表(Partition Table)的数量限制
9. 互联网晚报 | 3月1日 星期二 |​ 2022年苹果可能推出三款Apple Watch；“国家中小学智慧教育平台”投入试运行...
10. 自定义搜索框，带提示信息的搜索框
11. 训练集，验证集，测试集比例
12. 八年测开经验面试28K公司后，吐血整理出高频面试题和答案
13. 项目部署：IIS部署后运行报错iconfont.woff:1 Failed to load resource: the server responded with a status of 404
14. Hadoop完全分布式 小bug -no.1 为啥我的集群只显示一个datanode！
15. 计算机二级vb上机操作题库,全国计算机二级VB上机题库(题+答案)word版
16. mysql 表 忽略大小写_mysql表名忽略大小写配置方法详解
17. 厦门大学LaTeX毕业论文模板：中英文双目录
18. 从零开始学习区块链技术
19. w ndows无法完成格式化,windows无法完成格式化,小编教你解决windows无法完成格式化U盘...
20. sql 数据存在包含关系的查询

热门文章

1. FormatDateTime
2. 杨森翔的书法作品【行书、爨体、隶书等作品】
3. 艾美捷细胞失巢凋亡检测试剂盒测定原理
4. 数据解析——BeautifulSoup
5. 解决 驱动创建设备节点时 权限为 root只读只写 的问题
6. 红松获亿元融资，中老年在线兴趣社区会是一门“朝阳”生意么？
7. php开启pathinfo 模式
8. SOA推动电信服务走向融合应用
9. IT男的”幸福”生活续1
10. 菌群在发酵过程中如何动态演替