第四章 1.程序流程控制

程序流程控制介绍
在程序中,程序运行的流程控制决定程序是是如何执行的,是我们必须掌握的,主要三大流程控制语句
1)顺序控制
程序从上到下逐行地执行,中间没有如何判断和跳转.

2)分支控制
有三种:

单分支
if(条件表达式){
  执行代码块;(可以有多条语句)
 }
说明:当条件表达式为true时,就会执行{}的代码.如果为false,就不执行.
特别说明,如果{}中只有一条语句,则可以不用{},建议写上{};

package cn.javageiyegun.demo04;

import java.util.Scanner;

public class If01 {
    public static void main(String[] args) {
        //编写一个程序,可以输入人的年龄,如果该同志的年龄大于18岁,则输出"要对自己的行为负责,送入监狱"
        //思路分析:
        //1.接收输入的年龄,应该定义一个Scanner 对象
        //2.把年龄保存到一个变量 int age;
        //3.使用if判断,输出对应的信息


        //接收输入的年龄,应该定义一个Scanner 对象
        Scanner myscanner = new Scanner(System.in);
        System.out.println("请输入年龄:");
        //把年龄保存到一个变量 int age;
        int age = myscanner.nextInt();
        //使用if判断,输出对应的信息
        if (age > 18){
            System.out.println("要对自己的行为负责,送入监狱");
        }

    }
}

双分支
基本语法
if(条件表达式){
    执行代码块1;
} else {
    执行代码块2;
}
说明:当条件表达式成立,即执行代码块1,否则执行代码块2.
如果执行代码块只有一条语句,则{}可以省略,否则,不能省略.

package cn.javageiyegun.demo04;

import java.util.Scanner;

public class If02 {
    public static void main(String[] args) {
        //编写一个程序,可以输入人的年龄,如果该同志的年龄大于18岁,则输出"要对自己的行为负责,送入监狱",否则,输出"你的年龄不大这次放过你了".
        Scanner myscanner = new Scanner(System.in);
        System.out.println("请输入你的年龄: ");
        int age = myscanner.nextInt();
        if (age > 18){  //双分支
            System.out.println("要对自己的行为负责,送入监狱");
        } else {
            System.out.println("你的年龄不大这次放过你了");
        }
    }
}

多分支
基本语法:
if(条件表达式1){
    执行代码块1;
} else if(....){
    执行代码块2;
}
...
else {
    执行代码块n;
}
说明:
1)当条件表达式1成立时,即执行代码块1;
2)如果表达式1不成立,才去判断表达式2是否成立;
3)如果表达式2成立,就执行代码块2;
4)以此类推,如果所有的表达式都不成立,则执行else的代码块,注意:只能有一个执行入口;
注意:多分支 可以没有else ,如果所有的条件表达式都不成立,则一个执行入口都没有
如果又else,如果所有的条件表达式都不成立,则默认执行else

package cn.javageiyegun.demo04;

import java.util.Scanner;

public class If03 {
    public static void main(String[] args) {
        //5.需求
        //输入保国同志的芝麻信用分:
        //如果:
        //信用分为100分时,输出 信用极好;
        //信用分为(80,99]时, 输出 信用优秀;
        //信用分为[60,80]时,输出信用一般;
        //其他情况,输出 信用不及格
        //请从键盘输入保国的芝麻信用分,并加以判断
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入保国的芝麻信用分 : ");

        int num = scanner.nextInt();

        //先对输入的信用分,进行一个范围的有效判断1-100,否则提示输入错误
        if (num >= 1 && num <= 100){
            if (num == 100){
                System.out.println("极好");
            } else if(num > 80 && num <= 99){
                System.out.println("优秀");
            } else if(num >= 60 && num <= 80){
                System.out.println("一般");
            } else {
                System.out.println("不及格");
            }
        } else {
            System.out.println("不在1-100范围内,请重新输入");
        }
        //思考:如果输入的不是整数,而是hello..
        //这里要使用到异常处理机制,后面会讲到

    }
}

if练习

