java_day05_1Java流程控制

JAVA流程控制

目录

  1. 用户交互Scanner

  2. 顺序结构

  3. 选择结构

  4. 循环结构

  5. break & continue

  6. 练习

1 Scanner对象

  • Java.util.Scanner是java5的新特征，我们可以通过Scanner类来获取用户的输入。

  • 基本语法：

 Scanner s = new Scanner(System.in);

  • 通过Scanner类的next()与nextLine()方法获取输入的字符串，在获取前我们一般用hasNext()与hasNextLine()判断是否还有输入的数据。注意这是两对命令，配套使用。

1.1 next():

  • 一定要取到有效字符后才可以结束输入。

  • 对输入有效字符之前遇到的空白，next()方法会自动将其去掉。

  • 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。

  • next()不能得到带有空格的字符串

  •  package com.xin.scanner;
     ?
     import java.util.Scanner;
     ?
     public class Demo01 {
         public static void main(String[] args) {
             //创建一个扫描器对象，用于接收键盘数据
             Scanner scanner = new Scanner(System.in);  //右侧打完，按a|t+enter，可以在左侧自动创建相应类型变量
             System.out.println("使用next方式接收");
             //判断用户有没有输入字符
             if (scanner.hasNext()){
                 String str = scanner.next();
                 System.out.println("输出的内容为："+ str);
             }
             scanner.close();  //用完就关掉，节约资源
     ?
         }
     }

结果如下：绿色为键盘输入

1.2 nextLine()

  • 以Enter作为结束符，也就是说nextline()方法返回的是输入回车之前的所有字符。

  • 可以获得空白

 package com.xin.scanner;
 ?
 import java.util.Scanner;
 ?
 public class Demo02 {
     public static void main(String[] args) {
         //创建一个扫描器对象，用于接收键盘数据
         Scanner scanner = new Scanner(System.in);  //右侧打完，按a|t+enter，可以在左侧自动创建相应类型变量
         System.out.println("使用nextLine方式接收");
         //判断用户有没有输入字符
         if (scanner.hasNextLine()){               //判断是否还有输入
             String str = scanner.nextLine();
             System.out.println("输出的内容为："+ str);
         }
         scanner.close();  //用完就关掉，节约资源
 ?
     }
 }

结果如下：绿色为键盘输入

1.3 Scanner进阶使用

  • next()与nextLine可以和int，float,double等配合使用，更加精准。

 package com.xin.scanner;
 ?
 import java.util.Scanner;
 ?
 public class Demo04 {
     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("您输入的不是整数数据");
         }
 ?
         if (scanner.hasNextFloat()){
             f = scanner.nextFloat();
             System.out.println("小数数据：" + f);
         }else{
             System.out.println("您输入的不是小数数据");
         }
         scanner.close();
     }
 }

结果如下：绿色为键盘输入

 

  • 使用while进行多次输入

 package com.xin.scanner;
 ?
 import java.util.Scanner;
 ?
 public class Demo05 {
     public static void main(String[] args) {
         //我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果
         Scanner scanner = new Scanner(System.in);
         //和
         double sum = 0;
         //计算输入了多少个数字
         int m = 0;
         double average = 0;
         //通过循环判断是否还有输入，并在里边对每一次求和统计
         while (scanner.hasNextDouble()){     //不是数字就退出了
             double x = scanner.nextDouble();
             //
             System.out.println("输入了第"+(m+1)+"个数字");
             m = m +1;
 ?
             sum += x;
         }
         average = sum / m;
         System.out.println(m +"个数总和为："+ sum);
         System.out.println(m +"个数平均值为："+ average);
 ?
         scanner.close();
 ?
 ?
 ?
     }
 }

结果如下：

2 顺序结构

  • Java的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句句执行。

  • 语句与语句之间，框与框之间是按从上到下的顺序执行的，它是由若干个依次执行的处理步骤组成的。

  •  package com.xin.struct;
     ?
     public class shunxuDemo {
         public static void main(String[] args) {
             System.out.println("hello1");
             System.out.println("hello2");
             System.out.println("hello3");
             System.out.println("hello4");
             System.out.println("hello5");
         }
     }

结果如下：

3 选择结构

  • if单选择结构

  • if双选择结构

  • if多选择结构

  • 嵌套的if结构

  • switch多选择结构

3.1 if单选择结构

  • 使用场景：需要去判断一个东西是否可行，然后才去执行，这时用if

  • 语法：

 if (布尔表达式){
     //如果布尔表达式为true将执行的语句
     }
 package com.xin.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();
 //        判断字符串是否相等
         if (s.equals("hello")){
             System.out.println(s);
         }
         System.out.println("End");
         scanner.close();
 ?
     }
 }

结果如下：

