6，JAVA流程控制

目录

  1. 用户交互Scanner

  2. 顺序结构

  3. 选择结构

  4. 循环结构

  5. break&continue

  6. 练习

1，Scanner对象

之前我们学的基本语法中我们并没有实现程序和人的交互，但是Java给我们提供了这样一个工具类，我们可以获取用户的输入。java.util.Scanner是Java5的新特征，我们可以通过Scanner类来获取用户的输入。

 Scanner s=new Scanner(System.in);

通过Scanner类next的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNnextLine()判断是否还有输入的数据。

 package com.kuang.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()==true){
             //使用next方式接收
             String str =scanner.next();
             System.out.println("输出内容为："+str);
         }
         //凡是属于IO流的类如果不关闭会一直占用资源，要养成好习惯用完就关掉
         scanner.close();
     }
 }
 ​
 package com.kuang.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);
         }
         scanner.close();
     }
 }
 ​
 package com.kuang.scanner;
 import java.util.Scanner;
 public class Demo03 {
     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();
     }
 }//简写

next()

  1. 一定要读取到有效字符后才可以结束输入

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

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

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

nextLine()

  1. 以Enter为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符

  2. 可以获得空白

 package com.kuang.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("输入的不是整数数据！");
         }
 ​
         System.out.println("请输入小数：");
         if (scanner.hasNextFloat()){
             f=scanner.nextFloat();
             System.out.println("小数数据："+f);
         }
         else{
             System.out.println("输入的不是小数数据！");
         }
         scanner.close();
     }
 }
 package com.kuang.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;
         //通过循环判断是否还有输入，并在里面对每一次进行求和和统计
         while (scanner.hasNextDouble()){
             double x= scanner.nextDouble();
             m=m+1;//m++
             sum =sum +x;
         }
         System.out.println(m+"个数的和为"+sum);
         System.out.println(m+"个数的平均值是"+(sum/m));
         scanner.close();
     }
 }

2,顺序结构

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

  2. 顺序结构是最简单的算法结构，它是任何一个算法都李不卡的一种基本算法结构。

 package com.kuang.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,选择结构

  1. IF的单选择结构

  2. IF的双选择结构

  3. IF的多选择结构

  4. 嵌套的IF结构

  5. switch多选择结构

if单选择结构

 package com.kuang.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")) {//equals:判断字符串是否相等
             System.out.println(s);
         }
         System.out.println("End");
         scanner.close();
     }
 }

if双选择结构（if else）

 package com.kuang.struct;
 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();
     }
 }

if多选择结构（if else if else if else）

 package com.kuang.struct;
 import java.util.Scanner;
 public class IfDemo03 {
     public static void main(String[] args) {
         //考试分数大于60就是几个，小于60就是不及格
         Scanner scanner=new Scanner(System.in);
         System.out.println("请输入成绩：");
         int score=scanner.nextInt();
         if (score==100){
             System.out.println("恭喜满分");
         }
         else if(score<100&&score>=90){
             System.out.println("A级");}
             else if(score<90&&score>=80){
             System.out.println("B级");}
             else if(score<80&&score>=70){
             System.out.println("C级");}
             else if(score<70&&score>=60){
             System.out.println("D级");}
         else if(score<60&&score>=0){
             System.out.println("不及格");}
             else{
                             System.out.println("成绩不合法");
                         }
         scanner.close();
         }
     }//一旦其中一个else if语句检测为true，其他的else if以及else语句都将跳过执行

嵌套的if结构

switch多选择结构

switch语句中的变量类型可以是byte、short、int、char。从java SE7开始，switch支持字符串String类型了。同时case标签必须为字符串常量或字面量。

package com.kuang.struct;
public class SwitchDemo01 {
    public static void main(String[] args) {
        char grade ='B';
        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("未知等级");break;
        }
    }
}
package com.kuang.struct;
public class SwitchDemo02 {
    public static void main(String[] args) {
        String name="秦疆";
        //JDK7的新特性，表达式结果可以是字符串
        //字符的本质还是数字
        //反编译
        switch (name){
            case "秦疆":
                System.out.println("秦疆");break;
            case "狂神":
                System.out.println("狂神");break;
            default:
                System.out.println("弄啥嘞！");
        }
    }
}

不太明白反编译和看源码

4，循环结构

  1. while循环

  2. do...while循环

  3. for循环

  4. 在Java5中引入了一种主要用于数组的增强型for循环。

