标签：语句 case Java System 语法 第五节 循环 break println
程序控制结构
- 定义：程序控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑块
- 其流程控制方式采用结构化程序设计中的三种基本流程结构，即
- 顺序结构：程序从上到下逐行执行，中间没有任何判断和跳转
- 分支结构：
- 根据条件，选择性的执行某段代码
- 有if...else和switch-case两种分支语句
- 循环结构
- 根据循环条件，重复性的执行某段代码
- 有while,do....while,for三种循环语句
- 注：JDK1.5提供了foreach循环，方便的遍历集合，数组元素
顺序结构
- Java中定义成员变量时采用合法的前向引用。如：
public class Test{
int num1 = 12;
int num2 = num1 + 2;
}
错误形式：
public class Test{
int num2 = num1 + 2；
int num1 = 12;
}
分支结构
if-else结构
//举例1
int heartBeats=79;
if(heartBeats <60||heartBeats>100){
System.out.println("你需要做进一步检查");
}
System.out.println("检查结束");
//举例2
int age = 23;
if(age<18){
System.out.println("你还可以看动画片");
}else{
System.out.println("你可以看电影了");
}
//举例3
if(age<0){
System.out.println("你输入的数据非法");
}else if(age<18){
System.out.println("青少年时期");
}else if(age<35){
System.out.println("青壮年时期");
}else if(age<60){
System.out.println("中年时期");
}else if(age<120){
System.out.println("老年时期");
}else {
System.out.println("你已经成仙了");
}
- 条件表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量
- 语句块只有一条执行语句时，一对{}可以省略，但建议保留
- if-else语句结构，根据需要可以嵌套使用
- 当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略
- 当多个条件是“互斥”关系时，条件判断语句及执行语句间顺序无所谓
- 当多个条件是“包含”关系时，“小上大下 / 子上父下”
switch-case结构
- switch(表达式)中表达式的值必须是下述几种类型之一：byte，short，
char，int，枚举 (jdk 5.0)，String (jdk 7.0)； - case子句中的值必须是常量，不能是变量名或不确定的表达式值；
- 同一个switch语句，所有case子句中的常量值互不相同；
- break语句用来在执行完一个case分支后使程序跳出switch语句块；如
果没有break，程序会顺序执行到switch结尾 - default子句是可任选的。同时，位置也是灵活的。当没有匹配的case时，
执行default
int number = 2;
switch(number){
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");
}
//**********编译错误的情况***********
//举例1：③的反例
boolean isHandsome = true;
switch(isHandsome){
case true:
System.out.println("true");
break;
case false:
System.out.println("false");
break;
default:
System.out.println("error");
}
//举例2：④的反例
int age = 10;
switch(age){
case age>18:
System.out.println("成年了");
break;
default:
System.out.println("未成年");
}
循环结构
- 循环结构:在某些条件满足的情况下，反复执行特定代码的功能
- 循环语句分类
- for 循环
- while 循环
- do-while 循环
- 循环语句的四个组成部分
- 初始化部分(init_statement)
- 循环条件部分(test_exp)
- 循环体部分(body_statement)
- 迭代部分(alter_statement)
for 循环
-
语法格式
for (①初始化部分; ②循环条件部分; ④迭代部分)｛ ③循环体部分; ｝ -
执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ...-②
-
说明
-
循环条件部分为boolean类型表达式，当值为false时，退出循环
-
初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
-
迭代部分可以有多个变量更新，用逗号分隔
for(int i = 1;i <= 5;i++){
System.out.println("Hello World!");
}
//练习
int num = 1;
for(System.out.print("a");num<=3;System.out.print("c"),num++){
System.out.print("b");
}
//输出abcbcbc
//例题：遍历100以内的偶数，输出所有偶数的和和偶数的个数
int sum = 0;//记录所有偶数的和
int count = 0;//记录偶数的个数
for(int i = 1;i <= 100;i++){
if(i%2==0){
System.out.println(i);
sum += i;
count++;
}
}
System.out.println("所有偶数的和："+sum);
System.out.println("偶数的个数："+count);
while循环
- 语法格式
①初始化部分
while(②循环条件部分)｛
③循环体部分;
④迭代部分;
}
- 执行过程：①-②-③-④-②-③-④-②-③-④-...-②
- 说明：
- 注意不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环。
- for循环和while循环可以相互转换
//遍历100以内的偶数
int i = 1;
while(i <= 100){
if(i % 2 == 0){
System.out.println(i);
}
i++;
}
//出了while循环以后，仍可以调用
System.out.println(i);//101
do-while 循环
- 语法格式
①初始化部分;
do{
③循环体部分
④迭代部分
}while(②循环条件部分);
- 执行过程：①-③-④-②-③-④-②-③-④-...②
- 说明：
- do-while循环至少执行一次循环体
//遍历100以内的偶数,并计算所有偶数的和即偶数的个数
int sum = 0;//记录所有偶数的和
int count = 0;//记录偶数的个数
int num = 1;
do{
if(num%2==0){
System.out.println(num);
sum += num;
count++;
}
num++;
}while(num <= 100);
System.out.println("所有偶数的和："+sum);
System.out.println("偶数的个数："+count);
嵌套循环
- 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while均可以作为外层循环或内层循环。
- 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
- 设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。
//打印******
//System.out.println("******");
for(int i = 1;i <= 6;i++){
System.out.print('*');//也可以写成"*"
}
System.out.println();
/*
打印******
******
******
******
******
*/
for(int i = 1;i <= 5;i++){
for(int j = 1;j <= 6;j++){
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
打印***** 5 5
**** 4 4
*** 3 3
** 2 2
* 1 1
*/
for(int i = 1;i <= 5;i++){ //控制行数
for(int j = 0;j <= 5-i;j++){ //控制列数
System.out.print('*');
}
System.out.println();
}
//输出100000以内的质数
boolean isFlag = true;//标识i是否被j除尽，一旦除尽，修改其值
//获取当前时间距1970-01-01 00:00:00 的毫秒数
long start = System.currentTimeMillis();
for(int i = 2;i <= 100000;i++){
for(int j = 2;j <= Math.sqrt(i);j++){//优化二：对本身质数的自然数是有效的
if(i % j == 0){
isFlag = false;
break;//优化1：只对本身非质数的自然数是有效的
}
}
if(isFlag){
System.out.println(i);
}
//重置isFlag
isFlag = true;
}
//获取当前时间距1970-01-01 00:00:00 的毫秒数
long end = System.currentTimeMillis();
//输出运算的时间
System.out.println(end-start);
/*
优化前：15232
优化1后: 1965
优化1和2后: 660
*/
特殊关键字的使用：break、continue
-
break语句
- break语句用于终止某个语句块的执行
{ …… break; …… }- break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块
label1: { …… label2: { …… label3: { …… break label2; …… } } } -
continue 语句
- continue只能使用在循环结构中
- continue语句用于跳过其所在循环语句块的一次执行，继续下一次循环
- continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环
- continue语句用法举例
for (int i = 0; i < 100; i++) { if (i%10==0) continue; System.out.println(i); }
label:for(int i = 0;i <= 4;i++){
for(int j = 1;j <= 10;j++){
if(j % 4 == 0){
//break;//默认跳出包裹此关键字最近的一层循环
//continue;
//break label;//结束指定标识的一层循环结构
continue label;//结束指定标识的一层循环结构当此循环
}
System.out.print(j);
}
}
附加：特殊流程控制语句3
Scanner输入
-
从键盘或控制台获取输入的变量
-
具体实现步骤
-
导包：import java.util.Scanner
-
Scanner的实例化：Scanner scan = new Scanner(System.in);
-
调用Scanner类的相关方法(next()/nextXxx())，来获取指定类型的变量
- 注意：需要根据相应的方法来输入指定类型的数据。如果输入的数据类型跟要求的类型不匹配时会报异常：InputMismatchException 导致程序终止
-
import java.util.Scanner;
class Test{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请输入你的姓名：");
String name = scan.next();
System.out.println(name);
System.out.println("请输入你的芳龄：");
int age = scan.nextInt();
System.out.println(age);
System.out.println("请输入你的体重：");
double weight = scan.nextDouble();
System.out.println(weight);
System.out.println("你是否相中了我呢？(true/false)");
boolean isLove = scan.nextBoolean();
System.out.println(isLove);
//对于char类型的获取，Scanner没有提供相关的方法。只能获取一个字符串
System.out.println("请输入你的性别：(男/女)");
String gender = scan.next();//"男”
char genderChar = gender.charAt(0);//获取字符串索引为0位置上的字符
System.out.println(genderChar);
}
}
总结
*一，分支结构中的if-else（条件判断结构）
* 三种形式
* 第一种：
* if(条件表达式){
* }
* 第二种：二选一
* if(条件表达式){
* 执行语句1
* }else{
* 执行语句2
* }
* 第三种：多选一
* if(条件表达式1){
* 执行语句1
* }else if(条件表达式2){
* 执行语句2
* }else if(条件表达式3){
* 执行语句3
* }else if(条件表达式3){
* 执行语句3
* }.....else{
* 执行语句n
* }
*
*二，分支结构中的switch-case
* 1.格式
* switch(表达式){
* case 常量1：
* 执行语句1；
* //break;
* case 常量2：
* 执行语句2；
* //break;
* ...
* default：
* 执行语句n；
* //break;
* }
* 2.说明
* ①根据switch表达式中的值，依次匹配各个case中的常量。
* 一旦匹配成功，则进入相应的case结构中。调用其执行语句。
* 当调用完执行语句后，则仍然继续向下执行其他case结构中的执行语句，
* 直到遇到break关键字或此switch-case结构末尾为止结束
* ②break关键字可以使用在switch-case中，表示一但执行到此关键字，
* 就跳出switch-case结构
* ③switch-case结构中的表达式，只能是如下的6种数据类型之一：
* byte,short,char,int,枚举类型(JDK5.0新增)，String类型(JDK7.0新增)
* ④case之后只能声明常量，不能声明范围
* ⑤break关键字是可选的
* ⑥default:相当于if-else的else.也是可选的。而且位置是灵活的
* ⑦凡是可以使用switch-case的结构，都可以转换成if-else.反之不成立
* ⑧我们在写分支语句时，当发现既可以使用switch-case的结构(同时，
* switch中表达式的取值情况不太多)，又可以使用if-else时，我们会优先使用switch-case。
* 原因：switch-case的执行效率比if-else稍高
*三，循环结构
* 循环语句的四个要素
* ①初始化部分
* ②循环条件部分 -->是boolean类型
* ③循环体部分
* ④迭代部分
* 1:for循环结构
* for(①;②;④){
* ③
* }
* 执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ...-②
* break:在循环中，一旦遇到break,则跳出循环
* 2:while循环结构
* ①
* while(②){
* ③;
* ④;
* }
* 执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ...-②
* 注意：
* 1.写while循环时千万不要丢了迭代条件。一旦丢了，就可能导致死循环！
* 2.我们写程序，要避免死循环
* 3.for循环和while循环是可以相互转换的！
* 区别：for循环和while循环的初始化条件的作用范围不同
*
* 算法：局限性
* 3:do-while循环结构
* ①
* do{
* ③;
* ④;
* }while(②);
* 执行过程：① - ③ - ④ - ② - ③ - ④ - ...-②
* 说明：
* 1.do-while循环至少会执行一次循环
* 2.开发中，使用for和while会更多一些，较少使用do-while
* 补充：
* 1.不在循环条件部分限制次数的结构：for(;;)或while(true)
* 2.结束循环有几种方式？
* 方式一：循环条件部分返回false
* 方式二：在循环体中，执行break;
*四，嵌套循环
* 1.嵌套循环：将一个循环结构A声明在另一个循环结构B中，就构成了嵌套循环
* 2.外层循环：循环结构A
* 内层循环：循环结构B
* 3.说明：
* ①内层循环结构遍历一遍，只是相当于外层循环循环体执行了一次
* ②假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的循环体共执行了m * n次
* 4.技巧：外层循环控制行数，内层循环控制列数
*五，break和continue关键字的使用
* 使用范围 循环中使用的作用(不同点) 相同点
*break switch-case 结束当前循环 关键字后面不能声明执行语句
* 循环结构中
*
*continue 循环结构中 结束当次循环 关键字后面不能声明执行语句
*
*
*如何从键盘获取不同类型的变量：需要使用Scanner类
*具体实现步骤：
* 1.导包：import java.util.Scanner
* 2.Scanner的实例化：Scanner scan = new Scanner(System.in);
* 3.调用Scanner类的相关方法(next()/nextXxx())，来获取指定类型的变量
* 注意：
* 需要根据相应的方法来输入指定类型的数据。如果输入的数据类型跟要求的类型不匹配时
* 会报异常：InputMismatchException 导致程序终止
*
*
//练习：从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序
Scanner scan = new Scanner(System.in);
int positiveNumber = 0;//记录正数的个数
int negativeNumber = 0;//记录负数的个数
while(true){
int number = scan.nextInt();
//判断number的正负情况
if(number > 0){
positiveNumber++;
}else if(number < 0){
negativeNumber++;
}else{
//一旦执行break,跳出循环
break;
}
}
System.out.println("输入的正数的个数为："+positiveNumber);
System.out.println("输入的负数的个数为："+negativeNumber);
标签：语句,case,Java,System,语法,第五节,循环,break,println 来源： https://www.cnblogs.com/mzchuan/p/13885832.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。