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);//
         System.out.println("j=" + j);//
     }
 
     /**
      * 面试题2
      */
     @Test
     public void test5() {
         int i = 3;
         int j = ++i;  // 先运算，在赋值
         // i等于多少，j等于多少？
         System.out.println("i=" + i);//
         System.out.println("j=" + j);//
     }
 
     /**
      * 面试题3
      */
     @Test
     public void test6() {
         int i = 3;
         i = ++i;  // 先运算，在赋值
         // i等于多少，j等于多少？
         System.out.println("i=" + i); //
         int j = 3;
         j = j++;
         System.out.println("j=" + j); //
     }
 
     /**
      * 面试题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