2020-09-12

16.关于浮点型数据类型：
float 单精度【4个字节】
double 双精度【8个字节，精度较高】

    double的精度太低【相对来说的】，不适合做财务软件。
    财务涉及到钱的问题，要求精度较高，所以SUN在基础SE类库当中
    为程序员准备了精确度更高的类型，只不过这种类型是一种引用
    数据类型，不属于基本数据类型，它是：java.math.BigDecimal

    其实java程序中SUN提供了一套庞大的类库，java程序员是基于这套基础的类库
    来进行开发的。所以要知道java的SE类库的字节码在哪儿，要知道java的SE类库
    的原码在哪儿？
       * SE类库字节码：C:\Program Files (x86)\Java\jdk\jre\lib\rt.jar
       * SE类库原码：C:\Program Files (x86)\Java\jdk\src.zip

       例如：String.java和String.class
       我们的(String[] args)中的String.class字节码文件

       在java语言当中，所有的浮点型字面值【3.0】，默认被当作double类型来处理，
       要想该字面值当作float类型来处理，需要在字面值后面添加F/f

       注意：double和float在计算机内部二进制存储的都是近似值。
             在现实世界当中有一些数字是无限循环的，例如：3.33333333333....
	     计算机资源是有限的，用有限的资源存储无限的数据只能存储近似值。

       5.1是double类型的字面值
       f是float类型的变量
       大容量转换成小容量需要加强制类型转换符，所以以下程序编译报错。
       float f = 5.1;
       解决方案1：float f = (float)5.1;(强制类型转换)
       解决方案2：float f = 5.1f;(没有类型转换)

 17.关于布尔型数据类型：
      boolean

     在java语言当中boolean类型只有俩个值：true,false,没有其他值。
     不像c语言当中，0和1可以表示假和真。

     在底层存储的时候boolean类型占用1个字节，因为实际存储的时候false底层是0，true底层是1.

     布尔类型在实际开发当中非常重要，经常使用在逻辑运算和条件控制语句当中。

 18.关于基本数据类型之间的互相转换：转换规则
      a. 八种基本数据类型当中除了布尔类型之外剩下的7种类型之间都可以互相转换

      b. 小容量向大容量转换。称为自动类型转换，容量从小到大排序:
        byte < short < int < long < float < double
	       char <
	  注：
	      任何浮点类型不管占用多少个字节，都比整数型容量大。
	      char和short可表示的种类数量相同，但是char可以取更大的正整数

      c. 大容量转换成小容量，叫做强制类型转换，需要加强制类型转换符，程序才能编译通过
      但是在运行阶段可能会损失精度，所以谨慎使用。

      d. 当整数字面值没有超出byte,short,char的取值范围，可以直接赋值给byte,short,char
      类型的变量。

          e. byte,short,char混合运算的时候，各自先转换成int类型再做运算。

      f. 多种数据类型混合运算，先转换成容量最大的那种类型再做运算。

      g.注意：
             byte b = 3;  可以编译通过，3没有超出byte类型取值范围

	     int i = 10;
	     byte b = i / 3;  编译报错，编译器只检查语法，不会“运算” i / 3

      例题：
           double dd = 10 / 3;  // 3.0  (10和3默认为int，所以运算后的最大类型也是int,10 / 3 为 3，然后自动类型转换为3.0)
	   dd = 10.0 / 3;  //3.3333333333  (3先转换为3.0，然后10.0 / 3.0 = 3.333333)

               long g = 10;
	   byte h = (byte)(int)g/3;(编译期只检查语法不进行运算,优先级的问题)
               byte h = (byte)(int)(g/3);

运算符：
* 算数运算符
* 关系运算符
* 逻辑运算符
* 赋值类运算符
* 字符串连接运算符
* 三元运算符

     1.算数运算符：
      +      求和
      -      相减
      *      乘积
      /      商
      %      求余数【取模】

      ++     自加1
      --     自减1

    注意：一个表达式当中有多个运算符，运算符有优先级，不确定的加小括号，优先级得到提升。
          没有必要专门记忆运算符的优先级

	 ++运算符可以出现在变量后面【单目运算符】
	 int k = 10;
	 k ++;
	 System.out.println(k);  //11
             ++运算符可以出现在变量前面【单目运算符】
	 int y = 10;
	 ++ y;
             System.out.println(y);  //11

	 小结：++运算符可以出现在变量前，也可以出现在变量后，无论是变量前还是变量后
	 只要++运算结束，该变量中的值一定会自加1

	 ++ 出现在变量之后
