java系统化基础-day02-运算符、选择结构、循环结构

1.java中的运算符

package com.wfd360.day02;


import org.junit.Test;

import java.math.BigInteger;

/**
 * 1.算术运算符[掌握]
 * <p>
 * 2.自增自减[掌握]
 * <p>
 * 3.赋值运算[掌握]
 * <p>
 * 4.比较运算符[掌握]
 * <p>
 * 5.逻辑运算符[掌握]
 * <p>
 * 6.位运算符[了解]
 * <p>
 * 7.三目运算符[掌握]
 */

public class Demo01 {
    /**
     * 1.算术运算符[掌握]
     * 1)加法（+） 加法   正号  字符串拼接
     * 2)减法（-） 减法 负号
     * 3)乘法 （*） 乘法
     * 4)除法(/) 除法
     * 整数（小数）相除的例子
     * 10/3 =3；  10.0/3=3.33333…
     * 0/0
     * 0.0/0.0
     * 结果是NaN ,任何的NaN都不等于自己（面试题）
     * 1.0/0.0
     * Infinity,表示无穷大
     */
    @Test
    public void test() {
        int i1 = 3 + 2 - 5 * 6;
        int i2 = 10 / 3;  // 3
        // 3.0 代表整数相除，将运算结果，转变为double
        double d1 = 10 / 3;
        System.out.println("d1=" + d1);
        //double d2 = 10 / 3.0; // 3.3333333333333335
        double d2 = 10.0 / 3; // 3.3333333333333335
        System.out.println("d2=" + d2);
        // 0/0  报错  java.lang.ArithmeticException: / by zero
        //int i3=0/0;
        // System.out.println("i3="+i3);
        //  结果是NaN ,任何的NaN都不等于自己（面试题）
        double d3 = 0.0 / 0;
        System.out.println(" d3=" + d3);
        double d4 = 1.0 / 0; // Infinity,表示无穷大
        System.out.println(" d4=" + d4);
    }

    /**
     * 取模(%) ， 取余数
     * 案例：假设大学的一个寝室可以住6个人，那么计算1024个大学生一共需要多少个寝室？ （本质就是生产中经常用到的分页算法）
     */
    @Test
    public void test2() {
        int n = 6;
        int m = 1024;
        //取余数
        int y = m % n;
        System.out.println("y=" + y);
        //=====================
        //如果余数为零那么，一共需要的寝室数=m/n;
        //如果余数 不 为零那么，一共需要的寝室数=（m/n）+1;
    }

    /**
     * 2. 自增自减[掌握]
     * ++（自增）     --（自减）
     * 自增自减只能够用于 变量，不能用于常量
     * 自增自减运算的优先级  比  算术运算符  高
     */
    @Test
    public void test3() {
        //===========基本使用==================
        int i = 3;  // 表示把3赋值给变量i
        i++;      //表示变量i的值加1，i的值变成4
        ++i;      //表示变量i的值加 1，i的值变成5
        System.out.println("i=" + i);
    }

    /**
     * 面试题1
     */
    @Test
    public void test4() {
        int i = 3;
        int j = i++;  // 先复制，在运输算
        // i等于多少，j等于多少？
        System.out.println("i=" + i);// 4
        System.out.println("j=" + j);// 3
    }

    /**
     * 面试题2
     */
    @Test
    public void test5() {
        int i = 3;
        int j = ++i;  // 先运算，在赋值
        // i等于多少，j等于多少？
        System.out.println("i=" + i);// 4
        System.out.println("j=" + j);// 4
    }

    /**
     * 面试题3
     */
    @Test
    public void test6() {
        int i = 3;
        i = ++i;  // 先运算，在赋值
        // i等于多少，j等于多少？
        System.out.println("i=" + i); // 4
        int j = 3;
        j = j++;
        System.out.println("j=" + j); // 3
    }

