Chapter05 流程控制（Process Control）

目录

• Chapter05 流程控制
  • 5.1 顺序控制
  • 5.2 分支控制 if-else
    • 单分支基本语法：
    • 双分支基础语法:
    • 多分支基础语法
  • 5.3 嵌套分支
  • 5.4 switch分支结构
  • 5.5 For循环控制
  • 5.6 while循环控制
  • 5.7 do……while循环控制
  • 5.8 多重循环控制
  • 5.9跳转控制语句
    • 5.9.1 break - 跳转控制语句
    • 5.9.2 continue - 跳转控制语句
    • 5.9.3 return - 跳转控制语句
  • 5.10 练习

Chapter05 流程控制

目录

5.1 顺序控制

• 程序从上到下逐行地执行，中间没有任何判断和跳转。

5.2 分支控制 if-else

• 让程序有选择的执行，分支控制有三种

  • 单分支
  • 双分支
  • 多分支

单分支基本语法：

if（条件表达式）{
    执行代码块;(可以有多条语句)
}
说明:当条件表达式为ture时，就会执行{}的代码。如果为false,就不执行.特别说明，如果中只有一条语句，则可以不用0,韩老师建议写上。

练习：编写一个程序,可以输入人的年龄,如果该同志的年龄大于18岁,则输出"你年龄大于18,要对自己的行为负责,送入监狱"

import java.util.Scanner;

public class If01 {
    public static void main(String[] args) {
        //定义一个Scanner对象
        Scanner myScanner = new Scanner(System.in);
        System.out.println("请输入年龄");
        //把年龄保存到一个变量中
        int age = myScanner.nextInt();
        //if判断
        if (age >= 18 ){
            System.out.println("你的年龄大于18，要对自己的行为负责，送入监狱");
        }
    }
}

双分支基础语法:

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

练习：编写一个程序,可以输入人的年龄,如果该同志的年龄大于 18 岁, 则输出 "你年龄大于 18,要对自己的行为负责, 送入监狱"。否则 ,输出"你的年龄不大这次放过你了.

import java.util.Scanner;

public class If02 {
    public static void main(String[] args) {
        Scanner myScanner = new Scanner(System.in);
        System.out.println("输入你的年龄");
        int age = myScanner.nextInt();
        if (age >= 18){
            System.out.println("你的年龄大于18，要对自己的行为负责，送入监狱");
        }else {
            System.out.println("你的年龄小于18，放你一马");
        }
    }
}

多分支基础语法

if(条件表达式1){
    执行代码块1；
}else if(条件表达式2){
    执行代码块2；
}else if(条件表达式3){
    执行代码块3；
        …………
}else{
    执行代码块n；
}
特别说明:(1)多分支可以没有else,如果所有的条件表达式都不成立，则一个执行入口都没有(2)如果有else ,如果所有的条件表达式都不成立，则默认执行else代码块

import java.util.Scanner;

public class If03 {
    public static void main(String[] args) {
//        输入保国同志的芝麻信用分：
//        如果：
//        1) 信用分为 100 分时，输出 信用极好；
//        2) 信用分为(80，99]时，输出 信用优秀
//        信用分为[60,80]时，输出 信用一般；
//        4) 其它情况 ，输出 信用 不及格
//        5) 请从键盘输入保国的芝麻信用分，并加以判断

        Scanner myScanner = new Scanner(System.in);
        //接收用户输入
        System.out.println("请输入1-100的信用积分");
        int grade = myScanner.nextInt();

        if (grade >= 1 && grade <= 100) {
            //因为有4种情况
            if (grade == 100) {
                System.out.println("信用极好");
            } else if (grade > 80 && grade <= 99) {
                System.out.println("信用优秀");
            } else if (grade >= 60 && grade <= 80) {
                System.out.println("信用一般");
            } else {
                System.out.println("信用不及格");
            }
        } else {
            System.out.println("信用分在1-100之间，请重新输入");
        }
    }
}

5.3 嵌套分支

• 基本介绍：在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层分支外面的分支结构称为外层分支。老师建议: 不要超过3层

import java.util.Scanner;