while循环

while是最基本的循环，只要布尔表达式为true，循环会一直执行下去。

package com.kuang.struct;
public class WhileDemo01 {
    public static void main(String[] args) {
        //输出1-100
        int i=0;
        while (i<100){
            i++;
            System.out.println(i);
        }
    }
}
package com.kuang.struct;
public class WhileDemo02 {
    public static void main(String[] args) {
        int i=0;
        int sum=0;
        while (i<100){
            i++;
            sum=sum+i;
        }
        System.out.println(sum);
    }
}

do...while循环

while循环先判断后执行，do...while是先执行后判断，后者总是保证循环体会被至少执行一次，这是他们的主要差别。

package com.kuang.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);
    }
}

for循环

for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。for循环执的次是在执行前就确定的。

for(初始化；布尔表达式；更新)
{//代码语句}
package com.kuang.struct;
public class ForDemo01 {
    public static void main(String[] args) {
        int a=1;//初始化条件
        while (a<=100){//条件判断
            System.out.println(a);//循环体
            a+=2;//迭代
        }
        System.out.println("while循环结束！");

       //通过100.for然后回车，可迅速打出：for (int i = 0; i < 100; i++) {}
           //初始化//条件判断//迭代
        for (int i=1;i<=100;i++){
            System.out.println(i);
        }
        System.out.println("for循环结束！");
    }
}

  1. 可初始化一个或多个循环控制变量，也可以 是空语句

  2. 条件判断，如果为True，循环被执行，为False，循环终止。

package com.kuang.struct;
public class ForDemo02 {
    public static void main(String[] args) {
        //计算0到100之间的奇数和偶数的和
        int oddsum=0;
        int evensum=0;
        for (int i = 0; i <=100; i++) {
            if (i%2==0) {
                oddsum+=i;
            }
            else{
                evensum+=i;
            }
        }
        System.out.println(oddsum);
        System.out.println(evensum);
    }
}
package com.kuang.struct;
public class ForDemo03 {
    public static void main(String[] args) {
        for (int i = 0; i <= 1000; i++) {
            if(i%5==0){
                System.out.print(i+"\t");
            }
            if(i%15==0){
                System.out.println();// System.out.print("\n");
            }
        }
    }
}//筛选出从0-1000之间能被5整除的数
package com.kuang.struct;
public class ForDemo04 {
    public static void main(String[] args) {
        for (int i = 1; i < 10; i++) {
            for (int a=1;a<=i;a++){
                System.out.print(i+"*"+a+"="+i*a+"\t");
                if (a==i){
                    System.out.println();
                }
            }
        }
    }
}//打印九九乘法表

增强for循环

主要用于数组或集合的增强型for循环

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

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

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

 package com.kuang.struct;
 public class ForDemo05 {
     public static void main(String[] args) {
         int[] number={10,20,30,40,50};//定义了一个数组
         for (int i=0;i<5;i++){
             System.out.println(number[i]);
         }
         System.out.println("=======================");
         
         //遍历数组的元素
         for(int x:number){
             System.out.println(x);
         }
     }
 }

5，break&continue

break：在任何循环语句的主题部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。（break语句也在switch语句中使用）

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

 package com.kuang.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;
             }
         }
         System.out.println("123");
     }
 }
package com.kuang.struct;
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.print(i+"\t");
        }
    }
}

6，练习

package com.kuang.method;
import java.util.Scanner;
public class Demo08 {
    public static void main(String[] args) {
        System.out.println("输入一个数，输入1234，代表加减乘除，输入另一个数");
        Scanner scanner = new Scanner(System.in);
        double a = scanner.nextDouble();
        int f = scanner.nextInt();
        double b = scanner.nextDouble();
        switch (f) {
            case 1:
                System.out.println(add(a, b));
                break;
            case 2:
                System.out.println(minus(a, b));
                break;
            case 3:
                System.out.println(time(a, b));
                break;
            case 4:
                System.out.println(divide(a, b));
                break;
            default:
                System.out.println("运算符号不符");
                break;
        }
    }
        public static double add ( double a, double b){
        return a + b;
    }
        public static double minus ( double a, double b){
        return a - b; 
    }
        public static double time ( double a, double b){
        return a * b;
    }
        public static double divide ( double a, double b){
        return a / b;
    }
}//自己设计的计算器

 

 

posted @ 2021-06-21 12:22  林涉江  阅读(318)  评论(0)    收藏  举报