JAVA 基础-3

数据类型转换、运算符、表达式

3.1.Java中基本数据类型之间的转换以及注意事项？
      1.boolean类型是不参与基本数据类型之间的转换。
      2.基本数据类型的精度排序【由低到高顺序】
            byte short char int long float double
      3.将数据类型精度低的转换成数据类型精度高的----隐式数据类型转换【自动数据类型转换】
            隐式数据类型转换【自动数据类型转换】不需要修改程序，直接赋值即可完成。
            可以直接赋予具体的数据值，也可以将变量赋值。
            例如：int—>doubole [隐式数据类型转换【自动数据类型转换】]

public  class DataTypeSwitch1{
    
    
	public static void main(String args[]){
    
    
		//int--->doubole [隐式数据类型转换【自动数据类型转换】]
		//直接赋予具体的数据值
		double doublevalue = 100;
		System.out.println("doublevalue=="+doublevalue);
		//可以将变量赋值
		int intnum=300;
        double doublevalue2=intnum;
		System.out.println("doublevalue2=="+doublevalue2);
        }
}

      4.将数据类型精度高的转换成数据类型精度低的–显式数据类型转换【强制数据类型转换】
            显式数据类型转换【强制数据类型转换】需要修改程序。
            格式：低精度数据类型 变量名称 = (精度低数据类型)精度高的数据值【变量】;
            例如：double—>int[显式数据类型转换【强制数据类型转换】]

public  class DataTypeSwitch2{
    
    
	public static void main(String args[]){
    
    
		//double--->int[显式数据类型转换【强制数据类型转换】]
        //格式：低精度数据类型  变量名称 =  (精度低数据类型)精度高的数据值【变量】;
		//将小数转换成整数不会“四舍五入”，而是直接舍弃小数部分
		int intnum1=(int)12.8;
		System.out.println("intnum1=="+intnum1);
		double doublevalue=12.8d;
        int  value=(int)doublevalue;
		System.out.println("value="+value);
        }
}

      5.char与int的转换
            char的取值范围就是整数
            1.char---->int [[隐式数据类型转换【自动数据类型转换】]]
            2.int---->char[[显式数据类型转换【强制数据类型转换】]]
            例如：

public  class CharAndInt{
    
    
	public static void main(String args[]){
    
    
		//char的取值范围就是整数
		//1.char---->int [[隐式数据类型转换【自动数据类型转换】]]
		char chatvalue1='好';
        int intvalue1=chatvalue1; //隐式数据类型转换
        System.out.println("intvalue1="+intvalue1);//intvalue1=22909
		//2.int---->char[[显式数据类型转换【强制数据类型转换】]]
		int intvalue2=22909;
        char charvalue2=(char)intvalue2;//显式数据类型转换
		System.out.println("charvalue2="+charvalue2);
        }
}

      6.int转换成byte
      当整数超过取值范围以后，会从最小值向前推进计算。

public  class IntToByte{
    
    
	public static void main(String args[]){
    
    
		byte  bytevalue=(byte)300;
		System.out.println("bytevalue="+bytevalue);
		byte  bytevalue1=127;
		byte  bytevalue2=(byte)(bytevalue1+1);
		System.out.println("bytevalue2="+bytevalue2);
         }
}

3.2赋值运算符与赋值表达式的说明和用法
      赋值运算符:”=”
      例如:int num = 100;
3.3.算术运算符与算术表达式的说明和用法
      算术运算符：+ - * / %【求余】 ++【自动加1】 --【自动减1】
      例如：

public class SuanShu{
    
    
	public static  void  main(String args[]){
    
    
		//+  -  *  /  % 
		int num1=10;
		int num2=3;
		System.out.println(num1+"+"+num2+"="+(num1+num2));
		System.out.println(num1+"-"+num2+"="+(num1-num2));
		System.out.println(num1+"*"+num2+"="+(num1*num2));
		//当参数算术运算的数据是整数时，运算结果就是整数
		System.out.println(num1+"/"+num2+"="+(num1/num2));
		System.out.println(num1+"%"+num2+"="+(num1%num2));
	}
}

public class SuanShu2{
    
    
	public static  void  main(String args[]){
    
    
		//四则混合运算，参数运算的数据类型不是同一类
		//当参与算术运算的数据类型不是同一类时，
		//它的运算结果的数据类型是精度最高的数据类型
        byte b=100;
		short  s=200;
		int i=300;
        long l=400L;
        float f=3.14f;
        double d=2.7;
        char  c='A';
		//-1545.5599853515625----double
        System.out.println(b+s-i*l/c+f);
	}
}