public class NestedIf {
    public static void main(String[] args) {
        //参加歌手比赛，如果初赛成绩大于 8.0 进入决赛，否则提示淘汰。并且根据性别提示进入男子组或女子组。
        //输入成绩和性别，进行判断和输出信息。

        //接受用户输入
        Scanner myScanner = new Scanner(System.in);
        System.out.println("请输入该歌手的成绩");
        //定义成绩变量
        double score = myScanner.nextDouble();
        if( score > 8.0){ //进行成绩的判断
            System.out.println("请输入性别");
            char gender = myScanner.next().charAt(0);
            if ( gender == '男'){ //进行性别的判断
                System.out.println("恭喜你，进入男子组");
            }else if( gender == '女'){
                System.out.println("恭喜你，进入女子组");
            }else{
                System.out.println("输入错误，请重新输入");
            }
        }else{
            System.out.println("sorry,你被淘汰了");
        }
    }
}

5.4 switch分支结构

基础语法：

switch(表达式){
        case 常量1： //当……
            语句块1；
            break；
            case 常量2： //当……
            语句块2；
            break；
            case 常量3： //当……
            语句块3；
            break；
            …………
            case 常量n： //当……
            语句块n；
            break；
            default:
        default语句块；
            break；

解读：
1.switch关键字，表示swtich分支
2.表达式对应一个值
3.case常量1:当表达式的值等于常量1，就执行语句块1
4. break :表示退出swtich
5.如果和case常量1匹配，就执行语句块1，如果没有匹配，就继续匹配case常量2
6.如果一个都没有匹配上，执行default

import sun.security.rsa.RSAUtil;

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);

        //在java中，只要有值返回，就是一个表达式
        switch(c1){
            case 'a':
                System.out.println("今天星期一，猴子穿新衣");
                break;
            case 'b':
                System.out.println("今天星期二，猴子当小二");
                break;
            case 'c':
                System.out.println("今天星期三，猴子爬雪山");
                break;
            default:
                System.out.println("你输入的字符不正确，请重新输入");
        }
        System.out.println("退出switch，继续执行程序");

    }
}

• switch注意事项和细节讨论

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'://这里的String类型不能转成char类型，编译不能通过
//                System.out.println("ok2");
//                break;
            case 20://常量，这里的int类型可以转换成char类型，所以编译通过
                System.out.println("ok4");
                break;
            default:
                System.out.println("ok3");

//          2.switch(表达式)中表达式的返回值必须是:(byte,short,int, char,enum[枚举],String)
//                 double c = 1.1; //不兼容类型
//                 switch(c){
//                     case  1.1:
//                         System.out.println("ok1");
//                         break
//
//          3.case子句中的值必须是常量（1，'a'）或者是常量表达式,而不是变量
                char c = 'a';
                char c2 = 'c';
                switch (c){
                    case 'a':
                        System.out.println("ok1");
                        break;
//                    case 'c2': //只能是常量，不能是变量
//                        System.out.println("ok2");
//                        break;
                }

        }
        //4.穿透，没有写break，程序会顺序执行到switch结尾
        //break用来跳出switch语句块
        }
    }

练习：
import java.util.Scanner;

public class SwitchExercise {
    public static void main(String[] args) {
//       1. 使用 switch 把小写类型的 char 型转为大写(键盘输入)。只转换 a, b, c, d, e. 其它的输出 "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;
            case 'd':
                System.out.println("D");
                break;
            case 'e':
                System.out.println("E");
                break;
            default:
                System.out.println("你输入错误");
        }

//        2.对学生成绩大于 60 分的，输出"合格"。
//        低于 60 分的，输出"不合格"。(注：输入的成绩不能大于 100), 提示 成绩/60
        double score = 88.6;
        if( score >= 0 && score <= 100) {
            switch ((int) (score / 60)) {
                case 0:
                    System.out.println("不合格");
                    break;
                case 1:
                    System.out.println("合格");
                    break;
            }
        }else{
            System.out.println("请输入0-100的分数");
        }
//        3. 根据用于指定月份，打印该月份所属的季节。3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12, 1, 2 冬季 [课堂练习, 提示 使
//        用穿透 ]
        /*
        思路分析；
        1.创建Scanner对象
        2.使用int month 接受
        3.使用switch来匹配，使用穿透完成，比较简洁
         */
        Scanner myScanner1 = new Scanner(System.in);
        System.out.println("输入月份");
        int month = myScanner1.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("输入有误，重新输入（1-12）");
        }
    }
}

5.5 For循环控制

• 基础语法

for（循环变量初始化;循环条件；循环变量迭代）{
    循环操作（可以多条语句）；
}