    /**
     * 面试题3
     * 破题关键点：
     * i++是先赋值在执行 自增
     * ++i 是先执行自增 在赋值
     */
    @Test
    public void test7() {
        int i = 3;
        //      3(4)  4(5)  5(6)
        int a = i++ + i++ + i++;
        //      7      8     9
        int b = ++i + ++i + ++i;
        //请问 a=?  b=? i=?
        System.out.println("a=" + a);
        System.out.println("b=" + b);
        System.out.println("i=" + i);
    }

    /**
     * 3. 赋值运算[简单，与平时的数学逻辑一样]
     * =    +=     -=     *=     /=    %=
     * 1)赋值符号的运算顺序？
     * 从右到左，把符号右边的值赋值到左边的变量中
     * 2）上面 后五个分别看成是一个整体： 例如 += 看成是一个符号，不要看成两个；
     */
    @Test
    public void test8() {
        //请先在每行的后面给出i的值，然后用断点观察i值得变换
        int i = 3;
        i += 2;// 表示把2 累加到变量 i 中
        i -= 1; // 表示把-1 累加到变量 i 中
        i *= 3; // 等价  i=i*3;   划重点：等价不是等于
        i /= 3; // 等价  i=i/3;
        i %= 3;  // 等价 i=i%3;
        System.out.println("i=" + i);
    }

    /**
     * 超级面试题
     */
    @Test
    public void test9() {
        short s = 3;
        s += 2; //正常
        System.out.println("s=" + s);
        //===========================
        short s2 = 3;
        // 语法错误，结果值是int，int不能自动转换为short
        // s2 = s2+2;
    }

    /**
     * 4.比较运算符[掌握]
     * ==    !=     >    <    >=    <=    instanceof
     * 规律：比较运算的结果是一个布尔类型的值（true 或false）；
     * 举例：
     * 定义一个布尔表达式，打印输出
     * 特别说明：instanceof 是判断一个对象是否属于某种类型
     * 是否可以用于我们之前学习的基本数据类型
     */
    @Test
    public void test10() {
        System.out.println(1 == 2); //false
        System.out.println(1 <= 2); //true
        // instanceof
        //是否可以用于我们之前学习的基本数据类型  ==> 不可以
        // System.out.println( 1 instanceof int);
        System.out.println("爱老虎油" instanceof String); // true
    }

    /**
     * 5.逻辑运算符[掌握]
     * &    |     &&     ||   ^    ！
     * 是应用于多个条件的组合判断。
     * 示例说明：
     * 例如小明参加2个学科的考试 java php
     * 1)java 和 php 同时考100分，奖励 欧洲十日游
     * 伪代码描述：java==100 并且 php==100
     * 2)java 和php，只要有一门考100分，奖励 奖励棒棒糖一个
     * 伪代码描述：java==100 或者 php==100
     * <p>
     * 逻辑运算的两边结果值都必须是什么类型？  布尔
     * <p>
     * &   ：两边都为true ，结果为true
     * |    ： 只要有一边为true，结果为true
     * && ：   两边都为true ，结果为true
     * ||    : 只要有一边为true，结果为true
     * ^    : 两边不一样，结果为true ，否则为false，举个例子打印一下
     * ！  ： 逻辑非，举个例子打印一下
     */
    @Test
    public void test11() {
        int java = 100;
        int php = 100;
        int c = 90;
        int mysql = 80;
        // ||    : 只要有一边为true，结果为true
        System.out.println(java == 100 || php == 100); //true
        System.out.println(java == 100 || c == 100); //true
        System.out.println(mysql == 100 || c == 100); //false
        // && 两边都为true ，结果为true
        System.out.println(java == 100 && php == 100); //true
        System.out.println(java == 100 && c == 100); //false
        // 逻辑非
        System.out.println(java != 100); //false
        System.out.println(c != 100); // true

        // ^    : 两边不一样，结果为true ，否则为false，举个例子打印一下 (用的很少)
        System.out.println(java == 100 ^ php == 100); //false
        System.out.println(mysql == 100 ^ c == 100); //false
        System.out.println(java == 100 ^ c == 100); //true
    }

