javaSE基础----流程控制
一、用户交互Sacnner
1.初识Sacnner
java.util.Scanner是Java提供的一个工具类，可以通过Scanner类来获取用户的输入。
- 可以通过Scanner类的next()方法和nextLine()方法获取字符
- 可以通过Scanner类的hasNext()和hasNextLine()方法判断是否还有输入的数据
- 以
scanner.next()方法接收字符串输入
package com.scanner;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
//创建一个扫描器对象，用于接收键盘数据
Scanner scanner = new Scanner(System.in);
System.out.println("使用next方式接收：");
//判断用户有没有输入字符串
if (scanner.hasNext()){
String str = scanner.next();
System.out.println("输入内容为："+str);
//scanner.next()方法在接收到有效字符后面的空格时就终止输入
//剩余的字符将留在输入队列中，直到下一次`next()方法`或`nextLine()方法`的调用。
//str = scanner.nextLine();
//System.out.println("输入的内容2为： " + str);
}
//凡是属于IO流的类使用完应立即关闭，若不关闭会一致占用资源。
scanner.close();
}
}
-------------------------------
运行结果：
使用next方式接收：
hello
输入的内容为：hello
-------------------------------
然而，该程序存在一定的问题，当输入hello时，程序输出hello。当输入hello world时，程序输出依旧是hello。
使用next方式接收：
hello world！
输入的内容为：hello
--------------------------------
将以下两行去除注释，再次运行：
//str = scanner.next();
//System.out.println("输入的内容为：" + str);
运行结果：
使用next方式接收：
hello world!
输入的内容为：hello
输入的内容2为： world！
//可以发现只进行了一次输入，第一次调用scanner.next（）输出了hello，第二次调用scanner.next（），虽然未进行输入，但输出了上一次输入的后半部分，即：空格+world！。而hello前面的空格则被忽略没有被输出。
- 使用
scanner.nextLine()方法来获取字符串：
package com.scanner;
import java.util.Scanner;
public class Demo02 {
public static void main(String[] args) {
//创建一个扫描器对象，用于接收键盘数据
Scanner scanner = new Scanner(System.in);
System.out.println("使用nextLine方式接收：");
//判断用户有没有输入字符串
if (scanner.hasNextLine()){
String str = scanner.nextLine();
System.out.println("输入内容为："+str);
}
//凡是属于IO流的类使用完应立即关闭，若不关闭会一致占用资源。
scanner.close();
}
}
---------------------------------------
运行结果：
使用nextLine方式接收：
hello world!
输入的内容为： hello world!
//可以发现，以nextLine()方式接受字符串，输入的内容全部被输出，包括hello world！前面的空格。
scanner.next()与scanner.nextLine()方法的比较
next()方法:
- 一定要读取到有效字符后才可以结束输入
- 对输入有效字符之前遇到的空白，next()方法会自动将其去掉，忽略
- 对于有效字符之后的空白，next()方法将其当作分割符或结束符，遇到空白，终止输入。剩余的字符将留在输入队列中，直到下一次
next()方法或nextLine()方法的调用。 - 因此，
next()方法不能得到带有空格的字符串
nextLine()方法：
- 以回车符作为结束符，将返回回车符之前的所有字符，包括空白符
- 因此，
nextLine()方法可以得到带有空格的字符串
2. Scanner进阶
利用Scanner方法进行输入数据类型的限定
package com.scanner;
import java.util.Scanner;
public class Demo03 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int i=0;
double d=0;
System.out.println("请输入整数数据： ");
//判断是否有整型数据的输入
if (scanner.hasNextInt()) {
//若有，则接收数据并赋值给i
i = scanner.nextInt();
System.out.println("输入的整数数据为： " + i);
} else {
//若输入的不是整型数据，则输出提示信息
//同时，用户键盘输入的数据将留在输入队列中，等待下一次输入方法调用时接收
System.out.println("输入的不是整数数据!");
}
System.out.println("请输入小数数据： ");
//判断输入的数据是否为浮点型
if (scanner.hasNextDouble()) {
//若是，则接收数据并赋值给d
d = scanner.nextDouble();
System.out.println("输入的小数数据为： " + d);
} else {
//若输入的不是浮点型数据，则输出提示信息
//同时，用户输入的数据将留在输入队列中（输入缓冲区），等待下一次输入方法调用时接收
System.out.println("输入的不是小数数据！");
}
//若输入的数据类型为字符串，整型数据判断和浮点型数据判断失败，可由此输出输入队列中的数据
//String str = scanner.nextLine();
//System.out.println("此时输入队列的数据为：" + str);
scanner.close();
}
}
--------------------------------------
运行结果：
请输入整数数据：
2
输入的整数数据为： 2
请输入小数数据：
10.1
输入的小数数据为： 10.1
----------------------------------
请输入整数数据：
2.0
输入的不是整数数据!
请输入小数数据：
输入的小数数据为： 2.0
----------------------------------
去掉下面两行注释，输入字符串进行测试：
//String str = scanner.nextLine();
//System.out.println("此时输入队列的数据为：" + str);
请输入整数数据：
yes
输入的不是整数数据!
请输入小数数据：
输入的不是小数数据！
此时输入队列的数据为：yes
输入多个数字，并求其总和与平均数，每输入一个数字回车确认，通过输入非数字来结束输入，并输出执行结果
package com.scanner;
import java.util.Scanner;
public class Demo04 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
double sum = 0;
int num = 0;
System.out.println("请输入要计算的数据：");
//通过循环判断是都还有输入，并实现多次输入
while (scanner.hasNextDouble()){
double x = scanner.nextDouble();
sum += x;
//这里的 num++ 和 ++num 作用效果相同
//num++;
//这里的 num++ 和 ++num 体现各自的特点
System.out.println("您输入了第" + ++num + "个数据，当前数据的和是" + sum);
}
System.out.println("输入数据的总和是：" + sum);
System.out.println("输入数据的平均数是：" + sum / num);
scanner.close();
}
}
----------------
运行结果：
请输入要计算的数据：
10
您输入了第1个数据，当前数据的和是10.0
20
您输入了第2个数据，当前数据的和是30.0
30
您输入了第3个数据，当前数据的和是60.0
40
您输入了第4个数据，当前数据的和是100.0
kkk
输入数据的总和是：100.0
输入数据的平均数是：25.0
二、顺序结构
- 顺序结构是最基本也是最简单的算法结构。
- 除非特殊指明，所有程序语句将从上到下依次执行。
三、分支结构
分支结构，又称为选择结构。主要可以分为if语句和switch语句。
其中if语句根据使用情况又可以分为单选结构if、双选结构if...else、多选结构if...else if...else...和嵌套结构。
1. if单选结构
package com.scanner;
import java.util.Scanner;
public class Demo05 {
public static void main(String[] args) {
//if 单选结构
Scanner scanner = new Scanner(System.in);
System.out.println("请输入内容： ");
String s = scanner.nextLine();
//equals用于判断字符串是否相等
if (s.equals("Hello")){
System.out.println(s);
}
System.out.println("End");
scanner.close();
}
}
----------------------------------------------
运行结果：
请输入内容：
Hello
Hello
End
2. if…else…双选结构
package com.scanner;
import java.util.Scanner;
public class Demo06 {
public static void main(String[] args) {
// if...else 双选结构
Scanner scanner = new Scanner(System.in);
System.out.println("请输入分数：");
int score = scanner.nextInt();
if (score >= 60){
System.out.println("成绩合格！");
} else {
System.out.println("成绩不合格！");
}
System.out.println("End");
scanner.close();
}
}
----------------------------
运行结果：
请输入分数：
60
成绩合格！
End
3. if…else if…else…多选结构
package com.scanner;
import java.util.Scanner;
public class Demo07 {
public static void main(String[] args) {
//if...else if...else...多选结构
Scanner scanner = new Scanner(System.in);
System.out.println("请输入分数：");
float score = scanner.nextFloat();
if (score >= 90 && score <= 100){
System.out.println("A");
}else if(score >= 80 && score < 90){
System.out.println("B");
}else if(score >= 70 && score < 80){
System.out.println("c");
}else if(score >= 60 && score < 70){
System.out.println("D");
}else if(score >= 0 && score < 60){
System.out.println("End");
}else{
System.out.println("输入成绩不合理");
}
scanner.close();
}
}
---------------------------------
运行结果：
请输入分数：
102
输入成绩不合理
4. if…else…嵌套结构
package com.scanner;
public class Demo08 {
public static void main(String args[]){
int x = 30;
int y = 10;
if( x == 30 ){
if( y == 10 ){
System.out.print("X = 30 and Y = 10");
}
}
}
}
--------------
运行结果：
X = 30 and Y = 10
5. switch case结构
switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。
5.1 switch case语法
switch(expression){
case value :
//语句
break; //可选
case value :
//语句
break; //可选
//你可以有任意数量的case语句
default : //可选
//语句
}
switch 语句中的变量类型可以是： byte、short、int 或者 char类型- 从 Java SE 7 开始，
switch支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面量。 switch 语句可以拥有多个case 语句。每个 case 后面跟一个要比较的值和冒号。case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。- 当变量的值与
case 语句的值相等时，那么case 语句之后的语句开始执行，直到break 语句出现才会跳出switch 语句。 - 当遇到
break 语句时，switch 语句终止。程序跳转到switch 语句后面的语句执行。case 语句不必须要包含break 语句。如果没有break 语句出现，程序会继续执行下一条case 语句，直到出现break 语句。 switch 语句可以包含一个default 分支，该分支一般是switch 语句的最后一个分支（可以在任何位置，但建议在最后一个）。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。
5.2 switch使用举例
switch case 执行时，一定会先进行匹配，匹配成功返回当前 case 的值，再根据是否有 break，判断是否继续输出，或是跳出判断。
package com.struct;
public class Demo11 {
public static void main(String[] args) {
char grade = 'C';
switch (grade){
case 'A':
System.out.println("优秀");
break;
case 'B':
System.out.println("良好");
break; //可选
case 'C':
System.out.println("中等");
break; //可选
case 'D':
System.out.println("及格");
break; //可选
case 'E':
System.out.println("再接再厉");
break; //可选
default:
System.out.println("未知等级");
}
System.out.println("你的等级是： " + grade);
}
}
------------------------------------
运行结果：
中等
你的等级是： C
break的作用：
1. 若程序中没有 break 语句时，JVM 会依次匹配每一个case，若所有case都匹配不成功，则返回默认 case(default)
2. 若程序中没有 break 语句时，JVM 会依次匹配每一个case。若匹配成功，则从当前case开始，后续所有case值都会输出。（**case穿透现象**）
3. 若当前匹配成功的case没有break；则从当前case开始，后续case值都会输出；若后续case语句块有break，则至break处跳出判断。
5.3 switch支持的字符串
从 Jdk 7 开始，switch 增添了支持字符串 （String） 类型。
package com.struct;
public class Demo12 {
public static void main(String[] args) {
String name = "狂神";
switch (name) {
case "狂神":
System.out.println("狂神");
break;
case "设计":
System.out.println("设计");
break;
case "物理":
System.out.println("物理");
break;
default:
System.out.println("什么都没有");
}
}
}
------------------------
运行结果：
狂神
6. 扩展知识：反编译
由Java文件得到.class字节码文件的过程称之为编译；
那么由.class字节码文件反推得到Java文件的过程就称之为反编译。
使用IDEA来反编译
将.class 文件复制过来
四、循环结构
Java中主要由三种循环结构：while循环、do...while循环、for循环。
Java5中还引入了一种主要用于数组的增强型for循环。
1. while循环
while是最基本的循环，它的语法格式为：
while( 布尔表达式 ) {
//要循环的内容
}
//只要布尔表达式为 true，循环就会一直执行下去。
- 只要布尔表达式为 true，while循环就会一直执行下去;
- 大多数情况下是需要循环停止的，因此需要设计程序使布尔表达式失效来结束循环；
- 是少数情况下，需要循环一直运行，比如服务器的请求响应监听等等；
- 循环条件一直为true的循环称为死循环，应尽量避免死循环的出现。
package com.struct;
public class WhileDemo01 {
public static void main(String[] args) {
//while循环小例子：计算1~100的和
int i = 0;
int sum = 0;
while(i <= 100){
sum = i + sum;
i++;
}
System.out.println("1~100数字的和为： " + sum);
}
}
-------------------------------------------
运行结果：
1~100数字的和为： 5050
2. do…while循环
对于 while 语句而言，如果不满足条件，则不能进入循环。do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。它的语法格式是：
do {
//代码语句
}while(布尔表达式);
//布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。
//如果布尔表达式的值为 true，则语句块一直执行，直到布尔表达式的值为 false。
package com.struct;
public class WhileDemo02 {
//while 和 do...while 区别
public static void main(String[] args) {
int a = 0;
while (a < 0) {
System.out.println(a);
a++;
}
System.out.println("================");
do {
System.out.println(++a);
} while (a < 0);
}
}
---------------------------------
运行结果：
================
1
3. for循环
对于已知循环次数的循环，Java提供了for循环。for循环是最有效最灵活的循环结构，它的语法格式是：
for(初始化; 布尔表达式; 更新) {
//代码语句
}
- 最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
- 然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
- 执行一次循环后，更新循环控制变量。
- 再次检测布尔表达式。循环执行上面的过程。
for(;;){//死循环
}
快捷键
100.for 回车得以下结果
for (int i = 0; i < 100; i++) {
}
//for循环举例1：计算0~100之间所有奇数和偶数的和
package com.struct;
public class ForDemo01 {
public static void main(String[] args) {
int oodSum = 0; //偶数和
int envnSum = 0; //奇数和
for (int i = 0; i <= 100; i++) {
if (i%2 !=0){ //使用if判断区分奇数和偶数
oodSum+=i;
}else{
envnSum+=i;
}
}
System.out.println("所有奇数和为："+oodSum);
System.out.println("所有偶数和为："+envnSum);
}
}
-------------------------------
运行结果：
所有奇数的和为：2500
所有偶数的和为：2550
//for循环举例2：用while或for循环输出1~1000之间可以被5整除的数，每行10个
package com.struct;
public class ForDemo02 {
public static void main(String[] args) {
for (int i = 0; i <= 1000; i++) {
//判断当i可以被5整除，打印输出
//print打印输出后不会换行
//println打印输出后自动换行
if (i % 5 == 0){
System.out.print(i+"\t");
}
if (i % (5*10) == 0){ //判断当i可以被50整除，也就是每行数量积累到10的时候，进行换行
System.out.println();
}
}
}
}
--------------------------------------------
运行结果：
0
5 10 15 20 25 30 35 40 45 50
55 60 65 70 75 80 85 90 95 100
105 110 115 120 125 130 135 140 145 150
155 160 165 170 175 180 185 190 195 200
205 210 215 220 225 230 235 240 245 250
255 260 265 270 275 280 285 290 295 300
305 310 315 320 325 330 335 340 345 350
355 360 365 370 375 380 385 390 395 400
405 410 415 420 425 430 435 440 445 450
455 460 465 470 475 480 485 490 495 500
505 510 515 520 525 530 535 540 545 550
555 560 565 570 575 580 585 590 595 600
605 610 615 620 625 630 635 640 645 650
655 660 665 670 675 680 685 690 695 700
705 710 715 720 725 730 735 740 745 750
755 760 765 770 775 780 785 790 795 800
805 810 815 820 825 830 835 840 845 850
855 860 865 870 875 880 885 890 895 900
905 910 915 920 925 930 935 940 945 950
955 960 965 970 975 980 985 990 995 1000
package com.struct;
//for循环举例3：打印九九乘法表
public class ForDemo03 {
public static void main(String[] args) {
for (int j = 1; j <= 9; j++) {
for (int i = 1; i <= j; i++) {
System.out.print(i+"*"+j+"="+i*j+"\t");
}
System.out.println();
}
}
}
-------------------------------------
运行结果：
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
4.增强型for循环
Java5 引入了一种主要用于数组的增强型 for 循环。Java 增强 for 循环语法格式如下:
for(声明语句 : 表达式)
{
//代码句子
}
- **声明语句：**声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
- 表达式：表达式是要访问的数组名，或者是返回值为数组的方法。
package com.struct;
public class ForDemo04 {
public static void main(String[] args) {
//定义一个数组，数组名为numbers，数组内元素都是int型
int [] numbers = {10, 20, 30, 40, 50};
//增强型for循环
//相当于遍历数组
for(int x : numbers ) {
System.out.println( x );
}
System.out.println("===============");
//等价于以下for循环
for (int i = 0; i < 5; i++) {
System.out.println(numbers[i]);
}
}
}
-------------------------------------
运行结果：
10
20
30
40
50
===============
10
20
30
40
50
5. break与continue
break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。不执行循环中剩余的语句，去执行该循环下面的语句。
continue 适用于任何循环控制结构中，作用是终止某次循环过程，即提奥果循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。
- 在 for 循环中，continue 语句使程序立即跳转到更新语句。(i++)
- 在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。
package com.struct;
public class ForDemo05 {
public static void main(String[] args) {
int i = 0;
while (i < 100) {
i++;
if (i % 10 == 0) {
System.out.println();
continue;
}
System.out.print(i + " \t");
}
System.out.println("========================");
i = 0;
while (i < 100) {
i++;
if (i % 10 == 0) {//到数字为 10 时，就已经跳出循环体了
System.out.println();
break;
}
System.out.print(i + " \t");
}
}
}
-------------------------------------
运行结果：
1 2 3 4 5 6 7 8 9
11 12 13 14 15 16 17 18 19
21 22 23 24 25 26 27 28 29
31 32 33 34 35 36 37 38 39
41 42 43 44 45 46 47 48 49
51 52 53 54 55 56 57 58 59
61 62 63 64 65 66 67 68 69
71 72 73 74 75 76 77 78 79
81 82 83 84 85 86 87 88 89
91 92 93 94 95 96 97 98 99
========================
1 2 3 4 5 6 7 8 9
五、流程控制习题
1.打印5行的等腰三角形
package com.struct;
public class ForDemo06 {
//打印三角形
public static void main(String[] args) {
//最外层控制三角形的行数
for (int row = 1; row <= 5; row++) {
//循环1：打印左侧空白,计算每行空白的个数
for (int colu = 5; colu > row; colu--) {
System.out.print(" ");
}
//循环2：打印*，计算每行*的个数
for (int colu = 0; colu < 2 * row - 1; colu++) {
System.out.print("*");
}
//换行
System.out.println();
}
}
}
-----------------------------
运行结果：
*
***
*****
*******
*********
扫一扫
440
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
