java流程控制
用户交互Scanner
Scanner对象
◆之前我们学的基本语法中我们并没有实现程序和人的交互，但是Java给我们提供了这样一个工
具类，我们可以获取用户的输入。 java. util. Scanner是Java5的新特征，我们可以通过
Scanner类来获取用户的输入。
◆基本语法：
Scanner s = new Scanner(System.in);
◆通过 Scanner类的next())与 nextLine())方法获取输入的字符串，在读取前我们一般
需要使用 hasNext())与 hasNextLine())判断是否还有输入的数据。
◆next()
1、一定要读取到有效字符后才可以结束输入。
2、对输入有效字符之前 遇到的空白，next()方法会自动将其去掉。
3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
4、next()不能得到带有空格的字符串。
package Scanner;
import java.util.Scanner;
public class Demo1 {
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);
}
//凡是属于 IO流(输入输出流) 的类如果不关闭会一直占用资源,要养成用完就关掉的好习惯
scanner.close();
}
//输入的是Hello World! 运行结果为:Hello
}
◆nextLine()
1、以 Enter为结束符也就是说 nextline()方法返回的是输入回车之前的所有字符。
2、可以获得空白。
package Scanner;
import java.util.Scanner;
public class Demo2 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);//输入参数System.in
System.out.println("使用nextLine方法接收:");
//判断用户有没有输入字符串
if(scanner.hasNextLine()){
String str = scanner.nextLine();
System.out.println("输入的内容为:"+str);
}
//用完就关
scanner.close();
}
//输入的是Hello World! 运行结果为:Hello World!
}
//不加判断
package Scanner;
import java.util.Scanner;
public class Demo3 {
//不进行判断
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入字符串:");
String str = scanner.nextLine();
System.out.println("输入的字符串是:"+str);
scanner.close();
}
}
案例
案例一:
package Scanner;
import java.util.Scanner;
public class Demo4 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//从键盘接收数据
int i = 0;
float f = 0.0f;
System.out.println("请输入整数");
if (scanner.hasNextInt()){
i = scanner.nextInt();
System.out.println("整数数据:"+ i);
}else{
System.out.println("抱歉输入的不是整数数据");
}
System.out.println("请输入小数");
if (scanner.hasNextFloat()){
f = scanner.nextFloat();
System.out.println("输入的小数为:"+f);
}else{
System.out.println("输入的不为小数");
}
scanner.close();
}
}
案例二:输入多个数字,并求其总和与平均数,每输入一个数字用回车确认 ,通过输入非数字来结束并输出执行结果
package Scanner;
import com.sun.org.apache.bcel.internal.generic.NEW;
import java.util.Scanner;
public class Demo5 {
public static void main(String[] args) {
//输入多个数字,并求其总和与平均数,每输入一个数字用回车确认 ,通过输入非数字来结束并输出执行结果
Scanner scanner = new Scanner(System.in);
//和
double sum = 0;
//计算输入了多少个数字
int m = 0;
//通过循环判断是否还有输入,并在里面对每次求和进行统计
System.out.println("请输入数据:");
while (scanner.hasNextDouble()){
double x = scanner.nextDouble();
m = m+1;
sum = sum + x;
}
System.out.println(m+"个数字的和"+ sum);
System.out.println(m+"个数字的平均值"+ (sum / m));
scanner.close();
}
}
运行结果:
请输入数据:
20
10
30
40
s
4个数字的和100.0
4个数字的平均值25.0
进程已结束，退出代码 0
顺序结构
- Java 的基本结构就是顺序结构,除非特别明确,否则就按照顺序一句一句执行.
- 顺序结构是最简单的算法结构.
- 语句与语句之间,框与框之间是按照从上到下的顺序进行的,它是由若干个依次执行的处理步骤组成的,它是任何一个算法都离不开的一种基本算法结构.
※选择结构
if单选择结构
if(布尔表达式){
//如果布尔表达式为true将执行语句
}
package struct;
import java.util.Scanner;
public class ifDemo01 {
public static void main(String[] args) {
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();
}
}
if双选择结构
//语法:
if(布尔表达式){
//如果值为true
}else{
//如果值为false
}
package struct;
import java.util.Scanner;
public class ifDemo02 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入成绩:");
int a= scanner.nextInt();
if(a>=60){
System.out.println("及格");
}else{
System.out.println("不及格");
}
scanner.close();
}
}
if多选择结构
//语法
if(){
}else if(){
}else if(){
}else{
}
package struct;
import java.util.Scanner;
public class ifDemo03 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入成绩:");
int a = scanner.nextInt();
if (a == 100) {
System.out.println("恭喜满分");
} else if (a < 100 && a >= 90) {
System.out.println("A");
} else if (a < 90 && a >= 80) {
System.out.println("B");
} else if (a < 80 && a >= 70) {
System.out.println("C");
} else if (a < 70 && a >= 60) {
System.out.println("D");
} else if (a < 60 && a>=0) {
System.out.println("不及格");
}else {
System.out.println("成绩不符合规范");
}
scanner.close();
}
}
嵌套的if结构
if(布尔表达式1){
///如果哦\布尔表达式1
if(布尔表达式2){
///布尔表达式2
}
}
switch多选择结构
switch(expression){
case value:
//语句
break;//可选
case value:
//语句
break;//可选
default : //可选
//语句
}
package struct;
public class switchDemo1 {
public static void main(String[] args) {
//case穿透
char grade = 'f';
switch (grade){
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("未知等级");
}
}
}
//结果是未知等级
※※※重点注意
从Java SE 7开始switch支持字符串string类型了
循环结构
while循环
while(布尔表达式){
//循环内容
}
//只要布尔表达式为true，循环就会一直执行下去。
//我们大多数情况是会让循环停止下来的，我们需要一个让表达式失效的方式来结束循环
//案例
package struct;
public class whileDemo01 {
public static void main(String[] args) {
//输出1~100
int i= 0;
while (i<100){
i++;
System.out.println(i);
}
}
}
//计算1+2+3+.....+100
package struct;
public class whileDemo2 {
public static void main(String[] args) {
int num=0;
int i=0;
while (i<=100){
num=num+i;
i++;
}
System.out.println(num);
}
}
//死循环
while(true){
//用于等待客户端连接
//定时检查
//一般不会使用,尽量避免,以防止损害机器
}
do…while循环
do{
}while();
package struct;
public class dowhileDemo1 {
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);
a++;
}while (a<0);
}
}
//结果:
while的不输出
do while的输出0;
do while和while的区别:
while先判断后执行,dowhile是先执行后判断!
do while总是保证循环体会被至少执行一次.这是最主要的差别.
for循环
for循环语句是支持迭代的一种通用结构, 是最有效,最灵活的循环结构
快捷键
100.for 然后会自动生成
for (int i = 0; i < 100; i++) {
}
/*
关于for循环的以下几点说明:
- 最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。然后检测布尔表达式的值。如果为true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
- 执行一次循环后，更新循环控制变量（迭代因子控制循环变量的增减）。再次检测布尔表达式，循环执行上面的过程。
*/
//案例1
package struct;
public class forDemo1 {
public static void main(String[] args) {
int a = 1; //初始化条件
while (a<=100){ //条件判断
System.out.println(a); //循环体
a+=2; //迭代
}
System.out.println("while循环结束");
for (int i=1;i<=100;i++){
//初始化值 //条件判断//迭代
System.out.println(i);
}
System.out.println("for循环结束");
}
}
//计算0-100之间的奇数和偶数的和
package struct;
//计算0到100之间奇数和偶数的和
public class forDemo2 {
public static void main(String[] args) {
int oddSum = 0;
int evenSum = 0;
for (int i = 0; i <= 100; i++) {
if (i%2!=0){ //用到取余
oddSum=oddSum+i;
}else{
evenSum=evenSum+i;
}
}
System.out.println("奇数的和:"+oddSum);
System.out.println("偶数的和:"+evenSum);
}
}
package struct;
public class forDemo3 {
public static void main(String[] args) {
//用while或for循环输出1-1000之间能被5整除的数,并期望每行输出三个
for (int i = 0; i <= 1000; i++) {
if (i%5==0){
System.out.print(i+"\t");
}
if (i%(5*3)==0){
System.out.println();
}
}
}
}
//九九乘法表
package struct;
//九九乘法表
/*
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 forDemo4 {
public static void main(String[] args) {
//嵌套for循环解决
for (int j = 1; j <= 9; j++) {
for (int i = 1; i <= j; i++) {
System.out.print(j+"*"+i+"="+(j*i)+"\t");
}
System.out.println();
}
}
}
增强型for循环
Java5引入的一种主要用于 数组或集合 的增强型for循环
for(声明语句:表达式){
//代码句子
}
package struct;
public class forDemo5 {
public static void main(String[] args) {
int [] numbers = {10, 20, 30, 40, 50};//定义一个数组
//遍历数组的元素
for (int x:numbers){
System.out.println(x);
}
System.out.println("============================");
for (int i = 0; i < 5; i++) {
System.out.println(numbers[i]);
}
}
}
break&continue
◆ break在任何循环语句的主体部分，均可用 break控制循环的流程。 break用于强行退出循环，
不执行循环中剩余的语句。（ break语句也在 switch语句中使用）
package struct;
public class breakDemo {
public static void main(String[] args) {
int i = 0;
while (i<100){
i++;
System.out.println(i);
if (i==30){
break;
}
}
//break是跳出循环但不终止运行
System.out.println("我还可以运行");
}
}
◆ continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，
接着进行下一次是否执行循环的判定
package struct0;
public class continueDemo {
public static void main(String[] args) {
int i= 0;
while (i<100){
i++;
if (i%10==0){
System.out.println();
continue;
}
System.out.println(i);
}
}
}
//求素数
package struct0;
public class sushu {
public static void main(String[] args) {
for (int i = 2; i <= 100; i++) {
boolean flo = true;
for (int j = 2; j < i; j++) {
if (i % j == 0) {
flo = false;
break;
}
}
if (flo) {
System.out.println(i);
}
}
}
}
// break在任何新环语句的主体部分，均可用 break控制循环的流程
//break用于强行退出循环，不执行循环中剩余的语句。（ break语句也在 switch语句中使用）
// continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定
练习
三角形
package struct0;
public class TestDemo {
public static void main(String[] args) {
for(int i=1; i<=5;i++){
for (int j=5;j>=i;j--){
System.out.print(" ");
}
for (int j = 1; j <=i; j++) {
System.out.print("*");
}
for ( int h=1;h<i;h++){
System.out.print("*");
}
System.out.println();
}
}
}
*
***
*****
*******
*********
}
}
}
}
// break在任何新环语句的主体部分，均可用 break控制循环的流程
//break用于强行退出循环，不执行循环中剩余的语句。（ break语句也在 switch语句中使用）
// continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定
## 练习
**三角形**
```java
package struct0;
public class TestDemo {
public static void main(String[] args) {
for(int i=1; i<=5;i++){
for (int j=5;j>=i;j--){
System.out.print(" ");
}
for (int j = 1; j <=i; j++) {
System.out.print("*");
}
for ( int h=1;h<i;h++){
System.out.print("*");
}
System.out.println();
}
}
}
*
***
*****
*******
*********
扫一扫
234
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
