第一章：数据类型转换

Java程序中要求参与计算的数据，必须要保证数据类型的一致，
如果数据类型不一致则发生类型的转换

1.1 自动转换

• 自动转换：将取值范围小的类型自动提升为取回范围大的类型

自动类型转换原理：

一个int变量和一个byte变量进行加法运算，结果会是什么数据类型？
运算结果：变量的类型将是int类型，这就出现了数据类型的转换
如下代码：

• 案例：Demo01_DataType

/**
 * 当数据类型不一致时，将会发生数据类型转换
 *  自动类型转换：隐式
 *      1、代码不需要进行特殊处理，自动完成
 *      2、数据范围从小到大
 *  强制类型转换：显示
 *
 */
public class Demo01_DataType {
    public static void main(String[] args) {
        System.out.println(1000);   //输出一个整数，默认是int类型
        System.out.println(3.14);   //输出一个小数，默认是double类型


        //int--->long
        /*
            左边是：long类型，右边默认是int类型，左右不一样
            一个等号代表赋值，将右边的int常量100，交给左边long类型的变量进行存储
            int ---> long：符合数据范围从小到大的要求
            这一行代码发生了数据类型转换：由int转向long
         */
        //long num1 =100L;
        //System.out.println(num1);
        long num2 =100;
        System.out.println(num2);//100

        //float--->double
        /*
            左边是double类型，右边是float类型，左右不一样
            float---> double，符合从小到大的规则
            也发生了自动类型转换
         */
        double num3 = 3.3F;
        System.out.println(num3);//

        //long-->float
        /*
            左边是float类型，右边是long类型，左右不一样
            long-->float,范围是float更大些，符合从小打到的规则
            发生了自动类型转换
         */
        float num4 = 60L;
        System.out.println(num4);//60.0
    }
}

1.2 强制转换

• 强制类型转换：将取值范围大的类型，强制转换成取值范围小的类型

强制类型转换原理:
	将1.55赋值给int类型的变量会发生什么？出现编译失败，无法赋值
	即：int a = 1.55;//编译失败

	double类型内存为8字节，int类型内存为4字节，
	1.55是double类型，取值范围大于int。

	可以理解为double是8L的水壶，int是4L的水壶，
	不能把大水壶中的水直接放在小水壶中去，

	想要赋值成功，只有通过强制类型转换，
	将double类型强制转换成int类型才能赋值，

• 转换格式：

数据类型 变量名称 = (数据类型) 被转数据值;

• 案例：

/**
 * 强制类型转换：
 *      特点：代码需要进行特殊格式的处理，不能自动完成
 *      格式：范围小的类型 范围小的变量名 = (范围小的类型) 原本范围大的数据;
 *
 *  注意事项：
 *      1、强制类型转换一般不推荐使用，因为有可能发生精度丢失、数据溢出
 *      2、byte/short/char这三种类型都可以发生数学运算，例如加法"+"
 *      3、byte/short/char这三种类型在运算的时候，都会被首先提升为int类型，然后再计算
 *      4、boolean类型不能发生数据类型转换
 */
public class Demo02_DataType {
    public static void main(String[] args) {
        //long--->int
        //左边是int类型，右边是long类型,不一样
        //不能发生自动类型转换:int num1 = 100L;
        //格式：范围小的类型 范围小的类型名 = (范围小的类型) 原本范围大的数据
        int num1 = (int)300000000L;
        System.out.println(num1);//300000000

        //double--->int 强制类型转换
        int num2 = (int) 3.88;
        System.out.println(num2);//3 注意：不是四舍五入，而是所有的小数都会被舍弃掉

        //char和int运算
        char c1 = 'a';//字符型变量c1，存放字符a
        System.out.println(c1+1);//98 小写字母a被当做97进行运算，
        //计算机的底层会使用二进制数字表示一个字符
        //一旦char类型参与运算，那么字符就会按照一定的规则翻译成一个数字

        //byte与byte执行加法运算，byte会先自动转化成int，再进行运算操作
        byte num3 = 60;//注意右侧的数据不能超过左侧数据类型的取值范围
        byte num4 = 30;
        //byte num5 = num3+num4;//编译会报错
        // byte+byte ---> int+int=int
        int num6 = num3+num4;
        System.out.println(num6);

        //short与byte的相加运算，byte和short都会转换成int类型之后，再参与运算
        short num8 = 40;
        byte num9 = 30;
        int num10 = num8+num9;
        short num11 = (short) (num8+num9);//num8+num9 先默认执行自动转型成int。然后再强制转换成short
    }
}

