JavaSE| 流程控制

程序流程控制

流程控制语句结构:
、顺序结构
语句的关系是从上到下依次执行的顺序关系,中间没有任何判断和跳转;
它是最基本的结构,Java程序总体来说都是从main()依次执行
、分支结构; 根据条件,选择性地执行某段代码,有if--else 和switch两种分支语句。
、循环结构;根据循环条件,重复性地执行某段代码,有while、do--while、for三种循环语句。jdk1.5提供了foreach循环,方便的遍历集合、数组元素。

1、顺序结构

键盘输入程序的步骤:
1、先准备键盘输入的工具类的对象 --》比喻成准备键盘
java.util.Scanner input = new java.util.Scanner(System.in); 第一:Scanner是首字母是大写
第二:System也是首字母大写
第三:左右两边一样java.util.Scanner
第四:其他照抄,input可以自己命名,代表了键盘输入工具 2、提示输入
System.out.println(xxx); 3、输入
输入字符串:input.next();
输入整数: input.nextInt();
input.nextLong();
输入小数:input.nextFloat();
input.nextDouble();
输入布尔:input.nextBoolean() 输入一个字符:input.nextChar();错误的
input.next().charAt(0); */
class TestInput{
public static void main(String[] args){
//从键盘输入姓名和年龄等
java.util.Scanner input = new java.util.Scanner(System.in); System.out.print("请输入姓名:");
String name = input.next();//从键盘输入一个字符串,保存到name变量中。 System.out.print("请输入年龄:");
int age = input.nextInt(); System.out.print("请输入体重:");
double weight = input.nextDouble(); System.out.print("请输入是否已婚(true/false):");
boolean isMarry = input.nextBoolean(); System.out.print("请输入性别:");
char gender = input.next().charAt(0); System.out.println("姓名:" + name);
System.out.println("性别:" + gender);
System.out.println("年龄:" + age);
System.out.println("体重:" + weight);
System.out.println("是否已婚:" + (isMarry?"是":"否")); }
}

2 、分支结构

switch穿透, 没加break就穿透了