package cn.javageiyegun.demo04;

import java.util.Scanner;

public class IfExercise01 {
    public static void main(String[] args) {
        //1.
        int x = 7;
        int y = 4;
        if(x > 5){
            if(y > 5){
                System.out.println(x + y);  //不执行
            }
                System.out.println("韩老师教育~");  //执行
        } else {
            System.out.println("x is " + x);    //不执行
        }

        //2.
        //编写程序,声明2个double型变量并赋值.判断第一个数大于10.0,且第二个数小于20.0,打印两数之和.
        double d1 = 33.5;
        double d2 = 2.6;
        if(d1 > 10.0 && d2 < 20.0){
            System.out.println("两个数和等于 = " + (d1 + d2));
        }

        //3.定义两个变量int,判断二者的和,是够能被3又能被5整除,打印提示信息
        int a = 10;
        int b = 5;
        int c = a + b;
        if (c % 3 == 0 && c % 5 == 0){
            System.out.println("成功");
        } else {
            System.out.println("失败");
        }

        //4.判断一个年份是否是闰年,闰年的条件时符合下面二者之一:(1)年份能被4整除,但不能被100整除;(2)能被400整除
        //1)定义 int year 保存 年份
        //2)年份能被4整除,但不能被100整除,
        //  year % 4 == 0 && year % 100 != 0
        //3)能被400整除  year % 400 == 0;
        //4)2 和 3 是或的关系

        //实现
        int year = 2028;
        if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0){
            System.out.println("是闰年");
        } else {
            System.out.println("不是闰年");
        }

        //5.
        boolean d = true;
        if (d == false){    //如果写成if(b = false)能编译通过吗?如果能,结果是c
            System.out.println("a");
        } else if (d) {
            System.out.println("b");   //输出b
        } else if (!d) {
            System.out.println("c");
        } else {
            System.out.println("d");
        }


    }
}

补:嵌套分支
基本介绍
在一个分支结构中又完整的嵌套了另一个完整的分支结构,里面的分支的结构称为内部分支外面的分支称为外层分支.建议:不要超过3层(可读性不好)
基本语法
if(){
    if(){
        //if-else...
    } else {
            //if-else...
        }
}

package cn.javageiyegun.demo04;

import java.util.Scanner;

public class Nestedlf {
    public static void main(String[] args) {
        //需求:参加歌手比赛,如果初赛成绩大于8.0进入比赛,否则提示淘汰.并且根据性别提示
        //进入男子组或者女子组 [可以让学员先练习下] , 输入成绩和性别,进入判断和输出信息
        //提示:double score;char gender;
        //接收字符:char gender = scanner.next().charAt(0)
        //思路分析:
        //1.创建一个scanner对象,接收用户输入;
        //2.接收一个成绩,保存到double score
        //3.使用if-else 判断 如果初赛成绩大于8.0进入决赛,否则提示淘汰
        //4.如果进入到决赛 ,在使用char gender,使用if-else输出男子或者女子组

        //实现
        Scanner myScanner = new Scanner(System.in);
        System.out.println("请输入歌手的成绩: ");
        double score = myScanner.nextDouble();
        char gender;

        if (score > 8.0){
            System.out.println("请输入性别: ");
            gender = myScanner.next().charAt(0); //目前理解是[myscanner.next()-->扫描出来是字符串 然后用.charAt(0)-->转换成字符]
            if (gender == '男'){
                System.out.println("进入男子组");
            }else if(gender == '女'){
                System.out.println("进入女子组");
            } else {
                System.out.println("你的性别有误,不能参加决赛~");
            }
        } else {
            System.out.println("不好意思,被淘汰了.");
        }
    }
}

package cn.javageiyegun.demo04;

import java.util.Scanner;