• 注意事项

1、强制类型转换一般不推荐使用，因为有可能发生精度丢失、数据溢出
2、byte/short/char这三种类型都可以发生数学运算，例如加法"+"
3、byte/short/char这三种类型在运算时，都会被提升为int类型再计算
4、boolean类型不能发生数据类型转换

第二章：运算符

2.1 算术运算符

• 1、算术运算符----四则与取模运算

四则运算：加 减 乘 除
运算步骤：首先计算得到表达式的结果，然后再打印输出这个结果
除法运算：除法运算使用的是整除，
		 整数除以整数，结果仍然是整数，只看商值，不看余数
取模运算：即求余数。使用符号%。（取模只对于整数运算存在意义）
注意事项：运算中出现不同类型的数据，结果将是数据类型范围大的

public class Demo04_Operator {
    public static void main(String[] args) {
        //两个常量之间进行数学运算
        System.out.println(20+29);//49

        //两个变量之间进行数学运算
        int a = 22;
        int b = 33;
        System.out.println(a+b);//55

        //变量和常量之间混合进行数学运算
        int c = 50;
        System.out.println(c+50);//100

        //整数除法运算
        int d = 31;
        int e = 2;
        int result1 = d/e;
        System.out.println(result1);//商值：15

        //取模运算
        int result2 = d%e;
        System.out.println(result2);//余数：1

        //不同类型运算，结果会是数据类型大的那种
        double result3 = d+2.5;
        System.out.println(result3);//33.5
    }
}

• 2、算术运算符----加号的多种用法

  1、对于数值来说，+号就是加法
  2、对于字符char类型:
  		在计算之前，char会被提升为int，然后再进行计算  
        char类型字符和int类型数字之间的关系表：ASCII和Unicode
  3、对于字符串来说，加号代表字符串连接操作，
  		任何数据与字符串连接，结果都会变成字符串
  4、优先级：括号的优先级最高，先运算括号中的内容

• 3、案例

public class Demo05_Operator {
    public static void main(String[] args) {
        //字符串类型的变量使用格式
        //格式：字符串类型 字符串变量 = 数据值;
        String str1 = "qiaodan";
        System.out.println(str1);//qiaodan

        //字符串相加。即字符的连接
        System.out.println("Hello"+"World");//HelloWorld

        //String + int = String
        String str2 = "hello";
        int num1 = 22;
        System.out.println(str2+num1);//hello22

        //优先级:括号的优先级大于其他
        String str3 = "James";
        System.out.println(str3+10+10);//James1010
        System.out.println(str3+(10+20));//James30
    }
}

• 3、算术运算符----自增自减运算

1、自增符号：++
2、自减符号：--
3、基本含义：让一个变量增长一个数字1，让一个变量减少一个数字1 
4、使用格式：写在变量之前，或写在变量之后；++a,a++,b--.--b
5、使用方式：  
   1)、单独使用：不和其他任何操作混合，自己独立成为一个步骤 
   2)、混合使用：和其他操作混合
6、使用区别： 
   1)、在单独使用的时候，前++和后++没有什么区别，
   	   也就是 ++a,a++是一样的 
   2)、在混合使用的时候，区别如下：    
       区别1：如果++在前，变量会立刻加1.拿着结果进行运算。
       		 【先自增后运算】 
       区别2：如果++在后，变量首先使用本值参与运算，然后变量再加1。
             【先运算后自增】
7、注意事项：只有变量才能自增，自减运算符，常量不可以

