java基本语法＜2＞——数据类型转换，运算符

1.数据类型转换

1>.自动类型转换（隐式）

        ❶特点：代码不需要经过特殊处理，自动完成。

        ❷规则：要求数据范围从小到大转换

  ▨注意：什么是从小范围变成大范围？——等号的左边是大范围，等号右边是小范围，因为等号是“赋值”的意思，比如a=x，意思是把x赋值给a，同理 大范围变量名=小范围变量的数据 就是把小范围变量数据变成大范围；别弄混了！

public class ZiDongZhuanHuan{
    public static void main(String[] args){
        int a=23L;
        System.out.println(a);//这个是把long给int，是大变小，不可以；出错
        
    ☑  long b=23;
        System.out.println(b);   //这个是把int型赋值给long，所以这个是小变大

        long c=9999999999;
        System.out.println(c); //这个会出错，你这个超过了int型

        int d=999999999L;
        Systerm.out.println(d);  //这个会出错

    }
}

2>.强制类型转换(显式)

        ❶特点：代码需要进行特殊的格式处理，不能自动完成。

        ❷格式：范围小的类型  范围小的类型名=（范围小的类型）原本范围大的数据；

                        例： int a=(int)1223L;

                                int a=(int)(m+n);(不能产生歧义，产生时，注意加括号)

public class QiangZhi{
    public static void main(String[] args){
    
    ☑int a=(int)100L;
    System.out.println(a);  //这个是范本,打印出100

    
    int b=(int)99999999999L;  
    System.out.println(b);        //这个不会显示错误，但是结果为-727379969
                                //这个是数据溢出的现象

    int c=(int)3.99;
    System.out.println(c);    //这个不会显示错误，但是结果为3
                             //这个是降低数据的精确度，但是不是四舍五入！是直接去小数点

    char d=A;
    System.out.println(d+1);    //这个会打印出来“66” 因为首先他会转化换成int型，变成65                                        
                                   （来源于ASCII）然后变成66

    byte x=3;
    byte y=4;
    byte z=x+y;
    System.out.println(z);       //结果显示错误，因为数学运算时，首先换成了int型，            
                                  3+4=7，虽然没有超过byte的范围，但是是int变成了byte， 
                                   属于强制转换，所以其格式不正确。

    byte x=3;
    byte y=4;
    int z=x+y     //正确显示7；这里也可以写成byte z=(byte)(x+y)"注意这里括号别拉下！"
    System.out.println(z);


    byte m=3；
    char n=A;
    int q=m+n;
    System.out.println(q);      //正确显示68  不管是这三类怎么做运算，最后都会变成int
}

}

▨注意事项：1.强制类型转换一般不推荐使用，因为可能会出现精度损失、数据溢出的现象； 

                     2. byte/short/char 这三个数据类型都可以进行数学运算，如加法

                     3.byte/short/char 这三个数据进行数学运算的时候都会首先变成int 型，然后再计算

                     4.boolean类型不可以发生类型转换！

                     5.byte/short/char这三类数据进行强制类型转换时，如果右面的数据还在左面的范围之内，那系统也不会报错，他会自动的加上小括号，进行自动的隐含性强制类型转换；(但是注意自动的转换也仅限于右面是常量类型)

比如short a=12；12默认是int型，int—>short属于强制类型转换，但是你的代码并没有写成short a=(short)12，这时系统会自动加上括号，但是仅限于这三个类型！其余的会报错

public class ZhuanHuan{
    public static void main(String[] args){
        short a=2;    //自动的强制类型转换
        short b=3;
        short c=a+b;  //这种代码出现会出现报错，这个虽然也属于int到short，但是右面是变量形式！
        short d=2+3;    //这个就是正确的写法，这个右面是常量，可以自动转换
        short e=2+3+a    //报错，只要有变量就不行！   
 }
}

---

---

2.算术运算符

1>.运算符：进行特定操作的符号。例如：+

2>.表达式：用运算符连起来的式子叫做表达式。例如：2+76；a+b；

3>.算术运算符：加“+”；减“-”；乘“*”；除“/”；取模“%”；自行运算“++”“--”

▨注意：

             1.对于除法“/”，注意结果的数据类型，如果不能整除的话，就写成商和余数的形式，然后再取商的部分；例如“3/2=1”       

            2.注意乘除法的写法；       

            3.一旦运算中存在不同类型的时候，结果的类型和范围较大的类型一致！（电脑实际的操作是先把小类型自动转换成大类型，然后进行运算）  

public class SuanShuYunSuan{
    public static void main(String[] args){
        int a=5;
        float b=2.5;
        System.out.println(a/b);
    }
}                        //结果2.0，因为float的范围比较大，所以结果也是float型
                        //int——>float；——>float/float

---

 四则运算中加号“+”三种常见的用法 ：

        1.对于数值来说，即为正常的加法；

     ▧   2.对于字符char类型来说，在计算之前，char类型会变成int型，然后再计算 ；利用ASCII表对照；

     ▧   3. 对于字符串String来说，加号代表字符串连接操作，任何数据类型和字符串连接都会变成字符串。（任何类型+String字符串···===>字符串）

public class JiaFaZiFuChuan{
    pubilc static void main(String[] args){

         String a="Hello";
         System.out.println(a);    //打印出来是 Hello

         System.out.println(a+"world");    //打印出来是 Helloworld
        
         System.out.println(a+20);         //打印出来 Hello20
    
//下面是注意优先级！

         System.out.println(a+20+30);      //打印出来Hello2030，不是Hello50！
         
         System.out.println(a+(20+30));     //打印Hello50

         System.out.println(20+30+a);        //打印出来Hello50

         System.out.println(20+3.9+a);        //打印出来23.9Hello
 }
}