1. for 关键字，表示循环控制
2. for 有四要素: (1)循环变量初始化(2)循环条件(3)循环操作(4)循环变量迭代
3. 循环操作 , 这里可以有多条语句，也就是我们要循环执行的代码
4. 如果 循环操作(语句) 只有一条语句，可以省略 {}, 建议不要省略

• 注意事项和细节说明

public class ForDetail {
    public static void main(String[] args) {
//        循环条件是返回一个布尔值的表达式
//        2) for(;循环判断条件;) 中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略。
//        3) 循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代
//        语句，中间用逗号隔开。
//        4) 使用内存分析法，老师分析输出下面代码输出什么?
        int count = 3;
        for( int i = 0, j = 0; i < count; i++,j += 2){
            System.out.println("i=" + i + "j=" + j);
            /*
            i=0j=0
            i=1j=2
            i=2j=4
             */
        }
    }
}

练习：
public class ForExercise {
    public static void main(String[] args) {
//        打印 1~100 之间所有是 9 的倍数的整数，统计个数 及 总和.[化繁为简,先死后活
        //化繁为简
//        （1）完成输出 1 - 100 的值
//        （2）输出9的倍数的整数
//        （3）统计个数
//        （4）总和
//        int count = 0; //统计个数
//        int sum = 0; //总和
//         for(int i = 0; i <= 100; i++){
//             if( i % 9 == 0) {
//                 System.out.println("i=" + i);
//                 count++;
//                 sum +=i;
//             }
//         }
//        System.out.println("count=" + count);//12
//        System.out.println("sum=" + sum);//594

        //先死后活
        //为了适应更好的需求，把范围的开始的值和结束的值，
        // 做成变量，把倍数的值，也可以换成变量

        int count2 = 0; //统计个数
        int sum2 = 0; //总和
        int start = 1;
        int end = 100;
        int t =9;
        for(int i2 = start; i2 <= end; i2++){
            if( i2 % t == 0) {
                System.out.println("i2=" + i2);
                count2++;
                sum2 +=i2;
            }
        }
        System.out.println("count2=" + count2);//12
        System.out.println("sum2=" + sum2);//594

        //化繁为简
        //先输出0 - 5
        //后面的+ 是 5 - i

        //先死后活
        //5 替换变量 n
        int n = 5;
        for(int i = 0; i <= n; i++){
            System.out.println(i + "+" + (n - i) + "=" + n);
        }
    }
}

5.6 while循环控制

• 基本语法

while（循环条件）{

    循环体（语句）；
        循环变量迭代；
}

public class WhileExercise {
    public static void main(String[] args) {
//        1) 打印 1—100 之间所有能被 3 整除的数 [使用 while, 老师评讲 ]
//
//
//        int i = 1;
//        int count = 0;
//        while (i <= 100){
//            if (i % 3 == 0) {
//                System.out.println("i=" + i);
//                count++;
//            }
//            i++;
//        }
//        System.out.println(count);

//        2) 打印 40—200 之间所有的偶数 [使用 while,
        int i = 40;
        int start = 40;
        int end = 200;
        while(i >= start && i <= end ){
            if(i % 2 ==0){
                System.out.println("i=" + i);
            }
            i++;
        }

    }
}

5.7 do……while循环控制

• 基本语法

循环变量初始化；
    do{
        循环体（语句）；
        循环变量迭代；
    }while（循环条件）；

1. do while 是关键字
2. 也有循环四要素, 只是位置不一样
3. 先执行，再判断，也就是说，一定会至少执行一次
4. 最后 有一个分号 ;
5. while 和 do..while 区别举例: 要账

public class DoWhile {
    public static void main(String[] args) {
        int i = 1;//循环变量初始化
        do {
            System.out.println("hello world");//循环执行语句
            i++;//循环变量迭代15-
        }while (i <= 10);
    }
}

public class DoWhileExercise01 {
    public static void main(String[] args) {
        int i = 1;//打印1 - 100
        int sum = 0;//总和
        int count = 0;//个数
        do {
            if (i % 5 == 0 && i % 3 != 0) {
                System.out.println(i);
                count++;
            }
            i++;
            sum +=i;
        }while (i <= 200);
        System.out.println(sum);
        System.out.println(count);
    }
}

import java.util.Scanner;