3.2 if双选择结构

  • 语法：

 if (布尔表达式){
     //如果布尔表达式为true将执行的语句
     }else{
     //如果布尔表达式为false将执行的语句
 }
 package com.xin.struct;
 ?
 import org.w3c.dom.ls.LSOutput;
 ?
 import java.util.Scanner;
 ?
 public class ifDemo02 {
     public static void main(String[] args) {
         //考试成绩大于60是及格，小于60就是不及格
         Scanner scanner = new Scanner(System.in);
         System.out.println("请输入成绩：");
         int score = scanner.nextInt();
         if (score>60){
             System.out.println("恭喜您！您的成绩及格了");
         }else{
             System.out.println("很遗憾！您挂了");
         }
         scanner.close();
 ?
     }
 }

3.3 if多选择结构

语法：

 if (布尔表达式1){
     //如果布尔表达式1的值为true将执行的语句
     }else if(布尔表达式2){
     //如果布尔表达式2的值为true将执行的语句
     }else if(布尔表达式3){
     //如果布尔表达式3的值为true将执行的语句
     else{
     //如果以上布尔表达式的值都不为true将执行的语句
 }
 package com.xin.struct;
 ?
 import java.util.Scanner;
 ?
 public class ifDemo03 {
     public static void main(String[] args) {
         Scanner scanner = new Scanner(System.in);
         System.out.println("请输入您的成绩：");    //要写在读取用户输入之前
         int score = scanner.nextInt();
 ?
         if (score>90){
             System.out.println("您真牛逼");
         }else if(score>80){
             System.out.println("可以可以，集训努力");
         }else if(score>60){
             System.out.println("还得加油啊");
         }else{
             System.out.println("小垃圾");
         }
         scanner.close();      //必须添加，节约资源
     }
 }

3.4 嵌套的if结构

  • 使用嵌套的if...else语句是合法的，即可以在另一个if或者else if语句中使用if或者else if语句。

 if(布尔表达式 1){
     
    //如果布尔表达式1的值为true将执行的语句
     
    if(布尔表达式 2){
        
    //如果布尔表达式2的值为true将执行的语句
        
    }
 }

  • 示例如下：

 package com.xin.struct;
 ?
 import java.util.Scanner;
 ?
 public class ifDemo4 {
     public static void main(String[] args) {
         Scanner scanner = new Scanner(System.in);
         System.out.println("请输入一个1~10之间的整数");
         int data = scanner.nextInt();
         if (data > 5) {
             if (data > 6) {
                 if (data > 7) {
                     System.out.println("您输入的数大于7");
                 } else {
                     System.out.println("您输入的数是7");
                 }
             } else {
                 System.out.println("您输入的数是6");
             }
         } else {
             System.out.println("您输入的数小于等于5");
         }
         scanner.close();
     }
 }

3.5 switch多选择结构

  • switch语句判断一个变量与一系列中某个值是否相等，每个值成为一个分支。

  • switch语句中的变量类型可以是

    • byte、short、int或者char

    • 从Java SE 7开始，switch支持字符串String类型了

    • 同时case标签必须为字符串常量或字面量

语法：

 switch(expression){
     case value:
         //语句
         break；  //可选,如果没有就会继续输出
     case value;
         //语句
         break；  //可选
     default ：    //可选即可以不写
         //语句    
 }

  • 示例如下：

 package com.xin.struct;
 ?
 import java.sql.SQLOutput;
 import java.util.Scanner;
 ?
 public class SwitchDemo01 {
     public static void main(String[] args) {
         Scanner scanner = new Scanner(System.in);
         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("未知等级");
         }
     }
 }

4 循环结构

4.1 while循环

  • while是最基本的循环，结构为

 while(布尔表达式){
     //循环内容
 }

  • 只要布尔表达式为true，循环就会一直执行下去

  • 大多数情况会让循环停止，需要一个让表达式失效的方式来结束循环

  • 少部分情况循环需要一直执行，比如服务器的请求响应监听等

  • 平常要避免无限循环

示例如下：从0加到100

 package com.xin.struct;
 ?
 public class whileDemo01 {
     public static void main(String[] args) {
         int i =0;
         int sum = 0;
         while(i<=100){
 ?
             sum =sum+i;
             i++;
         }
         System.out.println(sum);
     }
 }

结果如下：

4.2 do...while循环

  • do...while和while类似，不同的是do...while循环至少会执行一次，先do

 do{
     //代码语句
 }while(布尔表达式)；
 package com.xin.struct;
 ?
 public class DoWhileDemo01 {
     public static void main(String[] args) {
         int i  = 0;
         int sum = 0;
         do {
             sum =sum + i;
             i++;
         }while(i<=100);
         System.out.println(sum);
 ?
     }
 }

  • do...while和while的区别：

    • while先判断后执行，do...while先执行后判断！

    • do...while总是保证循环体至少被执行一次；

 package com.xin.struct;
 ?
 public class DoWhileDemo02 {
     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++;                              //输出0，在线的下边
         }while(a<0);
     }
 }

4.3 For循环

  • for循环时支持迭代的一种通用结构，是最有效、最灵活的循环结构。

  • for循环执行的次数是在执行前就确定的

语法如下：

 for (初始化； 布尔表达式； 更新){
     //代码语句
 }
 快捷写法,结果如下：100.for
     for (int i = 0; i < 100; i++) {
             
         }