public class Demo06_Operator {
    public static void main(String[] args) {
        //单独使用
        int num1 = 100;
        System.out.println(num1);//100
        ++num1;// ++在前
        System.out.println(num1);//101
        num1++;// ++在后
        System.out.println(num1);//102

        System.out.println("-----------------------------");

        //混合使用 ++在前
        int num2 = 200;
        //变量先+1,然后打印结果
        System.out.println(++num2);//201
        System.out.println(num2);//201

        System.out.println("-----------------------------");

        //混合使用 ++在后
        int num3 = 300;
        //变量选运算，//运算结束后在+1
        System.out.println(num3++);//300
        System.out.println(num3);//301

        System.out.println("-----------------------------");

        //混合运算--和赋值相结合1
        int num4 = 40;
        //前--。变量立刻-1.编程39.再赋值给result1
        int result1 = --num4;
        System.out.println(result1);//39
        System.out.println(num4);//39

        System.out.println("-----------------------------");

        //混合运算--和赋值相结合2
        int num5 = 50;
        //后--，变量先把原来的值50赋值给result2.然后-1，变成49
        int result2 = num5--;
        System.out.println(result2);//50
        System.out.println(num5);//49

        System.out.println("-----------------------------");

        //++ . --混合
        int x = 22;
        int y = 33;
        int result3 = x++ + --y;
        System.out.println(result3);//54
        System.out.println(x);//23
        System.out.println(y);//32
    }
}

2.2 赋值运算符

• 赋值运算符

概念：就是将符号右边的值，赋值给符号左边的变量

 赋值运算符：
   基本赋值运算符：单个“=”，代表将右侧的数据交给左侧的变量保存。如：int a = 10;
   复合赋值运算符：
       +=  a+=1    等价于     a=a+1
       -=  b-=2    等价于     b=b-2
       *=  c*=3    等价于     c=c*3
       /=  d/=4    等价于     d=d/4
       %=  e%=5    等价于     e=e%5
  注意事项：
   	1、只有变量才能使用赋值运算符，常量不能进行赋值
   	2、复合运算符其中隐含了一个强制类型转换

    public static void main(String[] args) {
        int a = 5;
        a+=5;//即：a=a+5,也就是变量a先加5，再赋值给变量a
        System.out.println(a);//输出结果是10
    }

• 练习 Demo07_Operator

/**
 * 赋值运算符：
 *  基本赋值运算符：单个“=”，代表将右侧的数据交给左侧的变量保存。如：int a = 10;
 *  复合赋值运算符：
 *      +=  a+=1    等价于     a=a+1
 *      -=  b-=2    等价于     b=b-2
 *      *=  c*=3    等价于     c=c*3
 *      /=  d/=4    等价于     d=d/4
 *      %=  e%=5    等价于     e=e%5
 * 注意事项：
 *  1、只有变量才能使用赋值运算符，常量不能进行赋值
 *  2、符合运算符其中隐含了一个强制类型转换
 */

public class Demo07_Operator {
    public static void main(String[] args) {
        // +=练习
        int a = 10;
        a+=5;//a = a + 5  a=15
        System.out.println(a);//15

        // -= *= /+同上

        //%=练习
        int b = 11;
        b%=3;//b = b % 3  b=2
        System.out.println(b);//2

        //隐含强制类型转换
        byte c = 5;
        //byte c = c + 5
        //byte c = byte + int
        //byte c = int + int
        //byte c = int
        //byte c = (byte) int
        c+=5;
        System.out.println(c);//10
    }
}

2.3 比较运算符

• 比较运算符

概念：两个数据之间进行比较的运算，运算结果都是布尔值，
     即true或者false

• 注意事项

  1、两个等号== 表示比较符号两边数据是否相等，单个 = 表示复制
  2、比较运算符的结果一定是boolean值，成立是true，否则是false     
  3、如果进行多次判断不能连着写

• 练习 Demo08_Operator

  public class Demo08_Operator {
      public static void main(String[] args) {
          //常量比较
          System.out.println(10 > 5);//true
          System.out.println(5.5 < 1.5);//false
  
          //变量比较
          int num1 = 10;
          int num2 = 20;
          System.out.println(num1 > num2);//false
  
          //混合使用
          System.out.println(num1 >= 10);//true
          System.out.println(num1 <= 10);//true
          System.out.println(num2 == 20);//true
          System.out.println(num2 != 30);//true
  
          //多次判断不能连着写
          int num3 = 30;
          //System.out.println(20<num3<40);//编译错误
      }
  }
  