public class DoWhileExercise02 {
    public static void main(String[] args) {
//如果李三不还钱，则老韩将一直使出五连鞭，直到李三说还钱为
//[System.out.println("老韩问：还钱吗？y/n")] do...while ..
//化繁为简
//(1) 不停的问还钱吗?
//(2) 使用 char answer 接收回答, 定义一个 Scanner 对象
//(3) 在 do-while 的 while 判断如果是 y 就不在循
        Scanner myScanner = new Scanner(System.in);
        char answer = ' ';
        do {
            System.out.println("老韩使出了五连鞭");
            System.out.println("问：还钱吗 y/n");
            answer = myScanner.next().charAt(0);
            System.out.println("他的回答是" + answer);
        }while (answer != 'y');
        System.out.println("老韩停止了五连鞭的抽打");
    }
}

5.8 多重循环控制

public class MulFor {
    public static void main(String[] args) {
        for( int i =0; i < 2; i++){
            for( int j = 0 ; j < 3; j++){
                System.out.println("i=" + i + "j=" + j);
                /*结果：
                i=0j=0
                i=0j=1
                i=0j=2
                i=1j=0
                i=1j=1
                i=1j=2
                 */
            }
        }
    }
}

import java.util.Scanner;

public class MulFoExercise01 {
    public static void main(String[] args) {
//        统计 3 个班成绩情况，每个班有 5 名同学，求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。
//        2) 统计三个班及格人数，每个班有 5 名同学
        //化繁为简
//(1) 先计算一个班 , 5 个学生的成绩和平均分 , 使用 for
//1.1 创建 Scanner 对象然后，接收用户输入
//1.2 得到该班级的平均分 , 定义一个 double sum 把该班级 5 个学生的成绩累积
//(2) 统计 3 个班(每个班 5 个学生) 平均分
//(3) 所有班级的平均分
//3.1 定义一个变量，double sum2 累积所有学生的成绩
//3.2 当多重循环结束后，sum2
//(4) 统计三个班及格人数
//4.1 定义变量 int passNum = 0; 当有一个学生成绩>=60, passNum++
//4.2 如果 >= 60 passNum++
//(5) 可以优化[效率，可读性, 结构]

        Scanner myScanner = new Scanner(System.in);
        double sum2 = 0;//定义的是所有学生的分数
        int passNum = 0;//定义通过考试的人数
        for(int class1 = 1; class1 <= 3; class1++){ //班级循环
            double sum = 0; //定义每个班学生的成绩
            for (int student1 = 1; student1 <= 5; student1++){ //学生循环
                System.out.println("请输入第"+ class1 + "班的第" + student1 + "个学生的成绩");
                double score = myScanner.nextDouble();
                if(score >= 60){ //判断及格人数
                    passNum++;
                }
                sum += score;
                System.out.println("成绩是=" + score);

            }

            System.out.println("第" + class1 + "班的平均成绩=" + (sum / 5));
            sum2 += sum;
            System.out.println("及格的人数是=" + passNum);
        }
        System.out.println("所有班级的平均成绩=" + (sum2 / 3));//所有班级的平均分
    }
}

public class MulForExercise02 {
    public static void main(String[] args) {
        int sum = 0;
        for ( int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                sum = i * j;
                System.out.print(i + "*" + j + "=" + sum + "\t");
            }
            System.out.println();
        }
    }
}

public class Stars {
    //编写一个 main 方法
    public static void main(String[] args) {
/*
   *
  *  *
 *    *
********
思路分析
化繁为简
1. 先打印一个矩形
*****
*****
*****
*****
*****
2. 打印半个金字塔
* //第 1 层 有 1 个*
** //第 2 层 有 2 个*
*** //第 3 层 有 3 个*
**** //第 4 层 有 4 个*
***** //第 5 层 有 5 个*
3. 打印整个金字塔
    * //第 1 层 有 1 个* 2 * 1 -1 有 4=(总层数-1)个空格
   *** //第 2 层 有 3 个* 2 * 2 -1 有 3=(总层数-2)个空格
  ***** //第 3 层 有 5 个* 2 * 3 -1 有 2=(总层数-3)个空格
 ******* //第 4 层 有 7 个* 2 * 4 -1 有 1=(总层数-4)个空格
********* //第 5 层 有 9 个* 2 * 5 -1 有 0=(总层数-5)个空格
4. 打印空心的金字塔 [最难的]
   * //第 1 层 有 1 个* 当前行的第一个位置是*,最后一个位置也是*
  *  * //第 2 层 有 2 个* 当前行的第一个位置是*,最后一个位置也是*
 *    * //第 3 层 有 2 个* 当前行的第一个位置是*,最后一个位置也是*
*       * //第 4 层 有 2 个* 当前行的第一个位置是*,最后一个位置也是*
********* //第 5 层 有 9 个* 全部输出*
先死后活
5 层数做成变量 int totalLevel = 5;
//小伙伴 技术到位，就可以很快的把代码写出
*/
        int totalLevel = 20; //层数
        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(" ");
                }
            }
