Java流程控制

Alt.9

已于 2024-11-27 14:10:12 修改

阅读量1k

点赞数 23

分类专栏：笔记文章标签： java 开发语言

于 2024-10-25 22:04:44 首次发布

本文链接：https://blog.youkuaiyun.com/await_9/article/details/143188342

版权

笔记专栏收录该内容

50 篇文章

订阅专栏

提示：红色的需要注意，蓝底为例题

用户交互Scanner

通过工具类，实现用户的输入。Scanner类的使用如下：

Scanner s=new Scanner(System.in)；

通过Scanner类的next（）与nextLine（）方法获取输入的字符串，在读取前用hasNext（）与hasNextLine（）判断是否还有输入的数据。

法一：使用next（）接收、hasNext（）判断：

注：next（)

在读取到有效字符后才会结束输入
在输入有效字符前遇见空格，next（）方法会自动去掉空格
在输入有效字符后输入空格，空格作为分隔符或结束符
next（）无法输入带有空格的字符串

法二：使用nextLine（）接收、hasNextLine（）判断

使用方法与next（）一致，

new一个sanner对象用来接收数据
判断用户是否输入字符
创建一个字符串对象接收输入的数据

 Scanner scanner=new Scanner(System.in);//创建对象接收键盘的输入
        System.out.println("使用nextLine方式接收");
        if(scanner.hasNextLine()){//判断是否输入字符
            String str=scanner.nextLine();//创建一个str字符串存储用nextLine（）方法接收的数据
            System.out.println("输出内容："+str);
        }
        scanner.close();

注：nextLine（）

以Enter为结束符，nextLine（）方法返回输入回车之前所有的字符
可以获得带有空白的字符串

以上两种方法都可不用判断语句，如下：

        Scanner scanner=new Scanner(System.in);//关键语句1，创建scanner对象
        System.out.println("请输入：");
        String str=scanner.nextLine();//关键语句2，通过什么函数接收数据
        System.out.println("输入内容："+str);
        System.out.println("------------------------");
        Scanner scanner1=new Scanner(System.in);
        System.out.println("再次输入：");
        String str1=scanner1.next();
        System.out.println("再次输入的内容："+str1);
        scanner.close();
        scanner1.close();

主要注意next（）与nextLine（）区别

拓展：

通过nextIn（）获取整数，hasNextInt（）判断是否输入整数

通过nextFloat（）获取小数，hasNextFloat（）判断是否输入小数

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("输入的不是整数数据");
        }
        //判断是否输入字符
        Scanner scanner1=new Scanner(System.in);
        System.out.println("请输入数字：");
        if(scanner1.hasNextFloat()){
            f=scanner1.nextFloat();
            System.out.println("小数数据:"+f);
        }

Scanner 类有许多方法，可以选中Scanner单击，查看Scanner类的源码，然后点击Structure查看Scanner类中排版好了的方法

知识点总结练习题：输入多个数字，并求总和与平均数，每输入一个数字用回车确认
通过输入非数字来结束输入并输出执行结果

思路：根据题意用到输入Scanner类，多次输入并判断用while（），判断是否为数字用hasNextDouble（）。

变量名：求和用total，求平均数用avg，平均数的计算需要输入个数，用i表示输入次数，并自增，用num接收输入的数字

        Scanner scanner=new Scanner(System.in);
        double num=0;
        double total=0;
        double avg=0.0;
        int i=0;
        System.out.println("请输入数字、退出请按字符：");
        while(scanner.hasNextDouble()){
            num=scanner.nextDouble();
            total=total+num;
            ++i;
            avg=total/i;
        }
            System.out.println("输入的数字之和："+total);
            System.out.println("输入的数字平均数"+avg);

        scanner.close();

String类

概述：String类在java.lang包下，不需要导包。String类表示字符串，eg："abc"

Java程序中所有双引号字符串，都是String类的对象。

字符串的特点：

字符串不可变，它们的值在创建后不能被更改。
String的值可以被共享。
效果上相当于字符数组char[]，底层原理是字节数组byte[]

String构造方法：

public String()	创建一个空白字符串对象，不含有任何内容
public String(char[] cha)	根据字符数组的内容，来创建字符串对象
public String(byte[ ] bys)	根据字节数组的内容，来创建字符串对象
String s="abc"	直接复制的方式创建字符串对象，eg：abc

字符串比较：

所有==做比较

基本类型：比较数据值是否相同
引用类型：比较地址值是否相同

字符串是对象，它比较内容是否相同，用equals()方法来实现的，

public boolean equals(Object anObject) //比较字符串对象，参数传递一个字符串

用法：字符串对象.equals(字符串对象)

顺序结构

语句执行顺序：从上带下顺序执行，是所有算法的基本算法结构

选择结构

为了语句判断是否需要执行

if单选则结构

if（布尔表达式）{

//如果为true，则执行

}

简单案例：判断输入的字符是否为Hello，如果匹配为Hello就输出Hello，否则输出End

        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，执行

}