public class Nestedlf01 {
    public static void main(String[] args) {
        //需求:出票系统:根据淡旺季的月份和年龄,打印票价[课后练习]
        //旺季:成人(18-60):60  儿童(<18):半价  老人(>60):1/3;
        //淡季:成人:40  其他:20
        //思路分析:
        //1.淡旺季if-else
        //2.在旺季中,可以使用多分支处理三种情况
        //3.在淡季情况,使用双分支处理即可

        //实现
        Scanner myscanner = new Scanner(System.in);

        System.out.println("请输入年龄: ");
        int age = myscanner.nextInt();

        if(age >=1 && age <=100){
            System.out.println("请输入淡旺季:");
            char jijie = myscanner.next().charAt(0);
            if (jijie == '旺'){
                int price = 60;
                if (age > 18 && age < 60){
                    System.out.println("成人价格: " + price);
                } else if(age > 60){
                    System.out.println("老人价格: " + price/3);
                } else if (age < 18) {
                    System.out.println("儿童价格: " + price/2);
                }

            } else if(jijie == '淡'){
                if (age > 18 && age < 60){
                    System.out.println("成人价格: 60");
                } else {
                    System.out.println("价格: 20");
                }
            } else {
                System.out.println("淡旺季输入有误,请重新输入");
            }
        } else {
            System.out.println("输入年龄不在范围内,请重新输入");
        }

    }
}

3)循环控制
switch
基本语法:
switch(表达式){
    case 常量1: 语句块1;break;
    case 常量2: 语句块2;break;
    case 常量3: 语句块3;break;
    case 常量4: 语句块4;break;
        ...
    default: 语句块;break;
}
说明:
1)switch 关键字,表示switch分支
2)表达式 对应一个值
3)case 常量1:当表达式的值等于常量1,就执行 语句块1
4)break:表示退出switch
5)如果和case 常量1 匹配,就执行语句块1,如果没有匹配,就继续匹配case2
6)如果一个都没有匹配,就执行default

package cn.javageiyegun.demo04;

import java.util.Scanner;

public class Switch01 {
    public static void main(String[] args) {
        //请编写一个程序,该程序可以接收一个字符,比如a,b,c,d,e,f,g
        //a表示星期一,b表示星期二...
        //根据用户的输入显示相应的信息,要求使用switch语句完成

        //思路分析
        //1.接收一个字符,创建Scanner对象
        //2.使用switch 来完成匹配,并输出对应信息

        //实现
        Scanner myscanner = new Scanner(System.in);
        System.out.println("请输入一个字符(a-g): ");
        char c1 = myscanner.next().charAt(0);
        switch (c1){
            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;
            case 'f' :
                System.out.println("星期六");
                break;
            case 'g' :
                System.out.println("星期日");
                break;
            default:
                System.out.println("你输入的字符不正确,没有匹配到");
        }
    }
}

switchDetail
1.表达式数据类型,应和case后的常量类型一致,或者是可以自动转成可以相互比较的类型,比如输入的是字符,而常量是int
2.switch(表达式)中表达式的返回值必须是:(byte,short,int,char,enum,String)
3.case子句中的值必须是常量或者是常量表达式,而不能是变量
4.default子句是可选的,当没有匹配的case时,执行default ,如果没有default 子句,又没有匹配到任何的常量,则没有输出
5.break语句用来执行完一个case分支后使程序跳出switch语句块,如果没有写break,程序会顺序执行到switch结尾,除非遇到break

package cn.javageiyegun.demo04;

public class SwitchDetail {
    public static void main(String[] args) {
        //1.表达式数据类型,应和case后的常量类型一致,或者是可以自动转成可以相互比较的类型,比如输入的是字符,而常量是int
        char c = 'a';
        switch(c){
            case 'a':
                System.out.println("ok1");
                break;
//            case "hello":    //类型不匹配,报错
//                System.out.println("ok2");
//                break;
            case 20:
                System.out.println("ok2");
                break;
            default:
                System.out.println("ok3");
                break;
        }

        String d = "20";
        switch(d){
            case "a":
                System.out.println("ok1");
                break;
            case "20":
                System.out.println("ok2");
                break;
            default:
                System.out.println("ok3");
                break;
        }


    }
}