    /**
     * &&  ||   和   & |    区别？
     * 1) & | 既可以充当逻辑运算，也可以是位运算符，怎么区分是逻辑运算还是位运算？
     * 根据表达式的结果是否为 布尔类型 来判断
     * 2)双与  双或  具有短路行为  什么意思？
     * 举个例子 上面小明的考试的成绩 要求是两科都为100分，看到第一科低于100分之后没有必要再看第二科成绩
     * 代码表示：Java = 100  && php = 100   （java只考了5分）
     * 如果逻辑运算左边的值能够确定整个逻辑运算表达式的值，那么右边就不执行了，短路了。
     * && 何时短路 ？    左边表达式结果为false
     * ||  何时短路 ？    左边表达式结果为true
     * 思考：如何验证短路行为？
     * 提示：
     * 右边表达式用  自增自减，例如 ++i = 5
     * 或者使用一个编译正常，运行报错的表达式，例如 1/0
     */
    @Test
    public void test12() {
        int java = 5;
        int php = 100;

        // 区分 && 与 &
        System.out.println(java == 100 && (++php) == 100); // php=100  &&具有短路行为，左边为false时，不在执行右边
        System.out.println(java == 100 & (++php) == 100); // php=101

        php = 100;
        // 区分 || 与 |
        System.out.println(php == 100 || (++java) == 100); // java=5  ||具有短路行为，左边为true时，不在执行右边
        System.out.println(php == 100 | (++java) == 100); // java=6
        System.out.println("java=" + java + " php=" + php);
    }

    /**
     * 面试错误题
     * 例如：判断一个整数的变量 a里面的数据  在0-100之间
     * 正确写法： a>0   &&  a<100
     * 错误写法:   0<  a < 100  (java没有这种语法，不支持)
     */
    @Test
    public void test13() {
        int a = 10;
        System.out.println(a > 0 && a < 100);

        //System.out.println(0 < a < 100); 错误
    }

    /**
     * 十进制转成二进制
     * String s = Integer.toBinaryString(n)  //将十进制数转成字符串，例如n=5 ，s = "101"
     * <p>
     * 将字符串转成整形
     * int a = Integer.valueof("1002");  //当然s只能是数字类的字符串
     */
    @Test
    public void test14() {
        //十进制转成二进制
        String s = Integer.toBinaryString(5);
        System.out.println("s=" + s);
        //二进制转变为十进制
        BigInteger bi = new BigInteger("011", 2);    //转换为BigInteger类型
        int a = Integer.parseInt(bi.toString());
        System.out.println("a=" + a);
    }

    /**
     * 6.位运算符[了解]
     * &    |    ^     ~    <<      >>     >>>
     * 位运算就是 二进制的位进行运算。
     * 示例：比如计算 125+176 ，从数学的角度是怎么计算的？
     * 同理，位运算也类似，比如 3&4
     * <p>
     * 可以把1看成是true,把0看成是false
     * &  :与 位运算，两边为1，结果为1
     * |   :或 位运算，有一个为1，结果为1
     * ^  :  异或，两边不一样，就为1，否则为0
     * ~  :  取反，1变成0  ,0 变成1
     * << :  向左位移动，例如1<<3
     * >> :   向右位移动，例如8>>2
     * >>>:  无符号向右移动
     * <p>
     * 注意：
     * 正数的补码，反码，原码 都一样；
     * 负数的反码：符号为不变，其他位取反;
     * 负数的补码：它的反码+1;
     */
    @Test
    public void test15() {
        // &  :与 位运算，两边为1，结果为1
        System.out.println(20 & 30); //得到的是十进制数
        System.out.println("20的二进制：" + Integer.toBinaryString(20));
        System.out.println("           &");
        System.out.println("30的二进制：" + Integer.toBinaryString(30));
        System.out.println("----------------------------------------");
        System.out.println("            " + Integer.toBinaryString(20 & 30));
    }

    @Test
    public void test16() {
        // |   :或 位运算，有一个为1，结果为1
        System.out.println(20 | 30); //得到的是十进制数
        System.out.println("20的二进制：" + Integer.toBinaryString(20));
        System.out.println("           |");
        System.out.println("30的二进制：" + Integer.toBinaryString(30));
        System.out.println("----------------------------------------");
        System.out.println("            " + Integer.toBinaryString(20 | 30));
    }