练习1

 package com.xin.struct;
 ?
 public class ForDemo02 {
     public static void main(String[] args) {
         //计算0到100奇数和偶数的和
         int odd = 0;   //奇数和
         int even =0;   //偶数和
         for (int a =0; a<=100; a++) {
             if (a % 2 == 0) {
                 even = even + a;
             } else {
                 odd = odd + a;
             }
         }
         System.out.println("奇数和为"+ odd);    //2500
         System.out.println("偶数和为"+ even);    //2550
     }
 ?
 }

练习2

 package com.xin.struct;
 ?
 public class ForDemo03 {
     public static void main(String[] args) {
         //练习2：用while或者for循环输出1-1000之间能被5整除的数，并且每行输出3个
         int num = 1;
         int count =0;
         int i = 0;
 //        for (; num<=1000; num++){
 //            if (num%5 == 0){
 //
 //                i++;
 //                if ((i-1)%3 == 0){
 //                    System.out.println('\n');
 //                }
 //                System.out.println("第" + i +"个能被5整除的数:" +num);
 //            }
 //        }                            //输出的数自己独占一行，不能一行三个
         for (int i1 = 0; i1 < 1000; i1++) {
             if (i1 % 5 ==0){
                 System.out.print(i1 + "\t");
             }
             if ((i1 % (5 *3) ==0) ){
                 System.out.println();
                 //System.out.println('\n');
             }
         }
     }
 }

结果如下：

练习3

  • 九九乘法表，双for循环嵌套

 package com.xin.struct;
 ?
 /*
   打印九九乘法表
   1*1=1
   1*2=2 2*2=4
   1*3=3 2*3=6 3*3=9
 ?
 */
 public class ForDemo04 {
     public static void main(String[] args) {
         for (int i = 1; i <= 9; i++) {
             for (int j = 1;  j<= 9; j++) {
                 if (j<=i) {
                     //System.out.print(j);
                     //System.out.print('\t');
                     System.out.print(j + "*" + i + "=" + (i * j));   //这里乘法要用双引号，单引号会出错
                     System.out.print('\t');
                 }
             }
             System.out.print('\n');
         }
     }
 }

结果如下：

4.4 增强for循环

  • Java5引入了一种主要用于数组或集合的增强型for循环

语法如下：

 for (声明语句，表达式)
 {
     //代码句子
 }

  1. 声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

  2. 表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

示例如下：

 package com.xin.struct;
 ?
 public class ForDemo05 {
     public static void main(String[] args) {
         int[] numbers = {10, 20, 30, 40, 50}; //定义了
         for (int x:numbers){
             System.out.println(x);
         }
     }
 }

5 break && continue

  • break在任何循环语句的主体部分，用于强行退出循环，之后不执行循环中剩余的语句。（其也在switch中使用）

 package com.xin.struct;
 ?
 public class BreakDemo {
     public static void main(String[] args) {
         int i = 0;
         while(i<100){
             i++;
             if (i==30){
                 System.out.println(i);
                 break;        //执行直接循环结束
             }
         }
         System.out.println(123);
     }
 }

  • continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

 package com.xin.struct;
 ?
 public class ContinueDemo {
     public static void main(String[] args) {
         int i = 0;
         while (i<50){
             i++;
             if (i % 10 == 0){
                 System.out.println();
                 continue;
             }
             System.out.print(i +"\t");    //没有执行输出10的倍数
         }
     }
 }

结果如下：

6 练习

  • 打印三角形

 package com.xin.struct;
 ?
 public class TestDemo {
     public static void main(String[] args) {
         //打印三角形  5行
         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 j = 1; j < i; j++) {
                 System.out.print("*");
             }      //右侧三角型
             System.out.println();
         }
     }
 }

结果如下：

知识补充

1 class文件重命名

  • 在程序内，class文件重命名，在相应class文件，右键->Refactor->Rename

  • 或者直接去找到相应文件夹去更改

2 new快速创建变量

  • 右侧打完，按a|t+enter，可以在左侧自动创建相应类型变量

3 反编译

  • java---class(字节码文件)---反编译(IDEA)

  • 如何反编译，打开class文件？->打开对应文件夹的out里边的文件，找到class后缀文件，用Java打开，就可以查看反编译代码了

4 System.out.println()和System.out.print()

  • 第一个输出之后换行，第二个不换行

5 debug方式

  • 了解程序运行进制

  • 在代码左侧点击，进行断点，点击小蟑螂，在下方小箭头一步步运行

6

JavaSE

相关

JavaSE打开windows文件

JavaSE复习巩固

JavaSE01 Java的特性和优势

JavaSE-注解-Annatation-理解注解及其使用

【0基础学java】教学日志：javaSE-面向对象4-继承、super、方法重写、抽象类、抽象方法

JavaSE-泛型、异常

JavaSE12-封装、继承和多态

JavaSE10-面向对象

JavaSE学习

JAVASE基础知识

JavaSE基础-递归

javase-常用三种遍历方法

标签