***	 规则：先做赋值运算，再对变量中保存的值进行自加1【先使用(包括赋值、输出、参与运算)，后加1】
	 int a = 100;
	 int b = a ++;
	 System.out.println(a);  //101
             System.out.println(b);  //100
	 
             ++ 出现在变量之前
	 规则：先进行自加1，再做赋值运算
	 int m = 20;
	 int n = ++ m;
	 System.out.println(m);  //21
             System.out.println(n);  //21

	 int e = 100;
   ***       System.out.println(e ++);  //100(有一个println函数，把e ++的值赋给形参，先做赋值运算再自加1)
             System.out.println(e);  //101

             int s = 100;
             System.out.println(++ s);  //101
             System.out.println(s);  //101

             System.out.println(-- s);  //100
             System.out.println(s++);  //100
             System.out.println(s--);  //101
             System.out.println(s--);  //100
             System.out.println(s--);  //99
             System.out.println(s);  //98

 2.关系运算符：
     >        大于
     >=       大于等于
     <        小于
     <=       小于等于
     ==       等于
     !=       不等于

    = 是赋值运算符
    == 是关系运算符

    关系运算符的运算结果一定是布尔类型：true/false关系运算符的运算原理：
                      关系运算符是比较变量中保存的那个值之间的大小关系

    int a = 10;
    int b = 10;
        System.out.println(a == b);  //true

 3.逻辑运算符：
     &        逻辑与【并且】   （两边的算子都是true，结果才是true）
     |        逻辑或【或者】  （两边的算子只要有一个是true，结果才是true）
     ！       逻辑非          （取反，！false就是true，！true就是false，这是一个单目运算符）
     ^        逻辑异或        （两边的算子只要不一样，结果就是true）

     &&       短路与
     ||       短路或

   * 逻辑运算符要求两边的算子都是布尔类型，并且逻辑运算符最终的运算结果也是一个布尔类型。

   * 短路与和逻辑与最终的运算结果是相同的，只不过短路与存在短路现象。

   * 短路或和逻辑或最终的运算结果是相同的，只不过短路或存在短路现象。

   * 什么情况下发生短路现象呢？
       什么情况下发生短路或？
            第一个表达式执行结果是true,会发生短路或。
       什么情况下发生短路与？
            第一个表达式执行结果是false,会发生短路与。

   * 什么时候选择使用逻辑与运算符？什么时候选择使用短路与运算符？

      逻辑与和短路与
      int x = 10;
      int y = 8;
      逻辑与：System.out.println( x < y & ++x < y);
              System.out.println(x);  // 11

      短路与：System.out.println( x < y && ++x < y);
              System.out.println(x);  // 10
	      x < y 结果是false，整个表达式结果已经确定是false，所以后面的表达式没有再执行，这种现象被称为
	      短路现象。短路与才会有短路现象，逻辑与是不会存在短路现象的。

	      从某个角度来看，短路与更智能。由于后面的表达式可能不执行，所以执行效率较高。
	      这种方式在实际的开发中使用较多。短路与比逻辑与使用的多。短路与更常用。

	      但是，在某些特殊的业务逻辑当中，要求运算符两边的算子必须全部执行，此时必须使用逻辑与，不能使用短路与
	      使用短路与可能导致右边的表达式不执行。4.赋值类运算符：
      * 基本的赋值运算符
            =

      * 扩展的赋值运算符
            +=  （可以翻译为“追加”/“累加”）
            -=
	    *=
	    /=
	    %=

	A.赋值类运算符优先级：先执行等号右边的表达式，将执行结果赋值给左边的变量。

	B.注意以下代码：

	  byte b = 10;
	  b = 15;
	  b = b + 5; //编译错误，为什么？ 编译器只检查语法，不运行程序，编译器发现b+5的类型是int类型，
	               b变量的数据类型是byte，大容量向小容量转换需要加强制类型转换符，所以以下程序编译报错。
          b = (byte)(b + 5);  // 纠正错误

	  byte x = 10;
	  x += 5;  //编译成功，为什么？ 等同于：x = (byte)(x + 5),其实并不等同于：x = x + 5

 ***	 C.重要结论：扩展类的赋值运算符不改变运算结果类型，假设最初这个变量的类型是
	       byte类型，无论怎么进行追加或追减，最终该变量的数据类型还是byte类型。

     5.字符串连接运算符：
      关于java中的"+"运算符：
        A. +运算符在java语言当中有两个作用：
	    * 加法运算，求和
	    * 字符串的连接运算

	B. 当"+"运算符两边的数据都是数字的话，一定是进行加法运算。

	C. 当"+"运算符两边的数据只要有一个数据是字符串，一定会进行字符串连接运算。
	并且，连接运算之后的结果还是一个字符串类型。

	    数字 + 数字 --> 数字【求和】

	    数字 + "字符串" --> "字符串" 【字符串连接】

	D. 在一个表达式当中可以出现多个"+"，在没有添加小括号的前提下，遵循自左向右的顺序依次运算。

	  System.out.println( 10 + 20); // 30
              System.out.println( 10 + 20 + 30); // 60
              System.out.println( 10 + 20 + "30"); //"3030" 自左向右的顺序依次运算，第一个加号是求和，第二个加号是字符串的连接
              System.out.println( 10 + ( 20 + "30")); //"102030"

	  int a = 10;
	  int b = 20;

	  //要求在控制台输出"10 + 20 =30"
               System.out.println( "10 + 20 = 30"); 

	   //注意：要求以动态的方式输出
               System.out.println( "10 + 20 = " + a + b); // "10 + 20 = 1020"
               System.out.println( "10 + 20 = " + (a + b)); // "10 + 20 = 30"
               System.out.println( a + " + " + b + "=" + (a + b)); // "10 + 20 = 30"

	   引用类型String
	   String是SUN在JavaSE当中提供的字符串类型
	   String.class字节码文件

	   //int是基本数据类型，i是变量名，10是int类型的字面值
	   int i = 10;

	   //String是引用数据类型，s是变量名，"abc"是String类型的字面值
	   String s = "abc";

	   String username ="zhangsan";
	   System.out.println("登录成功" + username + "回来");6.三目运算符/三元运算符/条件运算符

    A. 语法规则：
       布尔表达式 ? 表达式1 ： 表达式2

    B. 三元运算符的执行原理？
       当布尔表达式的结果是true的时候，选择表达式1作为整个表达式的执行结果
           当布尔表达式的结果是false的时候，选择表达式2作为整个表达式的执行结果

       boolean sex = false;
       sex ? '男' ：'女'; //编译报错，因为它不是一个完整的java语句
       char c = sex ? '男' ：'女'; //可以

       sex = false;

*** char c1 = sex ? “男” ：‘女’; //编译报错，类型不兼容，结果可能是char，也可能是String,但是前边不能用char来接收数据。

*** System.out.println(sex ? “男” ：‘女’); //可以，因为括号里可以是字符串，也可以是字符