switch和if的比较
1)如果判断的具体数值不多,而且符合byte,short,int,char,enum,String这6种类型.虽然两个语句都可以使用,建议使用switch语句.
2)其他情况:对区间判断,对结果为boolean类型判断,使用if,if的使用范围广.

if和switch练习

package cn.javageiyegun.demo04;

import java.util.Scanner;

public class SwitchExercise {
    public static void main(String[] args) {
        //1.
        //使用 switch 把小写类型的char型转为大写(键盘输入).只转换 a->A ,b-.B
        //其他的输出"other".

        Scanner myscanner = new Scanner(System.in);
        System.out.println("请输入a-e: ");
        char c1 = myscanner.next().charAt(0);
        switch(c1){
            case 'a':
                System.out.println("A");
                break;
            case 'b':
                System.out.println("B");
                break;
            case 'c':
                System.out.println("C");
                break;
            default:
                System.out.println("输入有误!");
        }

        //2.
        //对学生成绩大于60分的,输出"合格".低于60分的.输出"不合格".(注意:输入的成绩不能大于100),提示 成绩/60
        //思路分析
        //1.可以使用分支来完成,但是要求使用switch
        //2.这里我们需要进行一个转换:
        //      如果成绩在[60,100],(int)(成绩/60) = 1;
        //      如果成绩在[0,60),(int)(成绩/60) = 0;

        //实现
        double grade = 88.5;
        //使用if-else 保证输入的成绩有效的[0-100]
        if (grade >= 0 && grade<=100){
            switch((int)(grade/60)){
                case 0 :
                    System.out.println("不合格");
                    break;
                case 1:
                    System.out.println("合格");
                    break;
            }
        } else {
            System.out.println("输入有误");
        }

        //3.根据用户指定的月份,打印该月份所属的季节  3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12,1,2 冬季
        //使用switch 来匹配  [用穿透]

        Scanner scanner = new Scanner(System.in);
        System.out.println("输入月份:");
        int month = scanner.nextInt();
        switch(month){
            case 3:
            case 4:
            case 5:
                System.out.println("春季");break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");break;
            case 12:
            case 1:
            case 2:
                System.out.println("冬季");break;
            default:
                System.out.println("输入有误!");

        }
    }
}

for循环
基本语法:
for(循环变量初始值;循环条件;循环变量迭代){
    循环操作(可以多条语句);
}
说明:
1.for 关键字 ,表示循环控制;
2.for有四要素:(1)循环变量初始化(2)循环条件(3)循环操作(4)循环变量迭代
3.循环操作,这里可以有多条语句,也就是我们要循环执行的代码
4.如果 循环操作(语句)只有一条语句,可以省略{},建议不要省略
细节
1)循环条件是返回一个布尔值表达式
2)for(;循环判断条件;)中的初始化和变量迭代可以写到其他地方,但是两边的分号不能省略.
3)循环初始值可以有多条初始化语句,但要求类型一样,并且中间用逗号隔开,循环变量迭代也可以有多条变量迭代语句,中间用逗号隔开

for循环练习

package cn.javageiyegun.demo04;

public class ForExercise {
    public static void main(String[] args) {
        //(1)打印1-100之间所有是9的倍数的整数,统计个数 及其 总和
        //思路分析:
        //1.先输出1-100
        //2.在输出的过程中,进行过滤,只输出9的倍数 i % 9 == 0;
        //3.统计个数 定义一个变量 int count = 0;当条件满足时 count++;
        //4.总和,定义一个变量int sum = 0;当条件满足时累积 sum+=i;
        //5.为了适应更好的需求,把范围的开始的值和结束的值,做出变量,还可以更进一步 把9倍数也做成变量 int t = 9;
        int count = 0;
        int sum = 0;
        int start = 10;
        int end = 200;
        int t = 9;
        for (int i = start; i <= end;i++){
            if(i % t == 0){
                System.out.println(i);
                count++;
                sum = sum + i;
            }
        }
        System.out.println(count);
        System.out.println(sum);
    }
}

package cn.javageiyegun.demo04;