自增自减运算：

                格式：自增运算：“++”；自减运算“--”

        ❶基本含义：让一个变量涨1或者降1；常量不可以使用！

        ❷使用格式：在变量名之前，即++i；在变量名之后，i++；

        ❸使用方法：1.单独使用：不和其他任何操作混合，自己独立成为一个步骤；

                             2.混合使用：和其他操作混合，例如与赋值混合，或者与打印操作混合等

                使用区别：1.单独使用时，"i++"  <=>  "++i"

                                  2.混合使用时：   

                                  ▧A.对于【++i】，那么变量【立刻+1】，然后拿着结果使用                                                    ▧B.对于【i++】，那么首先使用变量本来的值，【然后再让变量+1】  

public class QiangZhi{
	public static void main (String[] args){

//单独使用的，即单独成行
	int a=1;
	int b=1;
	a++;
	++b;
	System.out.println(a);    //打印2
	System.out.println(b);    //打印2  这里单独使用时i++=++i
	
//混合使用时，i++是先使用再加；++i是先加再使用
  //赋值运算中
	int c=1;
    int f=1;
	int d;
	int e;
	d=c++;
	e=++f;
	System.out.println(d);    //d=c++是先使用再加；即d=c原=1
	System.out.println(c);    //这里已经完成了c++，所以变成2
    System.out.println(e);    //e=++f，是结果先加后运算，所以e=f后=2
 
  //打印运行时	
    int x=1;
    System.out.println(++x);    //打印出2
    System.out.println(x);      //打印2
    
    int y=1;
    System.out.println(y++);    //打印出y原1，然后y变成了2
    System.out.println(y);      //这里就是2了
}
}

---

---

赋值运算符

       ❶基本赋值运算符：就是一个等号“=”，代表将右侧的数据交给左边的变量；

       ❷复合赋值运算符：

＋＝	a+=1	相当于	a=a+1
－＝	a-=1	相当于	a=a-1
＊＝	a*=1	相当于	a=a*1
/ =	a/=1	相当于	a=a/1
％=	a%=1	相当于	a=a%1

注意事项：1.只有变量才能使用赋值运算符，常量不能进行；

                  2.复合赋值运算其中隐含了一个强制类型转换；比如

public class a{
    public static void main(String[] args){
        byte a=30;
        System.out.println(++a);    
/*这里就是同上强制类型转换，byte/short/char进行数学运算时，都是强制转换成int*/
    }
}

---

---

比较运算符——true or false

比较运算符
==	比较符号两边的数据是否相等，相等的结果是true
<	比较符号的数据是否小于右边的数据，如果小于，结果是true
>	比较符号的数据是否大于右边的数据，如果大于，结果是true
<=	、、、、、是否小于等于、、、、、
>=	、、、、、是否大于等于、、、、、
!=	不等于符号，如果符号两边的数据不相等，结果为true

▲比较运算符，是两个数据之间进行比较，运算结果是布尔值true或者false；

注意事项：

        1.比较运算符的结果一定是一个Boolean值，成立就是true，不成立就是false；

        2.如果进行多次判断，不能连着写；就是说不可以写成【1<2<3】这样的形式；

public class BiJiao{
    public static void main(String[] args){
        int a=1;
        int b=4;
        System.out.println(a>b);    //结果false
        System.out.println(a>11);    //false
        System.out.println(a!=b);    //true
        System.out.println(a==1);    //true
        System.out.println(0<a<2);    //不能打印，写法错误，报错
    }
}

---

---

逻辑运算符——true or false

与（并且）	&&	一错则错
或（或者）	||	一对则对
非（取反）	！	对错互换

注意：&和&&的区别：

&：这个是让两者换成二进制,然后按照“一0则0”的理念进行运算；最后的结果是一个二进制的数

&&：这个是看两边的数据的真伪，按照“一假则假”的理念进行输出，最后的结果是布尔类型，不是“true”就是“”“false”

public class FuZhi{
	public static void main(String[] args){
	  int a=2;
	  int b=6;
	  System.out.println(a&b);  //结果是“2”就是“0010”，因为“0010&0110——>0010”
	  System.out.println(a>2&&b<8); //结果是false，因为a>2是假，所以结果为false
	  System.out.println(a&&b);//报错，这个没有办法判断&&两边的是真是假。
    
      System.out.println(!a>2);//结果为true，因为a>2为假，取反为真；
      
      System.out.println(a>2||b<8);//结果为true，因为b<8是真，所以为真
    }
}

★★★★★注意：逻辑运算“与&&”、“或||”都有“短路效果”，就是说当可以根据左边来判断最终结果的时候，是不需要执行右边的条件的

注意：

1，逻辑运算只能用于Boolean值。

2.与、或需要左右各自有一个Boolean值，但是取反的时候有一个即可。

3.与、或两种运算符，如果多个条件，可以连续写!(比较运算是不可以的，即不可以1<2<3)

        两个条件：A&&B        三个条件：A&&B&&C

        因此，对于1<x<3的情况，应该拆成两个部分，然后用&&连接起来（x>1&&x<3）

---

---

 三元运算符

一元运算：只需要一个数据就可以进行操作的运算。例：！++ --

二元运算：需要两个数据····

三元运算符：需要三个数据才能进行的操作

格式：        数据类型 变量名称=条件判断？表达式A：表达式B；

解释：首先判断条件是否成立；如果条件成立，就把A赋值给变量；如果条件不成立，就把B赋值给变量；二者选其一。

注意：1.必须同时保证表达式A和表达式B都符合左侧的数据类型

           2. 三元运算符结果必须被使用

---

---

补充：

1.按位异或：

 2.左右移动和关于2的乘除法相比，左右移动的效率更高

 

 

 

3.>>>和>>的区别