1)条件判断:if..else  单分支条件判断、双分支条件判断、多分支条件判断、嵌套。)
2)选择结构:switch..case (一)条件判断系列(if语句3种格式:单、双、多)
1
、单分支条件判断;  只有一个选项,要么成立就做,要么不成立什么也不干。
语法结构:
if(条件表达式){
当条件表达式成立时,需要执行的语句块;
} 说明:
(1)if(条件表达式)中的条件表达式的结果必须是boolean值,即要么是true要么是false
(2){}中是语句块,意思就是可以是一句或多句
(3){}中的语句块只有一条语句时,这个{}是可以省略的,但是不建议大家省略。 执行的特点:
if()条件成立就执行{}中的语句块,不成立就不执行。 2、双分支条件判断 ;(二选一)
语法结构:
if(条件表达式){
当条件表达式成立时,执行的语句块1;
}else{
当条件表达式不成立时,执行的语句块2;
} 说明:
(1)if(条件表达式)中的条件表达式的结果必须是boolean值,即要么是true要么是false
(2){}中是语句块,意思就是可以是一句或多句
(3){}中的语句块只有一条语句时,这个{}是可以省略的,但是不建议大家省略。 执行特点:
双分支结构,一定会执行其中的一个分支,即二选一执行。
当条件表达式成立时,执行的语句块1;不成立,就执行语句块2; if(num%2==0){
System.out.println(num + "是偶数");
System.out.println(num + "是双数");
}else{
System.out.println(num + "是奇数");
} /*
//两个单分支; 条件满足可以同时走两个if条件语句。 注意注意注意与if..elseif..else的区别,条件成立只能选择走一个;而多个单分支if语句可以执行多个。
if(num%2==0){ //条件成立就执行。
System.out.println(num + "是能被2整除");
System.out.println(num + "是双数");
}
if(num%4==0){ //条件成立就执行,例如num为4,两个if条件句都会执行。
System.out.println(num + "是能被4整除");
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)if(条件表达式)中的条件表达式的结果必须是boolean值,即要么是true要么是false
(2){}中是语句块,意思就是可以是一句或多句
(3){}中的语句块只有一条语句时,这个{}是可以省略的,但是不建议大家省略。
(4)如果多个条件之间的关系是“互斥”关系,它的顺序是随意的
是“包含”关系,它的顺序有要求,范围小的在上,范围大的在下; 执行的特点:
从上往下依次判断条件,如果有一个条件成立了,后面的条件都不看了;
如果最后有单独的else,那么以上条件都不成立,就执行最后else中的;
如果最后没有单独的else,那么以上条件都不成立时,就什么也不执行。也可以没有else。
多个分支中最多执行一个。
/*
if(score==100){
System.out.println("满分");
}else if(score>=80 && score<=99){
System.out.println("优秀");
}else if(score>=70 && score<80){
System.out.println("良好");
}else if(score>=60 && score<70){
System.out.println("及格");
}else{
System.out.println("不及格");
}
*/
if(score==100){
System.out.println("满分");
}else if(score>=80){
System.out.println("优秀");
}else if(score>=70){
System.out.println("良好");
}else if(score>=60){
System.out.println("及格");
}else{
System.out.println("不及格");
}
4、嵌套:
当外层情况满足了,才会判断嵌套在里面的条件。 前提条件是[0,100]
//如果是100分,显示满分
//如果是[80-99],显示优秀
//如果是[70,80),显示良好
//如果是[60,70),显示及格
//其他的显示不及格
如果成绩不再[0,100],提示它输入错误
/*
if(score>=0 && score<=100){
if(score==100){
System.out.println("满分");
}else if(score>=80){
System.out.println("优秀");
}else if(score>=70){
System.out.println("良好");
}else if(score>=60){
System.out.println("及格");
}else{
System.out.println("不及格");
}
}else{
System.out.println("成绩的范围是:[0,100]");
}
*/ if(score<0 || score>100){
System.out.println("成绩的范围是:[0,100]");
}else{
if(score==100){
System.out.println("满分");
}else if(score>=80){
System.out.println("优秀");
}else if(score>=70){
System.out.println("良好");
}else if(score>=60){
System.out.println("及格");
}else{
System.out.println("不及格");
}
}

(二)选择结构 ( switch() case : default: )

语法格式:
switch(表达式){
case 常量值1:
语句块1;
break;
case 常量值2:
语句块2;
break;
case 常量值3:
语句块3;
break;
default:
语句块n+1;
break;
} 说明:
(1)case后面必须是常量值;
(2)case后面的常量值不能重复
(3)switch(表达式)中表达式的结果的类型有要求:
四种基本数据类型:byte,short,int,char
两种引用数据类型:JDK1.5之后开始支持枚举类型,JDK1.7之后开始支持String类型 执行过程:
(1)入口
A:当switch(表达式)中表达式的值与某一个case后面的常量值“匹配”,就从这个case进入;
B:如果存在default,那么当所有的case都无法匹配时,从default进入;
(2)出口
A:自然出口:switch的结束}
B:中断出口:break; 一定找到“入口”,就会一直往下运行,直到遇到“出口” 可以用switch..case,一定可以用if..else实现,
但是有的时候,用switch...case效率更好,可读性更好 当条件判断是常量==比较时,可以改用switch..case

3、循环结构:当程序需要“重复”执行某些代码

(1)for
(2)while
(3)do...while
(4)增强for循环:用于类似于数组、集合等这种容器迭代,遍历用
(一)for循环
语法结构:
1、基本结构
for(;;){
循环体语句块;//(就是需要重复执行的代码)
  }