3.4”++”与”–”的具体用法
      “++”— 自动加1
      1.变量++；–【先用后加】
      2.++变量；–【先加后用】
      “–”---- 自动减1
      3.变量–；【先用后减】
      4.–变量；【先减后用】
      例如：

public class SuanShu3{
    
    
	public static  void  main(String args[]){
    
    
		//“++”--- 自动加1
		//1.变量++；--【先用后加】
        int  num1=10;
        System.out.println("变量++=="+(num1++));//10 先用
        System.out.println("num1=="+num1);//11 后加
        
		//2.++变量；--【先加后用】
		System.out.println("++变量=="+(++num1));//12 先加
        System.out.println("num1=="+num1);//12 后用
        
		//“--”---- 自动减1
		//3.变量--；【先用后减】
		int num2=10;
		System.out.println("变量--=="+(num2--));//10 先用
		System.out.println("num1=="+num2);//9 后减
		
		//4.--变量；【先减后用】
        System.out.println("--变量=="+(--num2));//8 先减
		System.out.println("num1=="+num2);//8 后用
		//每做完一次运算会将运算结果自动赋值给所使用的变量;
	}
}

3.5关系运算符与关系表达式的说明和用法
      关系运算符: > < >= <= == !=

public class GuanXi{
    
    
	public static  void  main(String args[]){
    
    
		//关系运算符:  >  <  >=  <=  ==  !=
		//关系运算符的结果一定是boolean值
		int  num1=10;
        int  num2=3;
		System.out.println(num1+" > "+num2+"="+(num1>num2));
		System.out.println(num1+" < "+num2+"="+(num1<num2));
		System.out.println(num1+" >= "+num2+"="+(num1>=num2));
		System.out.println(num1+" <= "+num2+"="+(num1<=num2));
		System.out.println(num1+" == "+num2+"="+(num1==num2));
		System.out.println(num1+" != "+num2+"="+(num1!=num2));
	}
}

3.6逻辑运算符与逻辑表达式的说明和用法
      逻辑运算符被分成2大类:
      1.逻辑运算符 【逻辑或 || 逻辑与 && 逻辑反 !】
      例如：

public class LuoJi1{
    
    
	public static  void  main(String args[]){
    
    
		//1.逻辑运算符 【逻辑或 ||   逻辑与 &&  逻辑反  !】
		//逻辑运算符的运算值和运算结果一定是boolean
		int  num1=10;
        int  num2=3;
		//逻辑或 ||
        boolean  b1 =((num1+num2)>10) || ((num1-num2)<3) ;
		System.out.println("b1=="+b1);
		//逻辑与 &&
		boolean  b2 =((num1+num2)>10) && ((num1-num2)<3) ;
		System.out.println("b2=="+b2);
		//逻辑反  !
		boolean  b3 =!(((num1+num2)>10) && ((num1-num2)<3)) ;
		System.out.println("b3=="+b3);
	}
}

      2.位运算符
      位运算：就是将参与运算的数据转换成2进制【0101001】
      10进制与2进制的转换 ： 8421码
      1 原码
            原码就是符号位加上真值的绝对值, 即用第一位表示符号, 其余位表示值.
      2. 反码
      反码的表示方法是:
            正数的反码是其本身【原码】
            负数的反码是在其原码的基础上, 符号位不变，其余各个位取反.
      3. 补码
      补码的表示方法是:
            正数的补码就是其本身【原码】
            负数的补码是在其原码的基础上, 符号位不变, 其余各位取反, 最后+1. (即在反码的基础上+1)
            整数的2进制就是源码
            负数的2进制实质上是用补码表示。
             -3 – 10000011—11111100—11111101----【负数的原码取反+1】{符号位不变}
             -3–3—00000011–11111100—11111101 —【负数的绝对值的原码的取反+1】
             -7–7--00000111—11111000----11111001
             -12–12–00001100—11110011—11110100

常见的6种位运算符号
      1.& 按位与 相同1为1，不同为0。
      例如：3 & -7
             0000 0011 3
             1111 1001 -7
             0000 0001 1
      2.| 按位或 相同位只要一个为1即为1。
      例如：3 | -7
            0000 0011 3
            1111 1001 -7
             1111 1011 -5
      3.^ 按位异或 相同位不同则为1，相同则为0。
       例如：3 | -7
            0000 0011 3
            1111 1001 -7
             1111 1010 -6
      4.~取反 0和1全部取反
       例如：~3
            0000 0011 3
             1111 1100 — 1111 1011 – 1000 0100 -4
      5.<<左移位 2进制整体向左移动指定的位数
       例如 : 3 << 2
                  0000 0011 3
                  0000 0110 移动1位
                  0000 1100 移动2位 — 12
      6.>>右移 2进制整体向右移动指定的位数
       例如 : 3 >> 2
            0000 0011 3
            0000 0001 移动1位
            0000 0000 移动2位 — 0
      例如：