//每打印完一层的*后，就换行 println 本身会换行
            System.out.println("");
        }
    }
}

5.9跳转控制语句

5.9.1 break - 跳转控制语句

• 基本介绍：break 语句用于终止某个语句块的执行，一般使用在 switch 或者循环[for , while

基本语法
{ ……
break; ……
}

public class Break01 {
    public static void main(String[] args) {
        for ( int i =1; i <= 10; i++){
            if ( i == 3){
                break;
            }
            System.out.println("i=" + i);
        }
        System.out.println("退出for循环，继续执行其他的");
    }
}

import java.util.Scanner;

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

        // 思路分析
// 1. 创建 Scanner 对象接收用户输入
// 2. 定义 String name ; String passwd; 保存用户名和密码
// 3. 最多循环 3 次[登录 3 次]，如果 满足条件就提前退出
// 4. 定义一般变量 int chance 记录还有几次登录机
        int change = 3;
        Scanner myScanner = new Scanner(System.in);
        for (int i = 1; i <= change; i++){
            System.out.println("一共有三次机会");
            System.out.println("请输入你的用户名");
            String name = myScanner.next();
            System.out.println("请输入你的密码");
            String passWord = myScanner.next();
            //判断是否正确
            //补充说明，字符串内容的比较，使用方法equals
            if (name.equals("丁真") && passWord.equals("666")){
                System.out.println("登录成功");
                break;
            }else{
                System.out.println("登录失败" + "还有" + (change - i) + "次机会");
            }
        }
    }
}

5.9.2 continue - 跳转控制语句

• 基本介绍
  • continue 语句用于结束本次循环，继续执行下一次循环。
  • continue 语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环 , 这个和前面的标签的 使用的规则一样

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;
                    continue label1;//直接跳到外层的for循环
                }
                System.out.println("i = " + i);
            }
        }
    }
}

5.9.3 return - 跳转控制语句

• 基本语法：直接结束方法，使用在主方法中，直接结束程序

public class Return01 {
    public static void main(String[] args) {
        for( int i = 1; i <= 5; i++){
            if(i == 3){
                System.out.println("hello world" + i);
                break;
            }
            System.out.println("嘿嘿");
        }
        System.out.println("go on...");
    }
}
//结果：
嘿嘿
嘿嘿
hello world3
go on...

public class Return01 {
    public static void main(String[] args) {
        for( int i = 1; i <= 5; i++){
            if(i == 3){
                System.out.println("hello world" + i);
                continue;
            }
            System.out.println("嘿嘿");
        }
        System.out.println("go on...");
    }
}
//结果：
嘿嘿
嘿嘿
hello world3
嘿嘿
嘿嘿
go on...

public class Return01 {
    public static void main(String[] args) {
        for( int i = 1; i <= 5; i++){
            if(i == 3){
                System.out.println("hello world" + i);
                return;
            }
            System.out.println("嘿嘿");
        }
        System.out.println("go on...");
    }
}
//结果： 直接结束方法，使用在主方法中，直接结束程序
嘿嘿
嘿嘿
hello world3

5.10 练习

public class HomeWork01 {
    public static void main(String[] args) {
//        某人有100,000元,每经过一次路口，需要交费,规则如下:
//        1)当现金>50000时,每次交5%
//        2)当现金<=50000时,每次交1000
//        编程计算该人可以经过多少次路口,要求:使用while + break方式完成

        //思路分析
        /*
        1.定义一个变量 double total = 100000;
        2.根据题目要求。分析三种情况
        total > 50000;
        total >= 1000;
        total < 1000;
        3.使用多分支 if-else if

         */
        int total = 100000;//总数
        int i = 0;//记录个数
        while (true){//无线循环
            if(total > 50000){ //判断大于50000的路过路口的次数
                total *= 0.95; //剩余的钱
                i++;   //记录个数
            }else if (total >=1000){
                total = total -1000;
                i++;
            }else if (total != 1000){
                break;
            }
        }
        System.out.println("还剩多少钱" + total + "经过" + i + "次路口");
    }
}