    @Test
    public void test17() {
        //<< :  向左位移动，例如1<<3  , 左位易的本质运算是，假设 a<<b ,相当于数学中的运算 a乘以2的b次方
        System.out.println(2 << 3); //得到的是十进制数
        System.out.println("2的二进制：000" + Integer.toBinaryString(2));
        System.out.println("           <<3");
        System.out.println("----------------------------------------");
        System.out.println("           " + Integer.toBinaryString(2 << 3));
    }

    /**
     * 注意：
     * 正数的补码，反码，原码 都一样；
     * 负数的反码：符号为不变，其他位取反;
     * 负数的补码：它的反码+1;
     */
    @Test
    public void test18() {
        //~  :  取反，1变成0  ,0 变成1
        System.out.println(~(-5)); //得到的是十进制数
        System.out.println("原码：00000000000000000000000000000" + Integer.toBinaryString(5));
        System.out.println("反码：" + Integer.toBinaryString(-5));
        System.out.println("补码：00000000000000000000000000000" + Integer.toBinaryString(~(-5)));
    }

    /**
     * 7.三目运算符[掌握]
     * 语法格式： X ? Y : Z
     * 1)上面的三目运算整体看成是一个表达式，应该有一个结果值
     * 2)X ?  布尔类型的值或者结果为布尔类型的表达式
     * 3)Y  Z  ? 一般来说数据类型相同的值或者表达式
     * 4)运算的规则？
     * X 为true，就是 Y 的结果值 ( 冒号前面的表达式的值)
     * X为false，就是Z的结果值 ( 冒号后面的表达式的值)
     * x ? y : z
     * <p>
     * 注意：  不要受  ？ 和    :  的干扰，它们只是一个固定语法格式而已
     */
    @Test
    public void test19() {
        //举例：找出两个整型变量中的最大值
        int a = 6;
        int b = 7;
        int c = a > b ? a : b;
        System.out.println("c=" + c);
        //举例 判断一个数是 奇数 还是 偶数
        int i = 9;
        System.out.println(i % 2 == 0 ? "偶数" : "奇数");
    }

}

2.条件选择结构-if

package com.wfd360.day02;


import org.junit.Test;

public class Demo02If {
    /**
     * if(判断条件){
     * 满足 判断条件(true),就执行此大括号里面的内容
     * }
     */
    @Test
    public void test1() {
        //案例：如果a>90,输出:优秀
        int a = 96;
        if (a > 90) {
            System.out.println("优秀");
        }
    }

    /**
     * if(判断条件A){
     * 满足 判断条件A(true),就执行此大括号里面的内容,后面的else不会执行
     * }else{
     * 前面的 判断条件A（false），执行else大括号里面的内容
     * }
     */
    @Test
    public void test2() {
        //案例：如果a>90,输出:优秀,否则输出:一般
        int a = 96;
        if (a > 90) {
            System.out.println("优秀");
        } else {
            System.out.println("一般");
        }
    }

    /**
     * if(判断条件A){
     * 满足 判断条件A(true),就执行此大括号里面的内容,后面的else-if不执行
     * }else if(判断条件B){
     * 满足 判断条件B(true),就执行此大括号里面的内容
     * }
     */
    @Test
    public void test3() {
        //案例：如果a>90,输出:优秀
        // 如果80<a<=90 ,输出: 良好
        int a = 96;
        if (a > 90) {
            System.out.println("优秀");
        } else if (a > 80) {
            System.out.println("良好");
        }
    }

    /**
     * if(判断条件A){
     * 满足 判断条件A(true),就执行此大括号里面的内容,后面的else-if不执行
     * }else if(判断条件B){
     * 满足 判断条件B(true),就执行此大括号里面的内容
     * }else{
     * 前面的if  esle-if 都不满足条件(false),执行此大括号里面的内容
     * }
     */
    @Test
    public void test4() {
        //案例：如果a>90,输出:优秀
        // 如果80<a<=90 ,输出: 良好
        // 否则,输出一般
        int a = 96;
        if (a > 90) {
            System.out.println("优秀");
        } else if (a > 80) {
            System.out.println("良好");
        } else {
            System.out.println("一般");
        }
    }