简单案例：考试分数60以上为及格，60以下不及格

        Scanner scanner=new Scanner(System.in);
        System.out.println("输入考试分数：");
        double score=scanner.nextDouble();
        if (score>=60){
            System.out.println("及格");
        }else {
            System.out.println("不及格");
        }
        scanner.close();

if多选择结构

if（布尔表达式1）{

//如果布尔表达式1为true，执行

}else if（布尔表达式2）{

//如果布尔表达式2为true，执行

}

else if（布尔表达式3）{

//如果布尔表达式3为true，执行

}else{

//如果以上布尔表达式都不为true，执行

}

简单案例：考试分数100为满分，100~90为A级，60以下不及格，100~0以外不合法

        Scanner scanner=new Scanner(System.in);
        System.out.println("输入考试分数：");
        double score=scanner.nextDouble();
        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){
            System.out.println("不及格");
        }else {
            System.out.println("成绩不合法");
        }
        scanner.close();

嵌套的if结构

if（布尔表达式）{

//如果布尔表达式1为true，执行

if（布尔表达式 2）{

//如果布尔表达式2为true，执行

}

}

switch多选择结构

判断一个变量与一系列值中某个值是否相等，每一个值称为一个分支

switch (expression){
    case value:
        //语句
        break;//可选
    case value:
        //语句
        break;//可选
    default:
        //语句
}

注意：expression表示变量类型，常用

byte、short、int、char
Java SE 7开始支持String类型
case标签必须为字符串常量或字面量

break的使用：当grade有A~E以及其他字符等6种情况，不同情况输出不同的提示信息

 char grade='C';
        switch (grade){
            case 'A':
                System.out.println("优秀");
                break;
            case 'B':
                System.out.println("良好");
            case 'C':
                System.out.println("及格");
            case 'D':
                System.out.println("继续努力");
            case 'E':
                System.out.println("加油啊！");
            default:
                System.out.println("出错");
        }

因为

case穿透 switch匹配一个具体的值
有break才会跳出循环，如grade=‘C’，则case c后所有条件继续执行，如上图

输入grade=‘A’，只会执行case A，因为执行break后跳出循环，如下图

字符串匹配：（Java SE 7开始支持String类型）

反编译：.java文件（源文件）编译后变成.class文件（字节码文件），正常情况下，字节码文件人类无法理解，所以需要反编译成人类可以看懂的文件，利用IDEA反编译步骤如下：（在面向对象的对象创建分析中有一个打开所有类的字节码文件的流程）

第一步：找到字节码文件

找到文件路劲后，打开该文件中的out，

打开一个自己想要反编译的字节码文件

（直接打开是乱码）

第二步：将字节码文件导入在idea中

不能直接在idea中复制

需要打开源文件路径，选中需要选中一个文件夹，点击右键，然后选中打开文件路径

在打开的文件路径中进行复制

即可在idea中打开SwitchDemo2的字节码文件，以下左边源文件，右边字节码文件

其中hashCode（）是每一个对象都会通过特定算法生成自己的hash值

循环结构

引入循环，让相同的操作进行多次执行

while循环

while（布尔表达式）{

//循环内容

}

注意：

表达式为true时，循环一直执行
想要停止循环，需要用一个让表达式失效的方式，否则为造成死循环（循环一直执行）
需要循环一直执行的情况有服务器的请求响应监听

例题：从1~100相加，结果为多少？

        int sum=0;
        int i=0;
        while (i<100){//根据布尔表达式不同的表达，来调整循i的初始值
            i++;//i自增，依次得到从1~100的数
            sum=sum+i;//求和
        }
        System.out.println(i);//100
        System.out.println(sum);//5050

注意：不满足条件，则无法进入循环

do……while循环

do{

//执行代码

}while（布尔表达式）；

例题：从1~100相加，结果为多少？

        int sum=0;
        int i=0;
        do{
            i++;
            sum=sum+i;
        }while (i<100);
        System.out.println(i);//100
        System.out.println(sum);//5050

do……while至少循环一次

注意：while先判断后执行，dowhile先执行后判断，下例代码可证明

        int a=0;
        int b=0;
        while (a<0){
            a++;
        }
        System.out.println(a);//0
        do {
            b++;            
        }while (b<0);
        System.out.println(b);//1

for循环

普通for循环

for循环的循环结构更简单，是支持迭代的一种通用结构，是最有效、最灵活的循环结构

for(初始化；布尔表达式；更新){

//执行代码块

}

练习：依次输出1~100

     //初始值//条件判断//迭代
        for (int i=1;i<=100;i++){
            System.out.println(i);
        }
        System.out.println("for循环结束");

for循环执行流程：

先执行初始化步骤，可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句
检测布尔表达式的值，如果是true，循环体执行，如果是 false，循环终止，开始执行循环之外的语句
执行一次循环后，更新循环控制变量（迭代）
再次检测布尔值，执行以上过程

while与for逻辑对比

for循环的死循环表达：

for( ; ; ;){

//执行代码块

}

快捷键辅助学习：100.for加回车，

自动生成条件

练习：计算0~100的奇数和偶数之和