import java.util.Scanner;

public class MulForExercise01 {
    public static void main(String[] args) {
        //1.统计3个班级成绩情况,每个班有5名同学
        //求出各个班的平均分或所有班级的平均分[学生的成绩从键盘输入]
        //统计三个班及格人数,每个班有5名同学.

        //思路分析
        //1)先计算一个班级,5个同学的成绩,使用for
        //1.1创建Scanner对象然后,接收用户的输入
        //1.2 得到该班级的平均分,定义一个double sum 把该班级5个同学的成绩累计

        //2)得到每个班级的平均分
        //3)所有班级的平均分
        //3.1定义一个变量,double score 累积所有学生的成绩
        //3.2当多重循环结束后,score/15
        //4)统计三个班级的及格人数
        //4.1定义变量 int count = 0;当有同学>=60则count++;
        Scanner myscanner = new Scanner(System.in);
        double grade;
        double score = 0;
        int count = 0;
        for (int i = 1;i <= 3; i++){  //班级
            double sum = 0;
            for (int j = 1; j <= 5; j++){  //该班级的同学
                System.out.println("第" + i + "个班级的第" + j + "个同学的成绩:" );
                grade = myscanner.nextDouble();
                if(grade >= 60){
                    count++;
                }
                System.out.println("成绩为:" + grade);
                sum = sum + grade;
            }
            score = score + sum;
            System.out.println("第" + i + "个班级的平均分: " + sum/5);
        }
        System.out.println("所有班级的平均分:" + score/15);
        System.out.println("三个班级及格人数:" + count);


    }
}

package cn.javageiyegun.demo04;

public class MulForExercise02 {
    public static void main(String[] args) {
        //九九乘法表
        for (int i = 1;i <= 9;i++){  //控制行
            for (int j = 1;j <= i;j++){
                System.out.print(i + "*" + j + "=" + (i * j));
                System.out.print("  ");
            }
            System.out.print('\n');
        }
    }
}

package cn.javageiyegun.demo04;

public class MulForExercise03 {
    public static void main(String[] args) {
        /*
            使用for循环
        打印:

                 *
                * *
               *   *
              *     *
             *********

            化繁为简:
            1)打印:
            *****
            *****
            *****
            *****
            *****
            2)打印半个金字塔
            *       //第1层有1个*
            **      //第2层有2个*
            ***     //第3层有3个*
            ****    //第4层有4个*
            *****   //第5层有5个*
            3)打印整个金字塔  2n-1
            *     //第1层有1个*     有4个空格 = 总层数 - 第i层;
           ***    //第2层有3个*     有3个
          *****   //第3层有5个*     有2个
         *******  //第4层有7个*     有1个
        ********* //第5层有9个*     有0个
            4)打印空心的金字塔[!!!!!!!]
            *     //第1层有1个*    当前行的第一个位置是*,最后一个位置也是*
           ***    //第2层有3个*
          *****   //第3层有5个*
         *******  //第4层有7个*
        ********* //第5层有9个*

        先死后活

        int totalLevel = 5  //定义层数
         */
        int totalLevel = 10;
        for (int i = 1;i <= totalLevel;i++){   //i表示层数
            for(int k = 1;k <= totalLevel - i;k++){
                System.out.print(" ");
            }
            //控制打印每层的*
            for (int j = 1;j <= 2 * i -1;j++){
                if (j == 1 || j == 2 * i -1 || i == totalLevel){
                    System.out.print("*");
                } else {
                    System.out.print(" ");
                }

            }
            System.out.println();
        }
    }
}

while循环控制
基本语法
循环变量初始化
while(循环条件){
    循环体(语句);
    循环变量迭代;
}
说明
 1)while也有四要素;
 2)只是四要素放的位置和for不一样;

package cn.javageiyegun.demo04;

public class While {
    public static void main(String[] args) {
        int i = 0; //变量初始化
        while(i <= 10){  //循环条件
            System.out.println(i);//执行语句
            i++;  //循环变量迭代
        }
    }
}