如果没有加条件,这个就是无限循环,或者说死循环。 2、完整结构
for(初始化表达式; 循环条件表达式; 迭代表达式){
循环体语句块;(就是需要重复执行的代码)
}
说明;
for循环一般需要一个循环变量,通过控制变量的值,来控制循环的次数。 初始化表达式:一般用于声明循环变量并赋初始值,每一轮,初始化表达式执行一次。
循环条件表达式:控制什么时候结束;
迭代表达式:修改循环变量的值。 3、执行的过程
(1)先执行“初始化表达式”
(2)判断“循环条件表达式”,
(3)如果条件成立 ,就执行“循环体语句块”,然后再执行“迭代表达式”,接着回到(2)
(4)如果条件不成立,结束for (二)while循环
语法结构:
while(循环条件){
循环体语句块;
}
执行过程:
(1)先判断循环条件
(2)如果条件成立,执行循环体语句块,然后回到(1)
(3)如果条件不成立,结束while循环 总结:
(1)可以用for,也可以用while,因为他们都是表示“重复”执行某些代码
(2)for循环更加适合于,循环次数比较明显的;
while循环更加适合于,循环条件比较明显,次数不是很在意 例如:求2的n次方,n在[0,10]范围内整数
for(int i=0; i<=10; i++){ } while循环的经典的结构:
while(true){
....
if(条件){
break
;
}

....
} (三)do...while
语法结构:
do{
循环体语句块;
}while(循环条件); 执行过程:
(1)先do(干)一次循环体语句块
(2)再判断循环条件
(3)如果条件成立,在(1)
(4)如果条件不成立,结束do..while do..while和for,while的最大不同,就是它的循环体语句块,至少可以执行一次。
而for,while循环的循环体语句可能一次都不执行。 TestDoWhile.java:41: 错误: 找不到符号
(1)是否写错单词
(2)没有声明
(3)不在作用域范围内 (四)循环嵌套:
内层循环作为外层循环的循环体的一部分; 外层循环循环一次,内层循环循环一轮; 打印:
*
**
*** 重复的代码:1)打印* ; 2)打印很多行*,每一行都有n个* //1、求1-100的和
//循环:为了重复执行某些代码
//(1)重复执行xx代码; 2)重复执行几次; 3)如何控制次数,循环变量怎么修改,条件是什么
/*
(1)重复执行xx代码
累加一个数
0 + 1 + 2 + 3 + 4 + ... + 100
(2)重复执行100次
(3)int i = 1; i<=100; i++
*/ 从键盘输入整数,输入0结束,统计输入的正数、负数的个数。
(1)哪些是需要重复的代码:键盘输入; 判断是正、负、0
(2)次数不明显,条件是否明显,不是0就继续,是0就结束,
选择while 这里需要几个变量?
(1)变量1:存储输入的数
(2)变量2:存储正数的个数
(3)变量3:存储负数的个数
break:
1、用于switch,表示结束switch结构
2、用于循环(for,while,do...while),表示结束当层循环 continue:
只能用于循环结构
表示提取结束本次循环或者说,跳过本次剩下的循环体语句 补充:了解(在开发中,源代码中没见到过,但是在教科书看到过)
break和continue可以配合标签使用 学习的步骤:
(1)先记循环结构的语法结构
(2)再记它的执行的过程
(3)阅读别人的代码,分析结果
(4)自己灵活应用
/*
1.格式:三种
2.执行if-else语句时,一定会选择其中的一个路径执行,而且仅选择一条路径。
*/
class TestIf1 {
public static void main(String[] args) {
int age = 28; if (age > 18){
System.out.println("");
}else{
System.out.println(""); if (age > 130 || age < 0){
System.out.println("");
}else if(age < 30){
System.out.println("");
}else{
System.out.println("");
} if(age < 30){
}else if(age < 60){
}else if(age < 100){
}else{
} }
}
//1.导包
import java.util.Scanner;
class TestScanner{
public static void main(String[] args) {
//2.创建一个Scanner类的对象
Scanner s = new Scanner(System.in);
System.out.println("请输入一个字符串:");
//3.调用此对象的相应的方法,完成键盘输入的值的获取
//next():表示从键盘获取一个字符串
String str = s.next(); System.out.println(str); }
}
/*
从键盘输入小明的期末成绩;
当成绩为100分时,奖励一辆BMW;
当成绩为(80, 90)时,奖励一个iphone8;
当成绩为[60,80)时,奖励一本参考书;
其他,什么也没有。
1.条件判断之间可以嵌套;
2.如果多个条件之间是互斥关系,多个条件语句上下顺序是*的。
如果多个条件之间存在包含关系,要求范围小的写在范围大的上面。
*/
import java.util.Scanner;
class TestIf2{
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
System.out.println("请输入小明的成绩:(分)");
int score = s.nextInt(); if (score >100 || score < 0){
System.out.println("你输入的数值有误!");
}else{
if(score == 100){
System.out.println("奖励一辆BMW");
}else if(score > 80){ //(score > 80 && score <=99)
System.out.println("奖励一个iphone8");
}else if(score >= 60){ //(score >= 60 && score <=80) //范围大的写下边哦
System.out.println("奖励一本书");
}else{
System.out.println("上面也没有");
}
} }
}
/*
switch(变量){
case 值1;
case 值2;
case 值3;
default:
}
1.根据变量的值,选择相应的case去判断,一旦满足条件,就执行case的相应语句;如果没有break或者已经
结尾的话,会继续执行其下的case语句。
2.default:是可选的,而且位置是灵活的。
3.变量可以是哪些类型?char byte short int 枚举 String(jdk1.7)
4.case条件:其中条件只能是值,不能是取值范围
*/ class TestSwitch1 {
public static void main(String[] args) {
int i = 5;
switch(i){
case 0:
System.out.println("zero");
break;
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("other");
break;
}
}
}

