算术运算符
开始下回分解

示范如下：

 int a = 10;
 int b = 20;
 System.out.println("a == b = " + (a == b) );
 System.out.println("a != b = " + (a != b) );
 System.out.println("a > b = " + (a > b) );
 System.out.println("a < b = " + (a < b) );
 System.out.println("b >= a = " + (b >= a) );
 System.out.println("b <= a = " + (b <= a) );

结果如下：

a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false

关系运算符
无法复制加载中的内容
示范如下：

int al = 10;
int bl = 20;
// == 两个变量相等 值为真
boolean cl = al==bl; // false
// != 两个变量不相等 值为真，否则为假
boolean c2 = al!=bl; // true
// 左边的变量是否大于右边的变量，大于值为真，否则为假
boolean c3 = al>bl; // false
// 左边的变量是否小于右边的变量，小于值为真，否则为假
boolean c4 = al<bl; // true
// 左边的变量是否大于等于右边的变量，大于等于值为真，否则为假
boolean c5 = al>=bl; // true
// 左边的变量是否小于等于右边的变量，小于等于值为真，否则为假
boolean c6 = al<=bl; // true

System.out.println(cl+"-"+c2); //false - true
System.out.println(c3+"-"+c4);
System.out.println(c5+"-"+c6);

位运算
无法复制加载中的内容
位运算这里稍微复杂一些，涉及到进制转换
原码、反码、补码
网上对原码、反码、补码的解释过于复杂，这里引用韩老师精简的几句话（这几点一定要背的滚瓜烂熟-基本功）
对于有符号的而言

二进制的最高位是符号位：0表示正数，1表示负数（口诀 0->0 , 1->-1）
正数的原码、反码、补码都一样（三码合一）
负数的反码 = 它的原码符号位不变，其他位取反（0->1 ，1->0）
负数的补码 = 它的反码 + 1，负数的反码 = 负数的补码 - 1
0的反码、补码都是0
java没有无符号数，换文言之，java中的数都是有符号的
在计算机运算的时候，都是以补码的方式来运算的
当我们看运算结果的时候，要看它的原码（重点）
// 位运算 & | ^ ~
// 进制之间的转化
int x = 10;// 00001010
int y = 8;// 00001000
int xy = x&y;

过程如下：
无法复制加载中的内容
具体案例
案例一：c = x&y c的结果？ (c = 100 & 50)
先试着自己推算出结果在查看具体的过程

int x = 100;
int y = 50;
/**
 *  1. c = x&y  c的结果？ (c = 100 & 50)
 *推导过程
 * 1. 得到 它的补码 => （要得到补码就要现有原码）
 *    100的原码 00000000 00000000 01100100 （正数三码合一）
 *    100的补码 00000000 00000000 01100100
 * 2. 50的原码  00000000 00000000 00110010 （正数三码合一）
 *    50的补码  00000000 00000000 00110010
 * 3. 按位 &
 *    00000000 00000000 01100100
 *    00000000 00000000 00110010
 *    00000000 00000000 00100000 & 运算后的补码
 *    运算后的原码是 00000000 00000000 00100000 （正数三码合一）
 *    结果是 32
 */
int c = x&y;
System.out.println("1. c = x&y 中 c 的结果是："+c); //32


        // >> 右移 将二进制位右移指定位数
        int move = 20 ;
        int ret = move >> 2;
        System.out.println(ret);

        //00000000 00000000 00010100 //20的二进制
        //00000000 00000000 0000 1010 // 向右引动一位
        //00000000 00000000 0000 0101 // 向右引动二位

案例二：2. d = c|y  d的结果？ (c = 32 | y = 50)

/**
 * 2. d = c|y  d的结果？ (c = 32 | y = 50)
 * 1. 得到 它的补码 => （要得到补码就先要有原码）
 *    32的原码 00000000 00000000 00100000 （正数三码合一）
 *    32的补码 00000000 00000000 00100000
 * 2. 50的原码  00000000 00000000 00110010 （正数三码合一）
 *    50的补码  00000000 00000000 00110010
 * 3. 位运算 |
 *      00000000 00000000 00100000
 *      00000000 00000000 00110010
 *      00000000 00000000 00110010 | 运算后的补码
 *      运算后的原码是 00000000 00000000 00110010 （正数三码合一）
 *      结果是 50
 */
int d = c|y;
System.out.println("2. d = c|y 中 d 的结果是："+d);//50

案例三：d = c^d d 的结果? (c=32 ^ d=50)

   /**
         * 3. d = c^d  d 的结果? (c=32 ^ d=50)
         * 1.得到 它的补码 => （要得到补码就先要有原码）
         *    32的原码 00000000 00000000 00100000 （正数三码合一）
         *    32的补码 00000000 00000000 00100000
         * 2. 50的原码  00000000 00000000 00110010 （正数三码合一）
         *    50的补码  00000000 00000000 00110010
         * 3. 位运算 ^
         *      00000000 00000000 00100000
         *      00000000 00000000 00110010
         *      00000000 00000000 00010010 ^ 运算后的补码
         *      运算后的原码是 00000000 00000000 00010010 (正数三码合一）
         *      结果是 18
         */
//        int c = 32;
//        int d = 50;
//        int g = c^d;
//        System.out.println("3. d = c^d 中 d的结果是 "+g);//18