细节
1.循环条件是返回一个布尔值的表达式
2.while循环时先判断再执行语句

while循环练习

package cn.javageiyegun.demo04;

public class WhileExercise {
    public static void main(String[] args) {
        //打印1-100之间能被3整除的数[使用while]
        int i = 1;
        while(i<=100){
            if (i % 3 == 0){
                System.out.println(i);
            }
            i++;
        }
        System.out.println("==============");
        //打印40-200之间所有的偶数[使用while]
        int x = 40;
        while(x <= 200){
            if(x % 2 == 0){
                System.out.println(x);
            }
            x++;
        }
    }
}

do-while循环
基本语法
循环变量初始化;
do{
  循环体;
  循环变量迭代;
 }while(循环条件);
说明:
1.do while是关键字
2.也有循环四要素,只是位置不一样
3.先执行,再判断,也就是说,一定会执行一次

package cn.javageiyegun.demo04;

public class Do_While {
    public static void main(String[] args) {
        int i = 1;
        do{
            System.out.println(i);
            i++;
        }while(i<=10);
    }
}

细节
1.循环条件是返回一个布尔值的表达式
2.do-while循环是先执行,再判断,因此它至少执行一次

do-while练习

package cn.javageiyegun.demo04;

import java.util.Scanner;

public class Do_WhileExercise {
    public static void main(String[] args) {
        //1.打印1-100
        int y = 1;
        do {
            System.out.println(y);
            y++;
        }while(y <= 100);

        //2.计算1-100的和
        int sum = 0;
        int i = 1;
        do {
            sum = sum + i;
            i++;
        }while (i <= 100);
        System.out.println(sum);

        //3.统计1-200之间能被5整除但不能被3整除的个数
        int x = 1;
        int count = 0;
        do {
            if (x % 5 == 0 && x % 3 != 0){
                count++;
            }
            x++;
        }while (x <= 200);
        System.out.println(count);

        //4.如果李三不还钱,则老韩将一直使出五连鞭,直到李三说还钱为止
        Scanner myScanner = new Scanner(System.in);
        char c;
        do {
            System.out.println("五连鞭");
            System.out.println("还不还钱! y/n");
             c = myScanner.next().charAt(0);
//            if (c == 'y'){
//                System.out.println("ok");
//                break;
//            } else if (c == 'n'){
//                System.out.println("五连鞭");
//            } else {
//                System.out.println("输入错误");
//                break;
//            }

        }while(c != 'y');
        System.out.println("终于还钱了");
    }
}

多重循环控制!!!
1.将一个循环放在另一个循环体内,就形成了嵌套循环.其中,for,while,do-while均可以作为外层循环和内层循环.[最好不超过3层,否则可读性差]
2.实质上,嵌套循环就是把内层循环当成外层循环的循环体.当只有内层循环的循环条件为false时,才会完全跳出内层循环,才可结束外层的当次循环,开始下一次的循环
3.设外层循环次数为m次,内层循环次数为n次,则内层循环体实际上需要执行m*n次.



break-跳转控制语句
break语句用于终止某个语句块的执行,一般使用再switch或者循环[for,while,do-while]中
基本语法:
{
        ....
        break;
        ....
}
BreakDetail
1.break语句出现在多层嵌套的语句块中时,可以通过标签指明要终止的是哪一层语句块
2.标签的基本使用
label1:{
label2:{
label3:{    ...
            break label2;
            ...
        }
    }
}
(1)break语句可以指定退出哪层
(2)label是标签,名字由程序员指定
(3)break 后指定到哪个label就退出到哪里
(4)在实际的开发中,尽量不要使用标签
(5)如果没有指定的break,默认退出最近的循环体

package cn.javageiyegun.demo04;

public class BreakDetail {
    public static void main(String[] args) {
        label1:
        for (int j = 0;j < 4;j++){
            label2:
            for (int i = 0;i < 10;i++){
                if(i == 2){
                    //break;  //break后面没有指定标签 等价于 break label2[就近原则]
                    break label1; //退出最外层的循环[label1]
                }
                System.out.println("i = " + i);
            }
        }
    }
}