    /**
     * else if 可以有多个
     */
    @Test
    public void test5() {
        //案例：如果a>90,输出:优秀
        // 如果80<a<=90 ,输出: 良好
        // 如果70<a<=80, 输出: 合格
        // 否则,输出一般
        int a = 96;
        if (a > 90) {
            System.out.println("优秀");
        } else if (a > 80) {
            System.out.println("良好");
        } else if (a > 70) {
            System.out.println("合格");
        } else {
            System.out.println("一般");
        }
    }

    /**
     * 简写
     * if 后面的大括号如果不写，表示执行是后面的第一行代码（不建议这样写）
     */
    @Test
    public void test6() {
        //案例：如果a>90,输出:优秀
        int a = 96;
        if (a > 90)
            System.out.println("优秀");
    }

    /**
     * 练习(学编程有捷径,那就是多敲,疯狂的敲代码,不论是简单的还是复杂的代码)
     * 1.求出2个变量中的最大值
     * 2.判断一个数是否是3的倍数
     * 3.小明java 考试成绩  按等级分   A B C  D ，判断变量值在不同的范围的，打印输出不同的等级
     * 90~100 A等。
     * 80-89 B等。
     * 70-79 C等。
     * 60-69 D等。
     * 60以下E等。
     */
    @Test
    public void test7() {
        //自己动手写,写完之后给老师检查
    }
}

3.条件选择结构-switch　

package com.wfd360.day02;

import org.junit.Test;

/**
 * 条件选择结构-switch
 * 作用和if差不多，只是语法结构不一致而已。
 * <p>
 * <p>
 * switch(变量或者一个表达式){
 * case 变量的可能值1: 功能语句;break;
 * case 变量的可能值2: 功能语句;break;
 * case 变量的可能值3: 功能语句;break;
 * ........
 * default:功能语句;break;
 * }
 */
public class Demo03Switch {
    /**
     * 案例:将数字1,2,3....7 输出对应的星期:周一,周二,周三,.....周末
     */
    @Test
    public void test1() {
        int week = 5;
        switch (week) {
            case 1:
                System.out.println("周一");
                break;
            case 2:
                System.out.println("周二");
                break;
            case 3:
                System.out.println("周三");
                break;
            case 4:
                System.out.println("周四");
                break;
            case 5:
                System.out.println("周五");
                break;
            case 6:
                System.out.println("周六");
                break;
            case 7:
                System.out.println("周天");
                break;
            default:
                System.out.println("没有对应数字的星期");
        }
    }

    /**
     * 1) case的顺序（包括default） 可以是任意的，但是建议先按照case的值的大小顺序排列，default放最后
     * 2)执行顺序，是先依次找完所有的case,如果都不匹配才会执行default
     * 3) break的作用，结束当前的这个switch结构
     * 从第一个匹配的条件开始，到第一个break之间的所有case判断失效 (这个特点非常重要,结合下面的例子理解)
     * 在执行功能语句时，如果到末尾都没有break,自动结束，不会再循环回去。
     * 最后一个break 可以省略掉，但是建议还是写上
     * 4) case后面的值应该和变量的类型一致;
     * 5) switch中的（）中的变量地方类型可以是哪些？
     * java5之前   ：  byte short char int
     * java5支持   ：   enum枚举  （面向对象部分学习了之后回头测试）
     * java7支持   ：  String 类型
     */
    @Test
    public void test2() {
        //根据月份,输出春夏秋冬 ,从第一个匹配的条件开始，到第一个break之间的所有case判断失效 (这个特点非常重要,结合例子理解)
        int month = 2;
        switch (month) {
            case 1:
            case 2:
            case 3:
                System.out.println("春天");
                break;
            case 4:
            case 5:
            case 6:
                System.out.println("夏天");
                break;
            case 7:
            case 8:

            case 9:
                System.out.println("秋天");
                break;
            case 10:
            case 11:
            case 12:
                System.out.println("冬天");
                break;
            default:
                System.out.println("月份数字错误");
                break;
        }
    }
}