输出0~100的数，用while（），判断奇偶性，用for（）。

        //计算0~100之间的奇数和偶数之和
        int oddsum=0;//奇数之和
        int evensum=0;//偶数之和
        for(int i=0;i<=100;i++){
            if(i%2==0){
                //偶数，偶数能够被2整除
                evensum=evensum+i;
            }else{
                oddsum=oddsum+i;
            }
            System.out.println(i);//验证是否是从0~100，可忽略不写
        }
        System.out.println("偶数之和"+evensum);//2550
        System.out.println("奇数之和"+oddsum);//2500

练习：用while或for循环输出1~1000之间能被5整除的数，并每行输出3个

        //用while或for循环输出1~1000之间能被5整除的数，并每行输出3个
        for (int i = 0; i <= 1000; i++) {
            if (i%5==0){
                System.out.print(i+"\t");
            }
            //实现三个自动换行
            if (i%(5*3)==0){//3个换行，一个隔5，所以能被15整除的数字就换行
                System.out.println();//换行有两种
                //System.out.print("\n");
                /*
                print()输出完不会换行
                println（）输出完自动换行
                /t表Tab   /n表换行
                 */
            }
        }
        System.out.println("for循环结束");

        int a=0;
        while (a<=1000){
            if (a%5==0){
                System.out.print(a+"\t");
            }
            if (a%15==0){
                System.out.println();
            }
            a++;
        }
        System.out.println("wile循环结束");

练习：打印九九乘法表

        //打印九九乘法表
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <=i ; j++) {//j<=i能够去掉重复行
                /*
                第一轮，i=1，j=1，得到1*1=1，内循环结束，执行换行
                第二轮，i=2，j=1，得到1*2=2，2*2=4，内循环结束，执行换行
                第三轮，i=3，j=1，得到1*3=3，2*3=6，3*3=9，内循环结束，执行换行
                 */
                System.out.print(j+"*"+i+"="+i*j+"\t");
            }
            System.out.println();//换行
        }

易错点：

增强for循环

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

for（声明语句：表达式）{

//执行语句

}

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

表达式：表达式是要访问的数组名，或者是返回值为数组的方法。（数组在后面会说）

        int[] numbers={10,20,30,40};//定义一个整数型的数组
        //普通for遍历
        for (int i=0;i<4;i++){
            System.out.println(numbers[i]);//数组下标从0开始，输出数组所有元素
        }
        System.out.println("=======================");
        //增强for遍历
        for (int x:numbers){//将numbers数组中每一项赋值给int x
            System.out.println(x);

break&continue

break可以用于任何循环语句主体部分，主要作用是强行退出循环，不执行循环语句中的剩余部分

continue用在循环语句体中，用于终止某次循环过程，跳过循环体进行下一步是否执行循环的判定

break理解：

continue理解：

结果对比：

拓展：goto关键字：利用break与continue后加上标签实现goto

标签是指后面加上一个冒号的标识符，eg：label：

使用场景：在循环语句之前，为了在其中镶嵌另一个循环，由于break和continue关键字通常只中断当前循环，但加上标签使用，它会中断到标签存在的地方。

案例：打印101~150之间所有的质数，理解用法即可，不建议使用

        //打印101~150之间所有的质数（大于1的自然数中，除了1和它本身，不能被其他自然是整除）
        int count=0;
        outer:for (int i=101;i<150;i++){//依次计算101~150
            for (int j=2;j<i;j++){//判断是否为质数的循环
                if (i%j==0){//能被任何一个数整除，都跳出该数字验证的循环
                    continue outer;
                }
            }
            System.out.print(i+" ");
        }

综合练习：打印一个五行的三角形

//打印三角形
        for (int i=1;i<=5;i++){
            /*
            第一轮，得到五个空格
            第二轮，得到四个空格
             */
            for (int j=5;j>=i;j--){
                System.out.print(" ");
            }
            /*
            第一轮1个※
            第二轮2个※
             */
            for (int j=1;j<=i;j++){
                System.out.print("*");
            }
            /*
            第一轮无※
            第二轮1个※
             */
            for (int j=1;j<i;j++){
                System.out.print("*");
            }
            /*
            综上
            第一轮左边5个空格加1个*，换行
            第二轮左边4个空格加3个*，换行
             */
            System.out.println();
        }

前两个内循环主要得到左边图像，最后一个内循环得到右边，

理解即可

用户登录

模拟用户登录，已知用户名，密码，限制三次机会，登录成功给出提示

//模拟用户登录，已知用户名，密码，限制三次机会，登录成功给出提示
public class StringDemo2 {
    public static void main(String[] args) {
        String username="Ctrl001";
        String password="user123";
        for (int i = 0; i < 3; i++) {
            Scanner scanner = new Scanner(System.in);//Java流程控制的用户交互中有解锁
            System.out.println("请输入用户名：");
            String name=scanner.nextLine();
            System.out.println("请输入密码");
            String pwd=scanner.nextLine();
            if (name.equals(username)&&pwd.equals(password)){
                System.out.println("登录成功");
                break;
            }else {
                if (2-i==0){
                    System.out.println("密码错误，账户锁定");
                }else {
                    System.out.println("登录失败，还有"+(2-i)+"次机会");
                }

            }
        }

    }
}