==========================================================================
import java.util.Scanner;

public class HomeWork02 {
    public static void main(String[] args) {
        Scanner myScanner = new Scanner(System.in);
        System.out.println("请输入整数");
        int integer = myScanner.nextInt();
        if( integer > 0){
            System.out.println("这是一个大于0的数");
        }else if( integer < 0){
            System.out.println("这是一个小于0的数");
        }else{
            System.out.println("这是一个等于0的数");
        }
    }
}

==========================================================================
import java.util.Scanner;

public class HomeWork03 {
    public static void main(String[] args) {
        /*
        判断一个整数是否是水仙花数，所谓水仙花数是指一个3位数，
        其各个位上数字立方和等于其本身。例如:153 = 1*1*1 +3*3*3+5*5*5

        思路分析：见多识广
        1.先得到integer的百位，十位，个位的数字，使用if 判断他们的立方和是否相等
        2.百位：n1 = integer / 100;
        3.十位：n2 = integer % 100 /10;
        4.个位：n3 = integer % 10;
        5.进行判断
         */
        Scanner myScanner = new Scanner(System.in);
        System.out.println("请输入你的整数");
        int integer = myScanner.nextInt();
        int n1 = integer / 100;
        int n2 = integer % 100 / 10;
        int n3 = integer % 10;
        if (n1 * n1 * n1 + n2 * n2 * n2 + n3 * n3 * n3 == integer){
            System.out.println("这个数是水仙花数");
        }else{
            System.out.println("这个数不是水仙花数");
        }
    }
}

==========================================================================
    public class HomeWork04 {
    public static void main(String[] args) {
        /*
        1.先输出1 - 100的所有数
        2.然后过滤输出，不能被5整除的数 i%5！=0
        3.每5个一行，我们使用 int n 统计个数，当 n%5==0 就说明输出了5个，这时，我们输出一个换行即可
         */
        int n = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 5 != 0) {
                n++;
                System.out.print(i + "\t");
                if (n % 5 == 0) {
                    System.out.println("");
            }
            }
        }
    }
}

==========================================================================
    public class HomeWork05 {
    public static void main(String[] args) {

        //输出小写的a-z以及大写的Z-A
        // 考察我们对a-z编码和for的综合使用//思路分析
        // 1.'b' = 'a' + 1 c = 'a' + 2//2．使用for搞定

        int count = 0;
        for ( char i = 'a'; i <= 'z'; i++){
            count++;
            System.out.print( i + "\t");
        }
        System.out.println(count);
        for (char i2 = 'Z'; i2 >= 'A';i2--){
            System.out.print(i2 + "\t");
        }
    }
}

==========================================================================
    public class HomeWork06 {
    public static void main(String[] args) {

        /*
        求出1-1/2+1/3-1/4.....1/100的和

        (1)一共有100数,，分子为1,分母从1-100
        (2）还发现当分母为奇数时，前面是+，当分母是偶数时，前面是-。
        3.我们可以使用for +判断即可完成
        4，把结果存放到double sum
        5．这里有一个隐藏的陷阱，要把公式分子1写出1.0才能得到精确的小数
         */
        double sum = 0;
        for ( int i = 1; i <= 100; i++ ){
            if( i % 2 != 0){
                sum += (1.0 / i);
            }else if (i % 2 == 0){
                sum -= (1.0 / i);
            }
        }
        System.out.println(sum);
    }
}

==========================================================================
    public class HomeWork07 {
    public static void main(String[] args) {
        /*
        //求(1)+(1+2) +(1+2$)+(1+2+3+4) +...+(1+2+3+..+100)的结果

        //思路分析
        //1。一共有100项相加
        //2。每一项的数字在逐渐增加
        //3．很像一个双层循环
        //i可以表示是第几项,同时也是当前项的最后一个数
        //4。使用sum进行累计即可

         */
        int sum = 0;
        for (int i = 1; i <= 100; i++){
            for ( int j = 1; j <= i; j++){//内层对i的循环
                sum += j;
            }
        }
        System.out.println(sum);
    }
}