4.java中的循环结构-while

package com.wfd360.day02;

import org.junit.Test;

/**
 * Java中提供了3  种循环
 * while  do-while  for
 * 1.上面的3中循环功能都是一样的，只是语法结构不一样，很多时候是可以相互交换的
 * ， 既然都差不多，为什么有多个呢？
 * 不同的循环结构，有不同的使用场景和优势
 * <p>
 * 2.在写循环代码之前呢？
 * 1)要做什么事情
 * 2)次数
 * 3)要写循环，必须知道循环的语法
 */
public class Demo04While_循环 {
    /**
     * while 基本用法[掌握]
     * 语法格式：
     * while(条件（布尔类型的）){
     * // 循环体具体做什么事情
     * }
     * <p>
     * 执行流程
     * 1.一个循环可能会循环执行多次
     * 第一次判断条件true，继续执行
     * 第二次判断条件true，继续执行
     * 第三次判断条件true，继续执行
     * 。。。。。
     * 直到第n次判断条件false，终止循环
     * <p>
     * 为什么第一次 第二次是true 。。。 n次就是false?
     */

    /**
     * 条件可以是一个常量
     * 举个例子(条件为布尔值true)
     * <p>
     * 这个例子是死循环,小心电脑崩溃,启动后建议马上手动停止
     */
    @Test
    public void test1() {
        while (true) {
            System.out.println("------死循环中-------");
        }
    }

    /**
     * 一般我们使用一个变量来充当条件循环，
     * 举个例子：播放一首歌，循环播放10次
     * 1)定义一个整数的变量记录循环的次数
     * 2)循环一次，自增一次
     * 根据次数进行判断是否继续循环
     */
    @Test
    public void test2() {
        int i = 1;// 1. 初始值
        while (i <= 10) {// 2. i<==10 循环条件
            System.out.println("北京欢迎你----" + i);
            i++; //变化量,很重要,否则就是死循环
        }
    }

    /**
     * 写一段代码计算1-10的和。
     * 1)传统的做法
     * 1+2+3+4+5+6+7+8+9+10
     * 如果要求计算1-100 ， 1-1000 这样写是否合理？
     * 可以动态的获得每一个加数
     * 2)使用while循环，每循环一次，把取到的加数累加起来
     * 3)在循环的外面定义一个变量用来放计算的和的值
     */
    @Test
    public void test3() {
        //案例:计算 1 +2+3...10
        int n = 1;
        int sum = 0;
        while (n <= 10) {
            sum += n;
            n++;
        }
        System.out.println("sum=" + sum);
    }

    /**
     * 练习:
     * 1.求出10以内2的倍数的数字 和 个数。
     */
    @Test
    public void test4() {

    }

    /**
     * 练习:
     * 2.求出 1-10的所有偶数的和
     */
    @Test
    public void test5() {

    }

    /**
     * do-while 基本用法[掌握]
     * do-while    先执行一次，再判断  (*****)
     * 语法格式：
     * do{
     * // 循环体
     * }while(条件);
     * <p>
     * 举例：循环10次
     * 和while区别？
     * 1)定义一个 布尔变量，默认值false
     * 2)将这个布尔变量放在 while  和 do-while 条件中，看有什么区别
     */
    @Test
    public void test6() {
        boolean b = false;
        System.out.println("-----执行while之前--------");
        while (b) {
            System.out.println("------正在执行while------------");
        }
        System.out.println("-----执行while之后--------");

        System.out.println("-----执行do-while之前--------");
        do {
            System.out.println("------正在执行do-while------------");
        } while (b);
        System.out.println("-----执行do-while之后--------");
    }

    /**
     * 案例:使用do-while  求出1-100的和
     */
    @Test
    public void test() {

    }
}

5.java中的循环结构-for