类型转换、常用运算符

​
​

活动地址：CSDN21天学习挑战赛

Java中基本数据类型之间的转换以及注意事项？

boolean类型是不参与基本数据类型之间的转换。

基本数据类型的精度排序【由低到高顺序】

byte short char int long float double
将数据类型精度低的转换成数据类型精度高的----隐式数据类型转换【自动数据类型转换】
隐式数据类型转换【自动数据类型转换】不需要修改程序，直接赋值即可完成。
可以直接赋予具体的数据值，也可以将变量赋值。

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

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

常用运算符

位运算符的用法
位运算：就是将参与运算的数据转换成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，不同为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

测试代码：

package c.s.a;

public class test1 {
    public static void main(String args[]){
        System.out.println("---  +  -  *  /  %   ----");
        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("-------------------");
        System.out.println("--四则混合运算，参数运算的数据类型不是同一类  当参与算数运算的数据类型不是同一类时，他的运算结果的数据类型是精度高的数据类型--");
        byte b=100;
        short s= 200;
        int i=300;
        long l=200L;
        float f=1.5f;
        double d=1.22;
        char c='A';
        System.out.println(b+s-l*d/f+i-c);
        System.out.println("-------------------");
     /*   “++”--- 自动加1
        1.变量++；--【先用后加】
        2.++变量；--【先加后用】
          “--”---- 自动减1
        3.变量--；【先用后减】
        4.--变量；【先减后用】*/

        //1.变量++；--【先用后加】
        int  num3=10;
        System.out.println("变量++=="+(num3++));//10 先用
        System.out.println("num3=="+num3);//11 后加

        //++变量：【先加后用】
        int num4=10;
        System.out.println("++变量=="+(++num4)); //11 先加
        System.out.println("num4=="+num4); //11 后用

        //“--”---- 自动减1
        //变量--；【先用后减】
        int  num5=10;
        System.out.println("变量-- =="+(num5--));//10 先用
        System.out.println("num5=="+num5);//9 后减

        //--变量；【先减后用】
        int num6=10;
        System.out.println("--变量=="+(--num6)); //9 先加
        System.out.println("num6=="+num6); //9 后用
        System.out.println("-------------------------");
        System.out.println("关系运算符:  >  <  >=  <=  ==  != 逻辑运算符 【逻辑或 ||   逻辑与 &&  逻辑反  !】");

//        关系运算符的结果一定是boolean值
        int num7=10;
        int num8=5;
        System.out.println(num7+">"+num8+"="+(num7>num8));
        System.out.println(num7+"<"+num8+"="+(num7>num8));
        System.out.println(num7+">="+num8+"="+(num7>num8));
        System.out.println(num7+"<="+num8+"="+(num7>num8));
        System.out.println(num7+"=="+num8+"="+(num7>num8));
        System.out.println(num7+"!="+num8+"="+(num7>num8));
        //1.逻辑运算符 【逻辑或 ||   逻辑与 &&  逻辑反  !】
        //逻辑运算符的运算值和运算结果一定是boolean
        //逻辑或 ||
        boolean  b1 =((num7+num8)>10) || ((num7-num8)<3) ;
        System.out.println("b1=="+b1);
        //逻辑与 &&
        boolean  b2 =((num7+num8)>10) && ((num7-num8)<3) ;
        System.out.println("b2=="+b2);
        //逻辑反  !
        boolean  b3 =!(((num7+num8)>10) && ((num7-num8)<3)) ;
        System.out.println("b3=="+b3);
        System.out.println("--------------------------");
        //短路或:当运算符号左边的结果为true时候，右边不用计算，结果就一定是true.
        int num9=10;
        //System.out.println(num1/0);
        boolean b4= (num9 < 20) || ((num9/0)>10);
        System.out.println("b4="+b4);

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

        System.out.println("-------------------------");
        //1.& 按位与 相同为1，不同为0。
        int num11=3;
        int num12=-7;
        System.out.println(num11 & num12); // 1
        //2.| 按位或  相同位只要一个为1即为1。
        System.out.println(num11 | num12); // -5
        //3.^ 按位异或  相同位不同则为1，相同则为0。
        System.out.println(num11 ^ num12); // -6
        //4.~取反   0和1全部取反
        System.out.println(~num11); // -4
        //5.<<左移位  2进制整体向左移动指定的位数
        System.out.println(num11 << 2); //
        //6.>>右移位  2进制整体向右移动指定的位数
        System.out.println(num11 >> 2); // 0
        System.out.println(2 << 3);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105