break练习

package cn.javageiyegun.demo04;

public class BreakExercise01 {
    public static void main(String[] args) {
        //1.
        //1-100以内的数求和,求出 当和 第一次大于20的当前数[for + break]

        //思路分析
        //1.循环1-100,求出 sum
        //2.当sum > 20 时 ,记录下当前数,然后break;
        //3.在for循环外部,定义变量你,把当前i赋给n
        int sum = 0;
        int n = 0;
        for (int i = 1; i < 100; i++) {
            sum = sum + i;
            //当sum > 20 时 ,记录下当前数,然后break;
            if(sum > 20){
                System.out.println(i);
                n = i;
                break;
            }
        }
        //System.out.println(i);    //会报错,因为要考虑i的作用域[i只在for循环里面有效]
        System.out.println(n);
    }
}

package cn.javageiyegun.demo04;

import java.util.Scanner;

public class BreakExercise02 {
    public static void main(String[] args) {
        //2.实现登录验证,有三次机会,如果用户名为"丁真",密码"666"提示登录成功,
        //否则提示还有几次机会,请使用for+break完成

        //思路分析
        //1.创建Scanner对象来接受用户输入
        //2.定义String name ; String passwd;保存用户名和密码
        //3.最大循环3次[登录3次],如果满足条件就退出
        //4.定义一般变量 int chance 记录还有几次机会

        //实现

        Scanner myscanner = new Scanner(System.in);
        String name = "";
        String passwd = "";
        int chance = 3;   //登录机会
        for (int i = 1;i <= 3;i++){
            System.out.println("输入用户名:");
            name = myscanner.next();
            System.out.println("输入密码:");
            passwd = myscanner.next();

            //比较输入的用户名和密码
            //[补充说明字符串 的内容 比较 使用的方法 equals -->返回boolean类型]
            //name和"丁真"可以互换位置-->name.equals("丁真")
            if ("丁真".equals(name) && "123".equals(passwd)){  //[建议使用,可以避免空指针]
                System.out.println("登录成功");
                break;
            }
            chance--;
            System.out.println("还有" + chance + "机会");
        }

    }
}

continue-跳转控制语句
基本介绍:
1)continue语句用于结束本次循环,继续执行下一次循环
2)continue语句出现在多层嵌套语句体中时,可以通过标签指明要跳过的是哪一层循环,这个和前面的标签的使用的规则一样.
基本语法:
{
     ...
     continue;
     ...
}

package cn.javageiyegun.demo04;

public class ContinueDetail {
    public static void main(String[] args) {
        label1:
        for (int j = 0; j < 4;j++){
            label2:
            for (int i = 0;i < 10;i++){
                if(i == 2){
                    //continue;    //等价于 continue label2; [输出4次(0,1,3,4,5,6,7,8,9)]
                    continue label1;  //[输出2次(0,1,3,4,5,6,7,8,9)]
                }
                System.out.println(i);
            }
        }
    }
}

return-跳转控制语句
介绍
retur使用在方法,表示跳出的方法,在讲解的时候,会详细的介绍,这里我们简单的提一下.注意 return 写在 main方法,退出程序..!!!!

package cn.javageiyegun.demo04;

public class Return01 {
    public static void main(String[] args) {
        for (int i = 1;i <= 5;i++){
            if (i == 3){
                System.out.println("韩老师" + i);
                //break;  //韩老师3
                //continue;  //韩老师3
                //return;  //韩老师3
            }
            //(1)先输出两句hello world,遇到break;-->不执行
            //(2)为continue;-->先输出两句hello world,遇到continue,结束本次循环,进入下一次循环,再输出两句hello world
            //(3)先输出两句hello world 遇到return结束程序[当return用在方法时,表示跳出方法,如果使用在main,表示结束程序!!!!]
            System.out.println("hello world!");
        }
        System.out.println("go on ...");  //为break;-->执行   为continue;-->执行   为return;-->不执行
    }
}