• 程序流程控制是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。
• 其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：
>顺序结构
程序从上到下逐行执行，中间没有任何判断和跳转。
>分支结构
根据条件，选择性地执行某段代码。
有if...else和switch-case两种分支语句。
>循环结构
根据循环条件，重复性的执行某段代码。
有while、do...while、for三种循环语句。
注意：JDK1.5提供了foreach循环，方便的遍历集合、数组元素。
分支结构
if-else结构
使用说明：
• 条件表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量
• 语句块只有一条执行语句时，一对{}可以省略，但建议保留
• if-else语句结构，根据需要可以嵌套使用
• 当if-else结构是”多选一“时，最后else是可选的，根据需要可以省略
• 当多个条件是“互斥”关系时，条件判断语句执行语句见顺序无所谓
当多个条件是“包含”关系时，“小上大下/子上父下”
• else就近原则
• if的三种格式：
class IfText1{
public void main(String[] args){
//举例一：
int heartBeats = 79;
if(heartBeats < 60 || heartBeats > 100){
System.out.println("需要做进一步调查");
}
System.out.println("检查结束");
//举例二：
int age = 23;
if(age < 18){
System.out.println("你可以看动画片");
}else{
System.out.println("你可以看电视剧");
}
}
}
//举例三：
class IfText1{
public void main(String[] args){
int age = 23;
if(age < 0){
System.out.println("您输入的数据违法");
}else(age < 18)if{
System.out.println("青少年时期");
}else(age < 35)if{
System.out.println("青壮年时期");
}else(age < 60)if{
System.out.println("中年时期");
}else(age < 120)if{
System.out.println("老年时期");
}else{
System.out.println("你要成仙了！");
}
}
}
面试题：
class OperatorText{
public static void main(String[] args){
boolean x = true;
boolean y = false;
short z = 40;
// 41 true true
if((z++ == 40) && (y = true){
z++;
}//false 43
if((x = false) || (++z == 43)){
z++;//44
}
System.out.println("z=" + z);//结果：44
}
}
1.定义三个int型变量并赋值，使用三元运算符或if-else获取这三个数中的较大数的实现
class ThreeInt{
public static void main(String[] args){
int num1 = 10,num2 = 21,num3 = -21;
int max;
if (num1 >= num2 && num2 >= num3) {
max = num1;
}else if (num2 >=num1 && num1 >= num3) {
max = num2;
}else{
max = num3;
}
System.out.println("较大数为：" + max);
}
}
2由键盘输入三个整数分别存入变量num1、num2、num3，对它们进行排序（使用if-else if-else），并且从小到大输出.
import java.util.Scanner;
class ThreeText1{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个整数");
int num1 = scan.nextInt();
System.out.println("请输入第二个整数");
int num2 = scan.nextInt();
System.out.println("请输入第三个整数");
int num3 = scan.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.岳小鹏参加Java考试，他和父亲岳不群达成承诺：
如果：成绩为100分时，奖励一辆BMW；
成绩为（80，99]时，奖励一台iPhone xs max;
当成绩为[60,80]时，奖励一个iPad；
其它时，什么奖励也没有。请从键盘输入岳小鹏的期末成绩，并加以判断
import java.util.Scanner;
class IfText{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请输入岳小鹏期末成绩：（0-100）");
int score = scan.nextInt();
if(score == 100){
System.out.println("奖励一台BMW");
}else if(score > 80 && score <= 99){
System.out.println("奖励一台iPhone xs max");
}else if(score >= 60 && score <= 80){
System.out.println("奖励一个iPad");
}else{
System.out.println("什么奖励也没有");
}
}
}
4.彩票游戏：
假设你想开发一个玩彩票的游戏，程序随机地产生一个两位数的彩票，提示用户输入一个两位数，然后按照下面的规则判断用户是否能赢。
1）如果用户输入的数匹配彩票的实际顺序，奖金10000美元。
2）如果用户输入所有数字匹配彩票的所有数字，但顺序不一致，奖金3000美元。
3）如果用户输入的一个数字仅满足顺序情况下匹配彩票的一个数字，奖金1000美元。
4）如果用户输入的一个数字仅满足非顺序情况下匹配彩票的一个数字，奖金500美元。
5）如果用户输入的数字没有匹配任何一个数字，则彩票没中奖，作废。
import java.util.Scanner;
public class shiyan1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//随机获取一个两位数
int number = (int)(Math.random()*90 + 10);
int numbershi = number / 10;
int numberge = number % 10;
Scanner input = new Scanner(System.in);
System.out.println("请输入一个两位数");
int guess = input.nextInt();
int guessshi = guess / 10;
int guessge = guess % 10;
if (number == guess) {
System.out.println("奖励10000美元");
}else if (guessge == numbershi && guessshi == numberge) {
System.out.println("奖励3000美元");
}else if (guessshi == numbershi || guessge == numberge) {
System.out.println("奖励1000美元");
}else if (guessge ==numbershi || guessshi == numberge) {
System.out.println("奖励500美元");
}else {
System.out.println("没中奖");
}
System.out.println("中奖号码为" + number);
}
}
键盘获取Scanner类
如何从键盘获取不同类型的变量：需要使用Scanner类
具体实现步骤：
1.导包：import java.util.Scanner;
2.Scanner实例化：Scanner scan = new Scanner(System.in);
3.调用Scanner类的相关方法（next () / nextXxx()），来获取指定类型的变量
注意：
需要根据相应的方法，来输入指定类型的值。如果输入的数据类型与要求的类型不匹配时，会报异常：InputMisMatchExce 导致程序终止
//1.导包：import java.util.Scanner;
import java.util.Scanner;
class ScannerTest{
public static void main(String[] args){
//2.Scanner的实例化
Scanner scan = new Scanner(System.in);
//3.调用Scanner类的相关方法
System.out.println("请输入你的姓名");
String name = scan.next();
System.out.println("请输入你的芳龄");
int age = scan.nextInt();
System.out.println("请输入你的体重");
double weight = scan.nextDouble();
System.out.println("你是否相中我了呢？（true/false）");
boolean isLove = scan.nextBoolean();
//对于char类型，Scanner没有提供相关方法。只能获取一个字符串
System.out.println("请输入你的性别：（男/女）") ;
String gender = scan.next();//“男”
//获取索引为0位置上的字符
Char genderChar = gender.charAt(0);
System.out.println(genderChar);//'男'
}
}
获取一个随机数
公式：[a,b] : (int)(Math.random() * (b-a+1)+a)
如何获取一个随机数：10——99
int value = (int)(Math.random)() * (90+10)
//[0.0,1.0)-->[0.0,90.0)-->[10.0,100.0)-->[10,99]
switch-case结构
switch-case结构：
• 根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。
当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇见break关键字或此switch-case结构末尾结束为止。
• break，可以使用在switch-case结构中表示一旦执行到此关键字，就跳出switch-case结构
• switch结构中的表达式，只能是如下的6种数据类型之一：
byte、short、char、int、枚举类型（JDK5.0新增）、string类型（JDK7.0新增）
• case之后只能声明常量，不能声明范围
• break关键字是可选的
• default：相当于if-else结构中的else，default结构是可选的，而且位置是灵活的
• 如果switch-case结构中的多个case的执行语句相同，则可以考虑合并
• 凡是可以使用switch-case的结构，都可以转换为if-else，反之，不成立
• 我们写分支结构时，当发现既可以使用switch-case（同时，switch中表达式的取值情况不太多），
又可以使用if-else时，优先选择使用switch-case。原因：switch-case执行效率高
class SwitchText{
public static void main(String[] args){
int number = 1;
switch(number){
case 0:
System.out.println("zero");
case 1:
System.out.println("one");
case 2:
System.out.println("two");
default:
System.out.println("other");
}
}
}
1.对学生成绩大于60分的，输出合格，低于60分的输出不合格
class SwitchText{
public static void main(String[] args){
int score = 78;
switch(score / 10){
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
System.out.println("不合格");
break;
case 7:
case 8:
case 9:
case 10:
System.out.println("合格");
break;
}
}
}
class SwitchText{
public static void main(String[] args){
int score = 78;
switch(score / 60){
case 0:
System.out.println("不合格");
break;
case 1:
System.out.println("合格");
break;
}
}
}
2.从键盘分别输入年、月、日，判断这一天是当年的第几天
注意：判断一年是否是闰年的标准：可以被4整除，但不可以被100整除或可以被400整除
package shiyan;
import java.util.Scanner;
public class shiyan1 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入年");
int year = scan.nextInt();
System.out.println("请输入月");
int month = scan.nextInt();
System.out.println("请输入日");
int day = scan.nextInt();
int sumday = 0;
switch(month) {
case 12://十一月
sumday += 31;
case 11://十月
sumday += 31;
case 10://九月
sumday += 30;
case 9://八月
sumday += 31;
case 8://七月
sumday += 30;
case 7://六月
sumday += 30;
case 6://五月
sumday += 31;
case 5://四月
sumday += 30;
case 4://三月
sumday += 31;
case 3://二月
if(year % 4 == 0 && year % 100 !=0 || year % 400 == 0) {
sumday += 29;
}else {
sumday += 28;
}
case 2:
sumday += 31;//一月
case 1:
sumday += day; //当月的天数
}
System.out.println(year + "年" + month + "月" + day + "日是当年的第" + sumday + "天");
}
}
循环结构
• 循环结构：
在某些条件满足的情况下，反复执行特定代码的功能
• 循环语句的分类：
for循环
while循环
do-while循环
• 循环语句的四个组成部分
初始化部分（init_statement)
循环条件部分（text_exp)
循环体部分（body_statement)
迭代部分（alter_statement)
• 衡量一个功能代码的优劣：
1.正确性
2.可读性
3.健壮性
4.高效率与低存储：时间复杂度、空间复杂度（衡量算法的好坏）
for循环
• 语法格式：
for(①初始化部分；②循环条件部分；④迭代部分) {
③循环体部分
}
• 执行过程：
①-②-③-④-②-③-④-②-③-④-……-②
• 说明：②循环条件部分为Boolean类型表达式，当值为false时，退出循环
①初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
④可以有多个变量更新，用逗号分隔
在for循环中变量 i 出了循环就不可以再调用
• for循环执行演示：
1.遍历100以内的偶数，输出所有偶数的和，输出偶数的个数
int sum = 0;//记录总和
int count = 0;//记录个数
for(int i = 1;i <=100;i++){
if(i % 2 == 0){
sum += i;
count++;
}
}
System.out.println("总和为" + sum);
System.out.println("总个数为" + count);
2.编写程序从1循环的150，并在每行打印一个值，另外在每个3的倍数行上打印出”foo"，
在每个5的倍数行上打印”biz“，在每个7的倍数行上打印出“baz”
for(int i = 1;i <= 150;i++) {
System.out.print(i);
if(i % 3 == 0) {
System.out.print("foo");
}
if(i % 5 == 0) {
System.out.print("biz");
}
if(i % 7 == 0) {
System.out.print("baz");
}
}
System.out.println();
3.输入两个正整数m和n，求其最大公约数和最小公倍数
比如：12和20的最大公约数是4，最小公倍数是60
import java.util.Scanner;
public class ShiYan {//最大公约数
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个正整数");
int m = scan.nextInt();
System.out.println("请输入第二个正整数");
int n = scan.nextInt();
int min = (m <= n)? m:n;
for (int i = min;i >=1;i--) {
if(m % i == 0 && n % i ==0) {
System.out.println("最大公约数" + i);
break;
}
}
}
}
import java.util.Scanner;
public class ShiYan {//最小公倍数
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个正整数");
int m = scan.nextInt();
System.out.println("请输入第二个正整数");
int n = scan.nextInt();
int max = (m >= n)? m:n;
for (int i = max;i <= m * n;i++) {
if(i % m == 0 && i % n == 0) {
System.out.println("最小公倍数" + i);
break;
}
}
}
}
while循环
• 语法格式：
①初始化部分
while(②循环条件部分) {
③循环部分；
④迭代部分；
}
• 执行过程：
①-②-③-④-②-③-④-②-③-④-……-②
• 说明：
>注意不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环
>for循环和while循环可以相互转换
>在while循环中变量i出了循环还可以调用
• 区别：for循环和while循环的初始化部分的作用范围不同
• 算法：有限性
• 说明：
>最简单无限循环格式：for( ; ;) 或while(true)
>无限循环存在的原因是并不知道循环多少次，需要根据循环体内部某些条件，来控制循环结束
>结束循环有几种方式：
方式一：循环条件部分返回false
方式二：在循环体中，执行break
public class ShiYan {
public static void main(String[] args) {
int i = 1;
while (i <= 100) {
if (i % 2 ==0) {
System.out.println(i);
}
i++;
}
System.out.println(i);//101
}
}
从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束
import java.util.Scanner;
public class ShiYan {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int zheng = 0;
int fu = 0;
for (;;) {//while(true){
int number = scan.nextInt();
if (number > 0) {
zheng++;
}else if (number < 0) {
fu++;
}else {
break;
}
}
System.out.println("输入正数个数为" + zheng);
System.out.println("输入负数个数为" + fu);
}
}
do-while循环
语法格式：
①初始化部分
do{
③循环体部分
④迭代部分
}while(②循环条件部分);
执行过程：
①-③-④-②-③-④-②-③-④-……-②
说明：
do-while循环至少执行一次循环体
public class ShiYan {
public static void main(String[] args) {
int number1 = 10;
while (number1 > 10) {//到这里会被停止，不会进行下一步，不会输出语句
System.out.println("hello wwhile");
number1--;
}
int number2 = 10;
do {//在这里是先循环一次
System.out.println("hello do-while");
number2--;
} while (number2 > 10);//到这里被停止，但已经循环一次，会输出一次语句
}
}//结果：hello do-while
1.遍历100以内的偶数，并计算所有偶数的和和偶数的个数
public class ShiYan {
public static void main(String[] args) {
int num1 = 1;
int sum = 0;//记录总和
int count = 0;//记录个数
do {
if (num1 % 2 == 0) {
System.out.println(num1);
sum += num1;
count++;
}
num1++;
} while (num1 <= 100);
System.out.println("总和为" + sum);
System.out.println("总个数为" + count);
}
}
嵌套循环
嵌套循环（多重循环):
• 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for,while,do-while均可作为外层循环或内层循环。
• 实质上，嵌套循环就是吧内层循环当成外层循环的循环体。只有当内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层循环的当次循环，开始下一次循环。
• 设外层循环次数为m次，内层为n次，则内层循环实际上需要执行m*n次
• 技巧：外层循环控制行数，内层循环控制列数
/*效果：
*
**
***
****
*****
******
*/
public class ShiYan {
public static void main(String[] args) {
for (int i = 1; i <= 6; i++) {
for (int j = 1; j <= i; j++) {
System.out.print("*");
}
System.out.println();
}
}
}
/*效果： i(行数） j(*的个数) 规律
****** 1 6 i+j=7
***** 2 5 j=7-i
**** 3 4
*** 4 3
** 5 2
* 6 1
*/
public class ShiYan {
public static void main(String[] args) {
for (int i = 1; i <= 6; i++) {
for (int j = 1; j <= 7-i; j++) {
System.out.print("*");
}
System.out.println();
}
}
}
1.九九乘法表：
/*
1*1=1
2*1=2 2*2=4
3*1=3 3*2=6 3*3=9
4*1=4 4*2=8 4*3=12 4*4=16
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
*/
public class ShiYan {
public static void main(String[] args) {
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(i + "*" + j + "=" + (i * j) + " ");
}
System.out.println();
}
}
}
2.自然数100以内的所有质数的输出
质数：素数，只能被1和它本身整除的自然数。-->从2开始，到这个数-1结束为止，都不能被这个数本身整除。
最小的质数：2
public class ShiYan {
public static void main(String[] args) {
boolean isFlag = true;//标识i是否被j除尽，一旦除尽，修改其值
for (int i = 2; i <= 100; i++) {
//for (int j = 2; j < i; j++) {
for (int j = 2; j <= Math.sqrt(i); j++) {//优化二：Math.sqrt(i)根号i，根号i被j除尽就说明i不是质数
if (i % j ==0) {//i被j除尽
isFlag = false;
break;//优化一：只对本身非质数的自然数是有效的，一旦有未除尽的就会停止
}
}
if(isFlag == true) {
System.out.println(i);
}
isFlag = true;//重置isFlag
}
}
}
break和continue关键字
• break语句：
>break语句用于终止某个语句块的执行
{ ...
break；
...
}
>break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的语句
label1: {……
label2: {……
label3: {……
breaklabel2;
……
}
}
}
附加：特殊流程控制语句:
>return：并非专门用于结束循环的，它的功能是结束一个方法。这个return处于多少层循环之内
>与break和continue不同的是，return直接结束整个方法，当一个方法执行到一个return语句时，这个方法将被结束。
• 特殊流程控制语句说明:
>break只能用于switch语句和循环语句中。
>continue 只能用于循环语句中。
>二者功能类似，但continue是终止本次循环，break是终止本层循环。
>break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。
>标签语句必须紧接在循环的头部。标签语句不能用在非循环语句的前面。
>很多语言都有goto语句，goto语句可以随意将控制转移到程序中的任意一条语句上，然后执行它。
但使程序容易出错。Java中的break和continue是不同于goto的。
• continue语句：
>continue只能使用在循环结构中
>continue语句用于跳过其所在循环语句块的一次执行，继续下一次循环
>continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环
break和continue关键字的使用：
public class ShiYan {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
if (i % 4 == 0) {
break;//123
}
System.out.println(i);
}
}
}
public class ShiYan {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
if (i % 4 == 0) {
continue;//1235678910
}
System.out.println(i);
}
}
}
带标签的break和countinue：
public static void main(String[] args) {
label:for(int i = 1; i <= 4; i++) {
for (int j = 0; j <= 10; j++) {
if (j % 4 == 0) {
//break;//默认跳出包裹此关键字最近的一层循环
//continue;//默认跳出包裹此关键字最近的当次循环
break label;//结束指定标识的一层循环,123
//continue label;//结束指定标识的当次循环,123123123123
}
System.out.print(j);
}
System.out.println();
}
}
}
扫一扫
238
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