案例四：4. d = ~c d的结果？（c ~ 32）

     /**
         *  4. d = ~c   d的结果？ （c ~ 32）
         * 1.得到 它的补码 => （要得到补码就先要有原码）
         *    32的原码 00000000 00000000 00100000 （正数三码合一）
         *    32的补码 00000000 00000000 00100000
         *
         * 2. 按位 ~ 操作
         *      00000000 00000000 00100000
         *      11111111 11111111 11011111 ~ 运算后的补码 （由于是负数，需要算出原码）
         * 3. 运算后的反码 11111111 11111111 1101 1110 （负数反码 = 负数补码 - 1）
         * 4. 运算后的原码 10000000 00000000 00100001
         *  11100010
         *结果是 -33
         */
//        int c = 32;
//        int d = ~c;
//        System.out.println("4. d = ~c  中 d 的结果？"+ d );

案例五：5. cc = ((x&y) & (x|y)) cc的结果? (cc = ((100&50) & (100|50)))
此案例稍微复杂一些，没有什么难度，重点是细心，一个一个算出结果就好（粗中有细）
提示：主要是分成三部分运算

   /**
         * 5. cc = ((x&y) & (x|y)) cc的结果? (cc = ((100&50) & (100|50)))
         * 一、 得到 100 & 50
         * 1. 得到 它的补码 => （要的到补码就要有原码）
         *    100的原码 00000000 00000000 01100100 （正数三码合一）
         *    100的补码 00000000 00000000 01100100
         * 2. 50的原码  00000000 00000000 00110010 （正数三码合一）
         *    50的补码  00000000 00000000 00110010
         * 3. 安位 & 操作
         *      00000000 00000000 01100100
         *      00000000 00000000 00110010
         *      00000000 00000000 00100000 & 运算后的补码
         *  4.运算后的原码是  00000000 00000000 00100000 （正数三码合一）
         *  结果是 32
         *
         *  二、 得到 100 | 50
         * 1. 得到 它的补码 => （要的到补码就要有原码）
         *    100的原码 00000000 00000000 01100100 （正数三码合一）
         *    100的补码 00000000 00000000 01100100
         * 2. 50的原码  00000000 00000000 00110010 （正数三码合一）
         *    50的补码  00000000 00000000 00110010
         * 3. 安位 | 操作
         *      00000000 00000000 01100100
         *      00000000 00000000 00110010
         *      00000000 00000000 01110110 | 运算后的补码
         * 4.运算后的原码是  00000000 00000000 01110110
         * 结果是 118
         *
         * 三、得到 32 & 118
         * 1. 得到 它的补码 => （要的到补码就要有原码）
         *    32的原码 00000000 00000000 00100000
         *    32的补码 00000000 00000000 00100000 （正数三码合一）
         * 2. 118的原码 00000000 00000000 01110110
         *    118的补码 00000000 00000000 01110110
         * 3. 安位 & 操作
         *      00000000 00000000 00100000
         *      00000000 00000000 01110110
         *      00000000 00000000 00100000 & 运算后的补码
         *  4.运算后的原码是  00000000 00000000 00100000
         *  结果是 32
         */
//        int cc = ((x&y) & (x|y));
//        System.out.println("5.cc = ((x&y) & (x|y))的结果是："+cc);

案例六：

//推导
// ~-2
// 1. 先得到 -2的原码 10000000 00000000 00000000 00000010
// 2. 2的反码 11111111 11111111 11111111 11111101
// 3. 2的补码 11111111 11111111 11111111 11111110
//    取反操作 ~ 00000000 00000000 00000000 00000001
// 4. 运算后的原码 就是 00000000 00000000 00000000 00000001
// 结果是 1
//

赋值运算符
无法复制加载中的内容

int abc = 100%3;
int abc1 = 0;
abc1 += 10; // abc1+10
abc1 -= 20;// abc1-20
abc1 /= 5;// abc1/5
abc1 %=1;// abc1%1
abc1 <<=1;// abc1<<1
abc1 >>=1;// abc1>>1

三元运算符
int ca = abc1 >10 ? 1 : 2;

相当于if-else ，如果为真执行冒号左边这一个，为假则执行冒号右边

判断 instanceof 对象 instanceof 类

Object v1 = new Var();
if (v1 instanceof Var){
    System.out.println("yes");
}else {
    System.out.println("no");
}

java运算符优先级
无法复制加载中的内容
案例一：

        int a = 2;
        int b = 2;
        int c = a * ++b - a-- << (b = a * 2);//6
//        这里是两个表达式 不是一个

案例二：

int a = 2;
int b = 2;
int c = a * ++b - a-- << (b = a * 2); //16
//这里是两个表达式，后面括号不影响后面的
System.out.println(c);
// 2 * 3 = 6 - 1 -> 5
// 5<<2

今天学习结束啦✿✿ヽ(°▽°)ノ✿
有什么问题欢迎大家提出来，一起进步

世界灿烂盛大，欢迎回家 —— 《全球高考》

3-「季淳卿」 运算符+原码、反码、补码

算术运算符 开始下回分解 示范如下：

3-「季淳卿」运算符+原码、反码、补码

算术运算符
开始下回分解

示范如下：