switch-case与if--else之间可以互换

/*
对学生成绩大于60的,输出"合格";低于60分的输出"不及格";
说明:
1.当多个case语句处理的语句块一致时,可以统一来写;
2.一定情况下switch-case与if-else之间可以互相转换。
*/
class TestSwitch3{
public static void main(String[] args) {
int score = 67;
if (score >= 60){
System.out.println("及格");
}else{
System.out.println("不及格");
} /*
switch(score){
case 100:
...
case 0:
default:
}
*/
switch(score / 10){
case 10:
case 9:
case 8:
case 7:
case 6:
System.put.println("及格");
break;
case 5:
case 4:
case 3:
case 2:
case 1:
case 0:
System.out.println("不及格");
break;
default:
System.out.println("输入有误");
break; }
}
/*
编写程序:从键盘上输入2014年的"month"和"day",要求通过程序输入输出的日期为2014年的第几天
*/
import java.util.Scanner; class TestSwitch4 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
System.out.println("请输入月份:");
int month = s.nextInt();
System.out.println("请输入日期:");
int day = s.nextInt(); int sum = 0;//用来记录month月day日是2014年第几天
//使用switch-case
switch(month){
case 12:
sum += 30;//30天,十一月的总天数
case 11:
sum += 31;
case 10:
sum += 30;
case 9:
sum += 31;
case 8:
sum += 31;
case 7:
sum += 30;
case 6:
sum += 31;
case 5:
sum += 30;
case 4:
sum += 31;
case 3:
sum += 28;
case 2:
sum += 31;//31,是一月份的天数
case 1:
sum += day; //最后再加上你输入的当月的天数
}
System.out.println(sum);
}
}
/*
for循环结构:
1.格式:①初始化条件;②循环条件;③迭代条件;④循环体;
for(①;②;③){
//④
}
2.执行过程:①-②-④-③-②-④-③- -④-③-②
即直至循环条件不满足,退出循环体
*/
class TestFor {
public static void main(String[] args) {
for (int i = 0;i < 4 ;i++ ){
System.out.println("Hello World!");
}
int j = 1;
for (System.out.print('a'); j < 3 ;System.out.print('b'), j++ ){
System.out.print('c');
}
//acbcb //题目:输出100以内的所有偶数及所有偶数的和及偶数的个数
int sum = 0;
int count = 0;
for (int i = 1;i<= 100 ;i++ ){ //100以内的自然数的遍历
if(i % 2 == 0){
System.out.println(i);
sum += i;
count++;
}
}
System.out.println("总和为:" + sum);
System.out.println("100以内偶数的个数为:" + count); }
}
/*

①初始化条件;
②循环条件;
③迭代条件;
④循环体;
1.格式:

while(②){


} */
class TestWhile{
public static void main(String[] args) {
//100以内的偶数的输出及其和
int i = 1;
int sum = 0;
while(i <= 100){
if(i % 2 == 0){
System.out.println(i);
sum += i;
}
i++;
}
System.out.println(sum); }
}
/*
1.格式:

do{


}while(②); 2.do-while与while的区别,do-while循环至少执行一次 */
class TestDowhile {
public static void main(String[] args) {
int i = 1;
do{
if(i % 2 == 0){
System.out.println(i);
}
i++;
}while(i <= 100); //do-while 和 while的区别
int j = 10;
do{
System.out.println(j);
j++;
}while(j < 10); while(j < 10){
System.out.println(j);
j++;
} }
}