2.4 逻辑运算符

与	&&	全部是true，才是true，否则是false
或	||	至少一个是true，就是true，全部是false，才是false
非	！	本来是true，变成false。本来是false，变成true

逻辑运算符：
   与 （并且） &&  全为true，才是true。否则为false
   或 （或者） || 至少一个为true，即为true。全false。才false
   反  (取反) !  原本是true，取反为false，原本是false，取反为true
 
   注意事项：
       &&且 、||或，具有短路效果，
       即：如果左边可以判断得到最终结果，
       	   那么右边的代码将不再执行，从而提高性能

• 练习 Demo09_Operator

public class Demo09_Operator {
    public static void main(String[] args) {
        //&&且
        System.out.println(true && true);//true
        System.out.println(true && false);//false
        System.out.println(false && false);//false

        //||或
        System.out.println(true || true);//true
        System.out.println(true || false);//true
        System.out.println(false || false);//false

        //取反
        System.out.println( !false);//true
        System.out.println( !true);//false

        //短路效果
        int a = 10;
        System.out.println(1 > 2 && ++a < 100);//false
        System.out.println(a);//10

        int b = 20;
        System.out.println(1 < 2 || ++b < 100);//true
        System.out.println(b);//20
    }
}

2.5 三元运算符

   一元运算符：只需要一个数据就可以操作的运算符。如：自增 自减
   二元运算符：需要两个数据才能操作的运算符。如：加法
   三元运算符：需要三个数据才能操作的运算符。
 
   三元运算符：
       格式：数据类型 变量名称 = 条件判断 ? 表达式A : 表达式B
       流程：首先判断条件是否成立：二选一
               条件成立为true，取表达式A的值赋值给左侧变量
               条件不成立为false。取表达式B的值赋值给左侧变量
 
   注意事项：
       1、必须同时保证表达式A和表达式B都符合左侧数据类型的要求
       2、三元运算符的结果必须被使用

练习 Demo10_Operator

public class Demo10_Operator {
    public static void main(String[] args) {
        int a = 30;
        int b = 40;
        //如果a>b为true。则将表达式a赋值给变量c。并输出
        int c = a > b ? a : b;
        System.out.println(c);//40

        //简化写法
        System.out.println(a < b ? a : b);//30
    }
}

2.6 运算符注意事项

• byte、short、char的使用注意事项

1、对于byte、short、char三种类型来说，
   如果右侧赋值的数值没有超过范围，
   那么javac编译器将会自动隐含的为我们补上一个(byte)(short)(char)

2、如果右侧超过了范围，那么编译器就会报错

3、编译器的常量优化
   如果右侧的表达式中都是常量，没有任何变量参与运算
​   short result = 2+3; //等号右边全部是常量，没有任何变量参与运算
​   在代码编译之后等到的.class文件的结果是：
		short result = 5;(注意此时代码还没有运行)
​   这被称为是“编译器的常量优化”
   但是一旦表达式中出现变量参与运算，就不存在此种优化 

• 案例 Demo12_Notice

public class Demo12_Notice {
    public static void main(String[] args) {
        //1、右侧数据值没有超过左侧的范围
        //等号右侧确实是int类型，但是数据值没有超过左侧的范围，就是正确的
        //右侧的数据值不是int--转byte。不是自动类型转换
        byte num1 = /*(byte)*/33;//右侧数据值没有超过左侧的范围，编译器会自动隐含的补充一个(byte)
        System.out.println(num1);//33

        //2、右侧数据值超过了左侧的范围
        // byte num2 = 130;//编译报错

        //3、char
        // 右侧的数据值不是int--转char。不是自动类型转换，没有超出范围
        //编译器将会自动补充上一个隐含的(char)
        char c1 = /*(char)*/97;
        System.out.println(c1);//a

        //4、short
        short a = 1;
        short b = 2;
        short result1 = (short) (a+b);//变量相加，short会自动转为int，进行运算。左侧需要是int，或者强转
        short result2 = 1+2;// 数值相加，在编译期间就已计算完毕，即short result2 = 3;
    }
}