一、流程控制概述
在Java程序中，JVM默认总是顺序执行以分号;结束的语句。但是，在实际的代码中，程序经常需要做条件判断、循环，因此，需要有多种流程控制语句，来实现程序的跳转和循环等功能。
流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。
其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：
顺序结构
分支结构
循环结构
二、顺序结构
顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。
总的来说：程序按照从上到下的顺序执行。
Java顺序结构示例代码：
public class Order {
public static void main(String[] args) {
System.out.println(1);
System.out.println(2);
System.out.println(3);
}
}三、分支结构
根据条件，选择性地执行某段代码。
有if…else和switch-case两种分支语句。
3.1 if单分支语句
语法:
if(条件表达式){
语句块;
}
解释:
条件表达式结果为boolean类型，当表达式结果为true,则执行语句块;否则什么都不执行！
当语句块只有一条执行语句时，一对{}可以省略，但建议保留。
Java if单分支示例代码：
public class IfTest {
public static void main(String[] args) {
int a = 10;
int b = 10;
if(a > b){
System.out.println("a 大于 b");
}
System.out.println("-------------");
if(a==b){
System.out.println("a 等于 b");
}
}
}练习题:
张浩Java成绩大于98分，而且音乐成绩大于80分，老师奖励他；或者Java成绩等于100分，音乐成绩大于70分，老师也可以奖励他.
public class Prize {
public static void main(String[] args) {
int score1 = 100; // 张浩的Java成绩
int score2 = 72; // 张浩的音乐成绩
if ( ( score1 >98&& score2 > 80 )|| ( score1 == 100 && score2 > 70 ) ){
System.out.println("老师说:不错，奖励一个MP4！");
}
}
}3.2 if双分支语句
语法:
if(条件表达式){
语句块A;
}else{
语句块B;
}
解释:
条件表达式结果为boolean类型，当表达式结果为true,则执行语句块A;否则执行语句块B。
if-else语句结构，根据需要可以嵌套使用。
public class IfDemo {
public static void main(String[] args) {
int a = 10;
int b = 10;
if(a == b){
System.out.println("a 等于 b");
}else{
System.out.println("a 不等于 b");
}
System.out.println("---------------");
if(a > b){
System.out.println("a 大于 b");
}else{
System.out.println("a 不大于 b");
}
System.out.println("---------------");
int age = 3;
if(age >= 3 && age < 6){
System.out.println("符合入园年龄，可以报名。");
}else{
System.out.println("赶紧去上小学把。");
}
}
}练习题：
如果张浩Java考试成绩大于98分，老师就奖励他一个MP4，否则老师就罚他进行编码。
public class SimpleIf {
public static void main(String[] args) {
int score = 91; // 张浩的Java成绩
if (score > 98) {
System.out.println("老师说:不错，奖励一个MP4！");
} else {
System.out.println("老师说:惩罚进行编码！");
}
}
}3.3 if多分支语句
语法：
if(条件表达式A){
语句块A;
}else if(条件表达式B){
语句块B;
}...
else if(条件表达式N){
语句块N;
}else{
语句块N+1
}
解释:
所有的条件表达式结果都是boolean类型。
如果条件表达式A结果为true,则执行语句块A，否则去判断条件表达式B；
如果条件表达式B结果为true,则执行语句块B，否则去判断条件表达式C；
....
如果所有的条件表达式结果都为false,则执行语句块N+1
else是可选的，根据需要可以省略
注：
当多个条件是“互斥”关系(没有交集)时，条件判断语句及执行语句间顺序无所谓
当多个条件是“非互斥”关系(有交集)时，需要根据实际情况，考虑如何定义顺序。
当多个条件是“包含”关系时，“小上大下 / 子上父下”
为什么使用多重if选择结构?
问题:对学员的结业考试成绩评测
成绩大于等于90时，评估结果为：优秀
成绩为(80-89)时，评估结果为：良好
成绩为(60-79)时，评估结果为：中等
成绩小于60时，评估结果为：差
分析：将成绩分成几个连续区间判断。使用单个if选择结构无法完成，使用多个if选择结构很麻烦 ，所以要使用多重if选择结构。
int score = 70; //考试成绩
if ( score >= 90 ) {
System.out.println("优秀");
} else if (score >= 80 ) {
System.out.println("良好");
} else if (score >= 60 ) {
System.out.println("中等");
} else {
System.out.println("差");
}练习题：
我想买车，买什么车决定于我在银行有多少存款
如果我的存款超过500万，我就买凯迪拉克
否则，如果我的存款超过100万，我就买帕萨特
否则，如果我的存款超过50万，我就买依兰特
否则，如果我的存款超过10万，我就买奥托
否则，我买捷安特
请从键盘输入我的存款，并加以判断
需要Scanner类
1、导包，Scanner类在java.util.Scanner包下
2、实例化Scanner对象
3、调用Scanner类相关API，获取相应类型的变量
注：如果输入类型不匹配，会抛出异常！
// 扫描器类
Scanner input = new Scanner(System.in);
// 输入int类型的值
int money = input.nextInt(); // 我的存款，单位：万元
// 判断
if (money >= 500) {
System.out.println("太好了，我可以买凯迪拉克");
} else if (money >= 100) {
System.out.println("不错，我可以买辆帕萨特");
} else if (money >= 50) {
System.out.println("我可以买辆依兰特");
} else if (money >= 10) {
System.out.println("至少我可以买个奥托");
} else {
System.out.println("看来，我只能买个捷安特了");
}练习题：
定义三个int型变量并赋值，使用三元运算符或者if-else获取这三个数中的较大数的实现
// 声明三个变量并赋值
int num1 = 10,num2 = 20,num3 = -5;
// 声明max变量，根据判断赋值
int max;
if(num1 >= num2 && num1 >= num3){
max = num1;
}else if(num2 >= num1 && num2 >= num3){
max = num2;
}else{
max = num3;
}练习题：
编写一个程序，获取用户输入的狗的年龄，通过程序显示其相当于人类的年龄。如果用户输入负数，请显示一个提示信息。
算法：狗的前两年每一年相当于人类的10.5岁，之后每增加一年就增加四岁。
int dogAge = 7;
if(dogAge >= 0 && dogAge <= 2){
System.out.println("相当于人的年龄：" + dogAge * 10.5);
}else if( dogAge > 2){
System.out.println("相当于人的年龄：" + (2 * 10.5 + (dogAge - 2) * 4));
}else{
System.out.println("狗狗还没出生呢！");
}3.4 嵌套if
为什么使用嵌套if？
问题：学校举行运动会，百米赛跑跑入10秒内的学生有资格进决赛，根据性别分别进入男子组和女子组。
分析：
要判断是否能够进入决赛。
在确定进入决赛的情况下，还要判断是进入男子组，还是进入女子组。
解决：
使用嵌套if选择结构
语法参考：
if（条件1) {
if（条件2) {
代码块1
} else {
代码块2
}
} else {
代码块3
}
if(score <= 10){
if(gender.equals("男")){
System.out.println("进入男子组决赛！");
}else if(gender.equals("女")){
System.out.println("进入女子组决赛！");
}
}else{
System.out.println("淘汰！");
} 为了使 if 结构更加清晰、避免执行错误，应该把每个 if 或 else 包含的代码块都用大括号括起来；
相匹配的一对 if 和 else 应该左对齐；
内层的 if 结构相对于外层的 if 结构要有一定的缩进；
3.5 switch语句
语法:
switch(表达式){
case 值1:
语句块1;
break;
.....
case 值N:
语句块N;
break;
default:
语句块default;
}
解释:
根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或switch-case结构末尾结束为止。
表达式在这里其实是一个值：但是必须是byte,short,int,char,枚举类型(JDK5.0新增)、String(JDK7.0新增)其中的一种。
break不是语法中固定的，可以加也可以不加，但是如果为了打断switch的贯穿性，需要结合break使用。
default块顺序可以变动，但要注意其执行顺序。通常，default块放在末尾，也可以省略；但是如果default放在前面,推荐添加break;
case的顺序无所谓，case 之后只能声明常量，不能声明范围。
程序会使用表达式值从上到下跟case后面的值进行比较，如果相等，则执行对应的语句块，否则继续向后对比；
如果都不相等，则执行default。
import java.util.Scanner;
public class SwitchDemo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("只能输入1,2,3：");
int a = sc.nextInt();
switch(a){
case 1:
System.out.println("one");
break;
case 2:
System.out.println("two");
break;
case 3:
System.out.println("three");
break;
default:
System.out.println("输入错误,请重新输入");
}
}
}练习题：
韩嫣参加计算机编程大赛
如果获得第一名，将参加麻省理工大学组织的1个月夏令营
如果获得第二名，将奖励惠普笔记本电脑一部
如果获得第三名，将奖励移动硬盘一个
否则，不给任何奖励
该问题属于等值判断，解决方法：
使用多重if选择结构实现
使用switch选择结构解决
int mingCi = 1;
switch (mingCi) {
case 1:
System.out.println("参加麻省理工大学组织的1个月夏令营");
break;
case 2:
System.out.println("奖励惠普笔记本电脑一部");
break;
case 3:
System.out.println("奖励移动硬盘一个");
break;
default:
System.out.println("没有任何奖励 ");
}下列语句的执行结果
int mingCi = 1;
switch (mingCi){
case 1:
System.out.println("参加麻省理工大学组织的1个月夏令营");
case 2:
System.out.println("奖励惠普笔记本电脑一部");
case 3:
System.out.println("奖励移动硬盘一个");
default:
System.out.println("没有任何奖励 ");
}
//如果需要每个case执行完后跳出，在每个case后不要忘记写break;练习题：
对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。
注：switch-case结构来实现；
int score = 78;
switch(score / 10){
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
System.out.println("不及格");
break;
case 6:
case 7:
case 8:
case 9:
case 10:
System.out.println("及格");
break;
}
//更优的解决方案：
switch(score / 60){
case 0:
System.out.println("不及格");
break;
case 1:
System.out.println("及格");
break;
}3.6 比较switch和多重if选择结构
相同点
都是用来处理多分支条件的结构
不同点
switch选择结构:只能处理等值条件判断的情况，而且条件必须是整型变量或字符型变量
多重if选择结构:没有switch选择结构的限制，特别适合某个变量处于某个连续区间时的情况
if 在应用中更为常见,有时switch 结构更清晰.
注：凡是可以使用switch-case的结构，都可以使用if-else；反之不成立。
四、循环结构
在某些条件满足的情况下，反复执行特定代码的功能
有while、do…while、for三种循环语句。
注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素。
4.1 循环分类
顺序结构或分支结构的程序语句只能 被执行一次。如果你要同样的操作执行多次，就需要使用循环结构。
执行一些需要重复的操作时,要用到循环流程.
在现实与程序中会大量的用到循环流程 .
设想:
小明为了表示对JAVA的喜欢,想要写100句 “ JAVA我爱你! ”
1遍: System.out.println(“JAVA我爱你!”);
2遍: System.out.println(“JAVA我爱你!”);
... ...
100遍: System.out.println(“JAVA我爱你!”);
如果是1万遍呢?
1遍: System.out.println(“JAVA我爱你!”);
2遍: System.out.println(“JAVA我爱你!”);
....
7777遍... ...
小明工作了一天,累成狗,老板还不满意他的工作...
循环语句分类
while循环
do-while循环
for循环
单层for循环
双层for循环
增强for循环(foreach)
嵌套循环
循环语句的四个组成部分
初始化部分(init_statement)
循环条件部分(test_exp)
循环体部分(body_statement)
迭代部分(alter_statement)
4.2 while循环
语法：
①初始化部分
while(②循环条件部分)｛
③循环体部分;
④迭代部分;
}
执行过程：
①-②-③-④-②-③-④-②-③-④-...-②
解释：
条件表达式返回值类型为boolean类型，只要条件表达式的结果为true,则一直执行语句块。
特点：先判断，再执行
注：
不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环。
for循环和while循环可以相互转换,区别点：for循环和while循环的初始化变量作用域不同。
public class WhileLoop {
public static void main(String[] args) {
int sum = 0;
int i = 1;
while(i <= 10){
sum += i;
i++;
}
System.out.println("sum:"+sum);
}
}练习题:
问题:如何用程序描述下面这个故事呢？
为了帮助张浩尽快提高成绩，老师给他安排了每天的学习任务，
其中上午阅读教材，学习理论部分，下午上机编程，掌握代码部分。
老师每天检查学习成果。如果不合格，则继续进行
分析:使用while循环的步骤
1、分析循环条件和循环操作
2、套用while语法写出代码
3、检查循环是否能够退出
System.out.print("合格了吗?(y/n)：");
String answer = input.next();
while(answer.equals("y") == false){
System.out.println("上午阅读教材！");
System.out.println("下午上机编程！\n");
System.out.print("合格了吗?(y/n)：");
answer = input.next();
}
System.out.println("完成学习任务！");4.3 do…while循环
语法：
①初始化部分;
do{
③循环体部分
④迭代部分
}while(②循环条件部分);
执行过程：
①-③-④-②-③-④-②-③-④-...②
解释：
先执行do对应的语句块，然后再判断循环条件，只要循环条件满足，则一直执行循环体，否则结束循环。
特点：先执行，再判断;do-while循环至少执行一次循环体。
public class DoWhileLoop {
public static void main(String[] args) {
int sum = 0;
int i = 1;
do{
sum+=i;
i++;
}while(i<=10);
System.out.println("sum:"+sum);
}
}为什么需要do-while循环?
经过几天的学习，老师给张浩一道测试题，
让他先上机编写程序完成，
然后老师检查是否合格。如果不合格，则继续编写。……
do{
System.out.println("上机编写程序！");
System.out.print("合格了吗?(y/n)");
answer = input.next();
System.out.println("");
}while(!"y".equals(answer));
System.out.println("恭喜你通过了测试！");while和do while的区别?
执行次序不同:
while先判断，再执行;do while先执行，再判断
初始情况不满足循环条件时:
while循环一次都不会执行
do-while循环不管任何情况都至少执行一次
int number1 = 10;
while(number1 > 10){
System.out.println("hello:while");
number1--;
}
int number2 = 10;
do{
System.out.println("hello:do-while");
number2--;
}while(number2 > 10);4.4 for循环
语法:
for( ①初始化循环条件; ②循环条件表达式 ; ④迭代部分 ){
③循环操作(循环体);
}
执行过程:
①-②-③-④-②-③-④-②-③-④-.....-②
解释:
1、先执行初始化循环条件
2、使用初始表达式值进行条件判断,如果判断为true,则执行循环操作;否则结束循环
3、进行迭代
4、循环迭代可以在()里面省略,在循环体里面进行迭代也可。
练习题：
循环输入某同学结业考试的5门课成绩，并计算平均分
1、分析循环条件和循环操作
2、套用for语法写出代码
3、检查循环是否能够退出
// 定义sum,用来存储叠加求和
int sum = 0;
// 循环5次录入5门课成绩
for(int i = 0; i < 5; i++){
System.out.print("请输入5门功课中第" + (i+1) + "门课的成绩： ");
score = input.nextInt(); //录入成绩
sum = sum + score; //计算成绩和
}
// 计算平均分
avg = sum / 5;
System.out.println(name + "的平均分是：" + avg);三种循环对比：
执行顺序
先判断,后执行: while 和 for
先执行,后判定: do-while
适用
循环次数确定: 一般使用for
循环次数不确定: 一般使用while 和 do-while
4.5 循环嵌套
将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while均可以作为外层循环或内层循环。
实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。
// 打印五颗星 *****
// System.out.println("*****");
for (int i = 1; i <= 5; i++) {
System.out.print('*');
}
System.out.println("\n");
/*
打印五次五颗星,如果定义五次上述代码,显然不太好;
那么就把上述代码,再放到一个循环结构中,就是嵌套循环
*****
*****
*****
*****
*****
*/
for (int j = 1; j <= 5; j++) {
for (int i = 1; i <= 5; i++) {
System.out.print('*');
}
System.out.println();
}打印直角三角形：
/* i(行号) j(*的个数)
* 1 1
** 2 2
*** 3 3
**** 4 4
***** 5 5
*/
for (int i = 1; i <= 5; i++) {//控制行数
for (int j = 1; j <= i; j++) {//控制列数
System.out.print("*");
}
System.out.println();
}打印倒直角三角形：
/* i(行号) j(*的个数) 规律：i + j = 5 换句话说：j = 5 - i;
**** 1 4
*** 2 3
** 3 2
* 4 1
*/
for (int i = 1; i <= 4; i++) {
for (int j = 1; j <= 5 - i; j++) {
System.out.print("*");
}
System.out.println();
}打印等腰三角形
/*
1 * 4个空格
2 *** 3个空格
3 ***** 2个空格
4 ******* 1个空格
5 *********
*/
for (int i = 1; i <= 5; i++) {
for (int j = 5; j >= i; j--) {
System.out.print(" ");
}
for (int j = 1; j <= i * 2 - 1; j++) {
System.out.print("*");
}
System.out.println();
}总结规律:
第一个(外层)for循环作用：控制行数
第二个(内层)for循环作用：控制列数
五、流程跳转
break 用于do-while、while、for、switch中时，可跳出循环而执行循环后面的语句
continue 用在循环中,跳过本次循环,执行下一次循环.
5.1 break
语法：
循环(…) {
……
break;
……
}
解释：
break语句用于终止某个语句块的执行
break通常在循环中与条件语句一起使用
public class BreakTest {
public static void main(String args[]) {
for (int i = 0; i < 10; i++) {
if (i == 3)
break;
System.out.println(" i = " + i);
}
}
}练习题：
问题：循环录入某学生5门课的成绩并计算平均分，如果某分数录入为负，停止录入并提示录入错误
分析：循环录入成绩，判断录入正确性：录入错误，使用break语句立刻跳出循环；否则，累加求和
public class BreakTest {
public static void main(String args[]) {
Scanner input = new Scanner(System.in);
// 记录总分
int sum = 0;
// 循环5次录入5门课成绩
for (int i = 0; i < 5; i++) {
System.out.print("请输入第" + (i + 1) + "门课的成绩： ");
int score = input.nextInt();
// 输入负数
if (score < 0) {
break;
}
// 累加求和
sum = sum + score;
}
System.out.println("学生5门课的平均分是:" + sum / 5);
}
}5.2 continue
语法：
循环(...){
....
continue;
....
}
解释：
continue只能使用在循环结构中
continue语句用于跳过其所在循环语句块的一次执行，继续下一次循环
continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环
public class ContinueTest {
public static void main(String args[]) {
for (int i = 0; i < 10; i++) {
if (i == 3)
continue;
System.out.println(" i = " + i);
}
}
}练习题：
循环录入Java课的学生成绩，统计分数大于等于80分的学生比例
1、通过循环，获得分数大于等于80分的学生人数num
2、判断：如果成绩<80，不执行num++，直接进入下一次循环
public class ContinueTest {
public static void main(String args[]) {
Scanner input = new Scanner(System.in);
System.out.print("输入班级总人数:");
int total = input.nextInt();
// 统计80分以上学生数量
int num = 0;
// 循环输入学生成绩
for (int i = 0; i < total; i++) {
System.out.print("请输入第" + (i + 1) + "位学生的成绩： ");
int score = input.nextInt();
if (score < 80) {
continue;
}
num++;
}
System.out.println("80分以上的学生人数是： " + num);
double rate = (double) num / total * 100;
System.out.println("80分以上的学生所占的比例为：" + rate + "%");
}
}5.3 多层循环跳转
嵌套循环时: 内循环可以使用外循环中的变量，外循环每循环一次,内循环都会重新循环,并循环完内循环的所有次。
break/continue 只会控制当前的循环，可以使用给循环设定标签的形式来控制循环.
label1: { ……
label2: { ……
label3: { ……
break label2;
……
}
}
}
5.4 return
return：并非专门用于结束循环的，它的功能是结束一个方法。当一个方法执行到一个return语句时，这个方法将被结束。
与break和continue不同的是，return直接结束整个方法，不管这个return处于多少层循环之内。
public class ReturnTest {
public static void main(String args[]) {
for (int i = 1; i <= 10; i++) {
for (int j = 1; j <= 10; j++) {
if (i + j == 15) {
return;
}
System.out.println("i = " + i + ",j = " + j + ",i + j = " + (i + j));
}
}
System.out.println("循环之后的语句");
}
}5.5 三者对比
break和continue对比：
使用场合不同
break可用于switch结构和循环结构中。
continue只能用于循环结构中。
作用不同（循环结构中）
break语句终止某个循环，程序跳转到循环块外的下一条语句。
continue跳出本次循环，进入下一次循环。
注：很多语言都有goto语句，goto语句可以随意将控制转移到程序中的任意一条语句上，然后执行它。但使程序容易出错。Java中的break和continue是不同于goto的
continue、break、return三者对比：
continue：
跳过本次循环，继续下一次循环
break：
结束所在的循环。
return：
结束整个方法
六、课后练习题
6.1 程序题
1、下面程序的输出结果
public class OperatorTest {
public static void main(String[] args) {
boolean x = true;
boolean y = false;
short z = 40;
if ((z++ == 40) && (y = true)) {
z++;
}
if ((x = false) || (++z == 43)) {
z++;
}
System.out.println("z = " + z);
}
}
// 运行结果：z = 442、编写程序：由键盘输入三个整数分别存入变量num1、num2、num3，对它们进行排序(使用 if-else if-else)，并且从小到大输出。
Scanner scanner = new Scanner(System.in);
System.out.println("请输入第一个整数：");
int num1 = scanner.nextInt();
System.out.println("请输入第二个整数：");
int num2 = scanner.nextInt();
System.out.println("请输入第三个整数：");
int num3 = scanner.nextInt();
if(num1 >= num2){
if(num3 >= num1)
System.out.println(num2 + "," + num1 + "," + num3);
else if(num3 <= num2)
System.out.println(num3 + "," + num2 + "," + num1);
else
System.out.println(num2 + "," + num3 + "," + num1);
}else{
if(num3 >= num2)
System.out.println(num1 + "," + num2 + "," + num3);
else if(num3 <= num1)
System.out.println(num3 + "," + num1 + "," + num2);
else
System.out.println(num1 + "," + num3 + "," + num2);
}3、大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，当然要提出一定的条件：
高：180cm以上；富：财富1千万以上；帅：是。
如果这三个条件同时满足，则：“我一定要嫁给他!!!”
如果三个条件有为真的情况，则：“嫁吧，比上不足，比下有余。”
如果三个条件都不满足，则：“不嫁！”
Scanner scan = new Scanner(System.in);
System.out.println("请输入你的身高：(cm)");
int height = scan.nextInt();
System.out.println("请输入你的财富：(千万)");
double wealth = scan.nextDouble();
/*
方式一：
System.out.println("请输入你是否帅：(true/false)");
boolean isHandsome = scan.nextBoolean();
if(height >= 180 && wealth >= 1 && isHandsome){
System.out.println("我一定要嫁给他!!!");
}else if(height >= 180 || wealth >= 1 || isHandsome){
System.out.println("嫁吧，比上不足，比下有余。");
}else{
System.out.println("不嫁！");
}
*/
//方式二：
System.out.println("请输入你是否帅：(是/否)");
String isHandsome = scan.next();
if(height >= 180 && wealth >= 1 && isHandsome.equals("是")){
System.out.println("我一定要嫁给他!!!");
}else if(height >= 180 || wealth >= 1 || isHandsome.equals("是")){
System.out.println("嫁吧，比上不足，比下有余。");
}else{
System.out.println("不嫁！");
}4、题目：输入两个正整数m和n，求其最大公约数和最小公倍数。
比如：12和20的最大公约数是4，最小公倍数是60。
说明：break关键字的使用：一旦在循环中执行到break，就跳出循环。
Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个正整数：");
int m = scan.nextInt();
System.out.println("请输入第二个正整数：");
int n = scan.nextInt();
//获取最大公约数
//1.获取两个数中的较小值
int min = (m <= n)? m : n;
//2.遍历
for(int i = min;i >= 1 ;i--){
if(m % i == 0 && n % i == 0){
System.out.println("最大公约数为：" + i);
break;//一旦在循环中执行到break，就跳出循环
}
}
//获取最小公倍数
//1.获取两个数中的较大值
int max = (m >= n)? m : n;
//2.遍历
for(int i = max;i <= m * n;i++){
if(i % m == 0 && i % n == 0){
System.out.println("最小公倍数：" + i);
break;
}
}5、求出1-100之间偶数和、奇数和，并分别记录奇偶数的个数。
int evenSum = 0; // 偶数和
int evenCount = 0;
int oddSum = 0; // 奇数和
int oddCount = 0;
for(int i = 1;i <= 100;i++){
if(i % 2 == 0){ // 偶数
evenSum += i;
evenCount++;
}else{
oddSum += i;
oddCount++;
}
}
System.out.println("偶数和:"+evenSum+",偶数个数:"+evenCount);
System.out.println("奇数和:"+oddSum+",奇数个数:"+oddCount);6、1~10之间的整数相加，得到累加值大于20的当前数。
int sum = 0;
for(int i = 1;i <= 10;i++){
sum += i;
if(sum > 20){
// 1 + 2 + 3 + 4 + 5 + 6
System.out.println("当前和是:"+sum+",当前数是:"+i);
break;
}
}7、判断101-200之间有多少个素数，并输出所有素数。(只能被自己整除)
/*
* 判断101-200之间有多少个素数，并输出所有素数。(只能被自己整除)
* 质数又称素数。一个大于1的自然数，除了1和它自身外，不能被其他自然数整除的数叫做质数；否则称为合数。
* 判断素数的方法：用一个数分别去除2到 Math.sqrt(这个数)，如果能被整除，则表明此数不是素数，反之是素数。
* Math.sqrt(数值) 获取这个数值的平方根整数
* 1、使用for循环,确定了循环次数
* 初始值 101
* 条件 小于等于200
* 迭代 递增
* 2、循环体: 拿每一个值(i)从2开始做取余,一直到这个数值的平方根
* 循环体里需要定义内层循环
* 内层循环判断: 判断能不能被整除,如果能被整除，则表明此数不是素数，反之是素数
* */
int counter = 0;
for(int i = 101;i <= 200;i++){
// 循环变量i,就是我们需要进行判断处理的每个数值
// i到底是不是素数,需要内层循环都执行完毕才可以得出结论
boolean isFlag = true; // 先假定每个值(i)都是素数
for(int j = 2;j <= Math.sqrt(i);j++){
if(i % j == 0){
isFlag = false; // 如果可以被2 - 其平方根整除,那么假定不成立
break;
}
}
if(isFlag){
counter ++;
System.out.println(i);
}
}
System.out.println("素数个数是:"+counter);8、打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。
/*
* 打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。
* 1、"水仙花数"是指一个三位数,确定了取值范围,那么我们就使用for循环
* 初始值: 100
* 循环条件: 小于 1000
* 迭代: 递增
* 2、循环体: 打印出所有的"水仙花数"
* 判断: 各位数字立方和等于该数本身
* 153
* 1*1*1
* 5*5*5
* 3*3*3
* 百位: 数值/100 153/100 = 1
* 十位: 数值/10%10 153/10%10 = 5
* 各位: 数值%10 153%10 = 3
* */
for(int i = 100;i <= 999;i++){
int hundreds = i / 100; // 百位
int decade = i / 10 % 10; // 十位
int bits = i % 10; // 各位
int sum = hundreds * hundreds * hundreds + decade * decade * decade + bits * bits *bits;
if(sum == i){
System.out.println(i+"是水仙花数");
}
}9、输入一个正整数,将其分解质因数。例如：输入90,打印出90=2*3*3*5。
/*
* 输入一个正整数,将其分解质因数。例如：输入90,打印出90=2*3*3*5。
* 1、使用Scanner类从控制台输入一个正整数
* 输入一个数整数n;
* 2、用for循环从k=2开始一直遍历到k<=n; 使用for循环
* 3、用这个数n%k求余,判断是否等于0,并且k!=n；
* 4、如果条件成立，就输出k和*，并将n=n/k，k=1，重新遍历，直到k==n，就输出n，并跳出循环，程序结束
* */
Scanner input = new Scanner(System.in);
System.out.print("请输入一个正整数:"); // 90
int n = input.nextInt();
System.out.print(n+" = "); // 90 =
for(int k = 2;k <= n;k++){
if(n % k == 0 && k != n){
System.out.print(k + " * "); // 2 * 3 * 3 *
n /= k; // 45 15 5
k = 1;
}else if(k == n){
System.out.print(n); // 5
break;
}
}10、求10的阶乘(10*9*...*2*1)
int product = 1;
for(int i = 10;i > 1;i--){
product *= i;
}
System.out.println(product);11、在控制台输出九九乘法表。
for(int i = 1;i <= 9;i++){
for(int j = 1;j <= i;j++){
System.out.print(j + " * " + i + " = " + j * i+"\t");
}
System.out.println();
}12、我国最高山峰是珠穆朗玛峰：8848m，我现在有一张足够大的纸张，厚度为：0.01m。请问，我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度?
double end = 8848;
double start = 0.01;
int count = 0;
while(start < end){
count ++;
start *= 2;
}
System.out.println("纸张折叠了"+count+"次,高度是:"+start);6.2 简答题
1、流程控制的常见结构?
顺序结构: 最常见的结构化程序设计流程,从上到下一步步执行;
分支结构: 在某个节点,出现了多个分支流程;
循环结构: 执行一些需要重复的操作时,要用到循环流程.
2、Java分支结构语句有哪些?
if分支语句
if 单分支语句
if else 双分支语句
if else if 多分支语句
switch开关语句
3、Java的switch语句可以定义什么类型的值?
byte,short,char,int,String,枚举enum其中的一种。
注:枚举是jdk1.5之后支持的,String是jdk1.7之后才支持的;
4、switch语句和多重if语句的区别?
相同点
都是用来处理多分支条件的结构;
不同点
switch选择结构:只能处理等值条件判断的情况，而且条件必须是整型变量或字符串型变量;
多重if选择结构:不仅可以做等值比较也可以做区间值比较，特别适合某个变量处于某个连续区间时的情况;而且条件没有类型限制;
if 在应用中更为常见,有时switch 结构更清晰。
5、为什么0.1 + 0.2 = 0.30000000000000004?
十进制数在进行运算的时候,会转换为二进制进行运算,运算完成之后在转换为十进制;
在小数运算转换过程中,可以出现误差;
6、Java循环语句有哪些?
while循环
do-while循环
for循环
普通for循环
增强for循环(foreach)
7、Java循环语句四要素?
初始化部分(init_statement)
循环条件部分(test_exp)
循环体部分(body_statement)
迭代部分(alter_statement)
8、结束循环的两种方式?
1、循环条件不成立,结束循环
2、在循环体内部,满足某种条件,使用break强制结束循环
9、while 和 do while的区别?
两者都是用来实现循环结构的;
while是先判断后执行; do while是先执行一次后判断;
如果初始条件成立,那么while和do while的执行结果一致;
如果初始条件不成立,那么while什么都不执行,do while至少执行一次;
10、for循环 和 while循环的区别?
两者都是用来实现循环结构的;
语法定义不同:
while循环,循环三要素定义在不同的地方;初始部分定义在循环外,条件定义在while后面的(),迭代定义在循环体;
for循环,循环三要素都定义在for循环后面的(),使用;分割
使用场景不同:
while 用于不确定循环次数的场合;
for 用于确定循环次数的场合;
初始变量的作用域不同:
while的初始变量在循环外都可以使用;
for循环的初始变量只能在for的循环体中;
11、for循环、while循环、do while循环的使用场景?
while 用于不确定循环次数的场合;
do while 用于至少执行一次的场合;
for 用于确定循环次数的场合;
12、break和continue的区别?
使用场合不同
break可用于switch结构和循环结构中
continue只能用于循环结构中
return 只能用于方法中
作用不同
break语句终止某个循环，程序跳转到循环块外的下一条语句。
continue跳出本次循环，进入下一次循环
return 用来定义方法返回值或结束方法；
13、如果有循环多层嵌套,怎么结束指定循环?
break写在哪个循环里面,就是结束哪个循环;
如果想要结束指定循环,我们可以给循环打标记,使用break 标记名; 结束指定循环
f1:for(int i = 1;i <= 10;i++){
for(int j = 1;j <= 10;j++){
if(i + j == 15){
// break; // break是结束内层循环
break f1; // 结束指定循环
}
System.out.println(i+" "+j);
}
}