do-while与while的区别,do-while循环至少执行一次

JavaSE| 流程控制

class TestForFor {
public static void main(String[] args) {
/*
*****
*****
*****
***** */
for(int j = 0;j < 4;j++){ //外层循环控制行数
for(int i = 0;i < 5;i++){ //内层循环控制列数
System.out.print("*");
}
System.out.println();
}
/*
*
**
***
****
*/
for (int j = 0;j < 4 ; j++){ //外层循环控制行数
for(int i = 0;i < j + 1;i++){ //内层循环控制列数
System.out.print("*");
}
System.out.println();
} /* ****
***
**
* */ for(int i = 0;i < 5;i++){
for(int j = 0;j < 5-i;j++){ //for(int j = i;j < 5;j++)
System.out.print("*");
}
System.out.println();
} /*
*
**
***
****
****
***
**
* */
for (int j = 0;j < 4 ; j++){ //外层循环控制行数
for(int i = 0;i < j + 1;i++){ //内层循环控制列数
System.out.print("*");
}
System.out.println();
}
for(int i = 0;i < 5;i++){
for(int j = 0;j < 5-i;j++){ //for(int j = i;j < 5;j++)
System.out.print("*");
}
System.out.println();
} /*
打印如下图形:
----*
---* *
--* * *
-* * * *
* * * * *
i k- j* k = 4 - i j = i + 1
0 4 1
1 3 2
2 2 3
3 1 4
4 0 5 -* * * *
--* * *
---* *
----*
i k- j* k = i + 1 j = 4-i
0 1 4
1 2 3
2 3 2
3 4 1 */ //上半部分
for(int i = 0;i < 5;i++){
for(int k = 0;k < 4 - i;k++){
System.out.print("-");
}
for(int j = 0;j < i + 1;j++){
System.out.print("* ");
}
System.out.println();
}
//下半部
for (int i = 0;i < 4;i++){
for(int k = 0;k < i + 1 ;k++){
System.out.print("-");
}
for(int j = 0;j < 4-i;j++){
System.out.print("* ");
}
System.out.println();
} }
}
/*
break:使用在switch-case中或者循环中
如果使用在循环中,表示结束"当前"循环 continue:使用在循环结构中
表示:结束"当次"循环
*/ class TestBreakContinue {
public static void main(String[] args) {
for (int i = 1;i <= 10;i++){
if (i % 4 == 0){
break;
//continue;
}
System.out.println(i);
} label:for (int i =1;i < 5;i++){
for (int j = 1;j <= 10;j++){
if (j % 4 == 0){
//break; //写在哪一层就结束哪一层
//continue;
//break label;
continue label;
}
System.out.print(j);
}
System.out.println();
} for (int i = 1;i <= 10;i++){
if (i % 4 == 0){
break;
//continue;
//在break和continue语句之后不能添加其他语句,永远也不能被执行;
//System.out.println('我是执行不了的哦');
}
System.out.println(i);
} }
}

returen关键字一定要有类型,不能省
return 临时变量 -returen关键字一定要有类型,不能省
return和i++都有临时变量;

上一篇:IP地址、子网掩码详解


下一篇:VMware_ubuntu设置共享文件夹