public class LuoJi3{
    
    
	public static  void  main(String args[]){
    
    
		int num1=3;
		int num2=-7;
		//1.& 按位与 相同1为1，不同为0。
		System.out.println(num1 & num2); // 1
		//2.| 按位或  相同位只要一个为1即为1。
		System.out.println(num1 | num2); // -5
		//3.^ 按位异或  相同位不同则为1，相同则为0。
		System.out.println(num1 ^ num2); // -6 
		//4.~取反   0和1全部取反
		System.out.println(~num1); // -4
		//5.<<左移位  2进制整体向左移动指定的位数
		System.out.println(num1 << 2); //
		//6.>>右移位  2进制整体向右移动指定的位数
		System.out.println(num1 >> 2); // 0
		System.out.println(2 << 3); 
	}	
}

      当我们学习完运算符以后，变量和运算符会组成一个运算的表达式，这个运算表达式中的变量的数据类型可能不同，那么这个运算表达式的结果使用什么类型的变量来保存。
这个运算表达式的结果使用参与运算的变量中数据类型精度最高的为标准。

public  class  Test{
    
    
	public  static  void  main(String  args[]){
    
    
		byte  by1=120;
        short sh1=220;
		int  int1=1000;
        long  long1=10000L;
		float  flo1=12.5f;
		double  dou1=12.5;
		char  ch1='A';
		float  val=by1+sh1+int1+long1+flo1+ch1;
		System.out.println("val=="+val);
	}
}

3.7短路与和短路或
      短路或–逻辑或的运算规则
            【运算符号左右两边都是false的时候，运算结果就一定是false,如果出现一个true,运算结果就一定是true】
      短路或—短路就是运算符号只运算一边
            当运算符号左边的结果为true时候，右边不用计算，结果就一定是true.

      短路与–逻辑与的运算规则
            【运算符号左右两边都是true的时候，运算结果就一定是true,如果出现一个false,运算结果就一定是false】
      短路与—短路就是运算符号只运算一边
            当运算符号左边的结果为false时候，右边不用计算，结果就一定是false.

      例如：

public class LuoJi2{
    
    
	public static  void  main(String args[]){
    
    
		//短路或:当运算符号左边的结果为true时候，右边不用计算，结果就一定是true.
		int num1=10;
		//System.out.println(num1/0);
        boolean b1= (num1 < 20) || ((num1/0)>10);
		System.out.println("b1="+b1);

		//短路与:当运算符号左边的结果为false时候，右边不用计算，结果就一定是false
		int num2=100;
        boolean b2= (num2 < 20) && ((num2/0)>10);
		System.out.println("b2="+b2);
	}
}

运算符号的优先级

运算符	结合性
[].()(方法调用)	从左到右
！~ ++ -- +(一元运算) -(一元运算)	从右到左
* / %	从左到右
+ -	从左到右
<<    >>    >>>	从左到右
<  <=  >  >=instanceof	从左到右
==  !=	从左到右
&	从左到右
^	从左到右
|	从左到右
&&	从左到右
||	从左到右
?:	从右到左
=	从右到左

      面试题:
      1.最有效率的方法算出2乘以8等於几? 2<<3； 表示2 向左移3位
            16      8      4      2      1 [8421码]
      2.下面代码运行后，e变量的值是多少？ e= =10;
            int a =1,b=2; int e = ++a + ++a + b++ + b++;
                                                2         3    2        3
      3. System.out.println(“10/3==”+(10/3)); 运算结果 3
      //两个无具体数据类型接收的整数，进行运算所得结果默认为int类型
      4.short s1 = 1; s1 = s1 + 1;有错吗? 有错
      //s1为short类型，1默认为int类型；不同的数据类型之间做运算，结果默认为精度高的那个；
      //所以s1+1的结果属于int类型
      //int类型精度高于short类型，且int类型为4个字节；而short类型为2个字节；
      //显然用short类型的s1直接来接收int类型的（s1+1）是错误的；
      //改正short s1 = 1; s1 = (short)(s1 + 1);