java运算符及解释

运算符分类

package com.zhiyou100;
// 运算符 operator
public class Demo01_Operator {
    public static void main(String[] args){
        /*
         运算符 程序中一种很特殊的符号 连接程序中需要参与运算的变量(前提条件是该变量有值)
         "" '' ; - _ ,
         算术运算符
         赋值运算符
         比较运算符(关系运算符)  数字(整数/小数) 表达式(变量+运算符)
         逻辑运算符   与 &  或|  非!
         位运算符   1个字节 = 8 bit(位)
         三目(元)运算符 : ?
       算术运算符:
         + - * / %  i++  ++1  i自加1  / --i i-- i自减1
        */

        // + 第一个作用:连接变量(变量的类型:基本+引用(String)) 通常情况下进行字符串的拼接
        String name = "张三";
        int age = 20;
        System.out.println(name+age);
        // + 第二个作用:相加运算
        int a = 10;
        int b = 20;
        int c = a+b;
        System.out.println(c);
        int a1 = 15;
        int b1 = 38;
        int c1 = a1+b1;
        System.out.println(c1);
        // + 第三个作用:  正数 >0 (0是自然数，整数)
        int a2 = 10;
        int b2 = +a2;
        System.out.println(b2);

        // - 第一个作用:相减运算
        int a3 = 20;
        int b3 = 10;
        int c3 = a3-b3;
        System.out.println(c3);
        // - 第二个作用:负数 <0
        int a4 = 20;
        int b4 = -20;
        System.out.println(b4);

        // * 重量级 作用:乘法运算
        int a5 = 10;
        int b5 = 20;
        int c5 = a5*b5;
        System.out.println(c5);
        int a6 = 1233;
        int b6 = 2354;
        int c6 = a6*b6;
        System.out.println(c6);
        //  / 作用:除法运算 求商数(保留整数)
        int a7 = 10;
        int b7 = 5;
        int c7 = a7/b7;
        System.out.println(c7);
        //  % 作用:出发运算 求余数(取模)
        int a8 = 13;
        int b8 = 5;
        int c8 = a8%b8;
        System.out.println(c8);
        //  / 正数除以负数
        System.out.println(a7/-b7);
        System.out.println(a8%-b8);
        System.out.println(-a8%-b8);
        // 在除法运算中 商数正负随着除数走,但是商数的正负(只要除数和被除数其中一个为负数即为负数)否则为正数
        // ++ 自加运算符
        int number = 10;
        number += 5;
        System.out.println(number);
        int number2 = 10;
        number2++;//等价于number2 =number2+1 等价于number2 +=1
        System.out.println(number2);
        int number3 = 10;
        //number3++5 ;此时语法不成立
        int plus = 5;
        //number3 = plus++; 等价于 number3 += plus++;
        number3 += plus++;
        // 如果变量在++运算符的左边,那么在运算过程中,先进行++运算符左边的运算,再执行++运算符
        System.out.println(number3);//15
        System.out.println(plus);//6
        // 变量在++运算符的右边
        int num4 = 10;
        int plus2 = 5;
        num4 += ++plus2;
        System.out.println(num4);
        System.out.println(plus2);
        //如果变量在++运算符的右边,那么在运算过程中,先进行++运算,再进行其他运算
        //不管变量是在++运算符的左边还是右边,对于该变量本身都会做自加1运算

        // --自减运算符
        int num5 = 10;
        int reduction = 5;
        // num5 -= reduction--;
        System.out.println(num5);
        --num5;
        System.out.println(num5);




    }
}

赋值运算符

package com.zhiyou100;
// 赋值运算符
public class Demo02_Operator {
    public static void main(String[] args) {
        /*
           赋值运算符:就是给变量赋值(初始化)
           = 等号代表的意思是把等号右边的数据赋值给等号左边的变量
           += 相加赋值 就是该运算符左边的变量相加右边的数据的结果又赋值给运算符左边的变量
           -= 相减赋值 就是该运算符左边的变量相减右边的数据的结果又赋值给运算符左边的变量
           *= 相乘赋值 就是该运算符左边的变量相乘右边的数据的结果又赋值给运算符左边的变量
           /= 相除赋值 就是该运算符左边的变量相除右边的数据的结果又赋值给运算符左边的变量 求商数
           %= 相除赋值 就是该运算符左边的变量相除右边的数据的结果又赋值给运算符左边的变量 求余数
        */
        int a;
        a = 10;
        int a1 = 10;
      /*  a1 = a1 + 10;
      等价于
        a1 +=10;
       */
        a1 += 10;
        System.out.println(a1);
        int b1 = a1 + 10;

        // -= 相减运算
        int a2 = 10;
        /*
          a2 = a2-5;
           等价于
           a2 -= 5;      */
        a2 = a2 - 5;
        System.out.println(a2);
        int b2 = a2 - 5;

        // *= 相乘运算
        int a3 =10 ;
        a3 = a3 * 5;
        //等价于 a3*=5;
        System.out.println(a3);

        // /= 相除运算 求商数
         int a4 = 13;
         a4 = a4 / 5;
         //等价于 a4/=5;
        System.out.println(a4);

        // %= 相除运算 求余数
        int a5 =13;
        a5 %=5;
        //等价于a5 = a5 %5;
        System.out.println(a5);

    }
}

比较运算符

package com.zhiyou100;
// 比较运算符 compare
public class Demo03_Operator {
    public static void main(String[] args) {
        /*
            比较运算符
            >      <      ==      >=        <=       !=
            小于    大于   等于     大于等于    小于等于   不等于

            备注: 1.比较运算符中"等于"符号是"==" 而不是"="
                 2.比较运算符运算的结果就是布尔类型值,要么是true,要么是false
                 3.比较运算符可以连接表达式或者语句
        */
        int a = 10;
        int b = 20;
        System.out.println(a > b);// false
        System.out.println(a < b);// true
        System.out.println(a != b);// true
        System.out.println(a == b);// false
        System.out.println(a >= b);// false
        System.out.println(a <= b);// true
        // 备注: ">=" "<=" 该运算符运算过程中只要满足其中一种情形即为true
        // 比较运算符前后是语句
        System.out.println(a++ > b--);




    }
}

逻辑运算符

package com.zhiyou100;
//逻辑运算符
public class Demo04_Operator {
    public static void main(String[] args) {
        /*
            逻辑运算符  与& 或| 非!
            在程序中,运算的是布尔类型值(可以是具体的true或者false,也可以是布尔类型的表达式)
             */
        boolean bool = true;
        boolean bool2 = false;
        boolean bool3 = bool & bool2;
        System.out.println(bool3);
        //说明: 与运算符 在程序运算过程中,只要有一个false ,结果就是false,否则为true
        //或运算 |
        boolean var01 = true;
        boolean var02 = false;
        boolean var03 = var01|var02;
        System.out.println(var03);
        //说明: 或运算符 在程序运算过程中,只要有一个为true,结果就为false
        // 非运算!
        boolean var04 = false;
        boolean var05 = true;
        boolean var06 = !var04;
        System.out.println(var06);
        //说明: 非运算符，在程序运算过程中,一般只能连接一个布尔类型值,而且非运算符只能放在布尔类型值的左边
        //   结果就是对连接的该布尔类型值取相反结果
        //异或 ^ 异或运算符
        boolean var07 = true;
        boolean var08 = false;
        boolean result = var07^var08;
        System.out.println(result);
        //说明: 异或运算符,在程序中运算中,同为false 异为true
        //  如果异或运算符连接的左右布尔类型变量(表达式)的值相同,结果为false
        //  如果异或运算符连接的左右布尔类型变量(表达式)的值不相同,结果为true
        //备注: 如果和或运算符做对比,不同之处:当左右都为true的时候,结果为false
        //拓展: 与& 或| 非! 异或^
        boolean bool4 = true;
        boolean bool5 = false;
        boolean bool6 = bool4 && bool5;
        System.out.println(bool6);
        //在程序中,与运算符,通常使用双& &&
        //&与&&异同点 : 相同点:都是做与运算,不同点,&&可以实现断路(短路)
        //备注:短路效果,当&&符号左边的布尔类型值可以确定为false的时候
        //那么程序在执行到&&符号的时候,会发生跳跃,也就是&&后面的表达式程序不再执行了
        //或运算符||效果等同于&&,在程序中,通常使用的是"||"
        boolean bool7 = true;
        boolean bool8 = false;
        boolean bool9 = bool7||bool8;
        boolean bool10 = !bool9;
        System.out.println(bool10);
        System.out.println(bool9);
        //备注:||或运算符,在程序运行中,如果||连接的左边的布尔类型为true,那么程序也会发生跳跃,形成短路现象
    }
}

位运算符

package com.zhiyou100;
// 位运算符
public class Demo05_Operator {
    public static void main(String[] args) {
        /*
           位运算符  位
           位 bit 计算机中最小的信息单位为bit(位) 一个bit上存储的是0或者1
           计算机中最小得到存储单位是byte  1byte=8bit
           二进制的运算
           与位运算 &
           或位运算 |
           非位运算 ×
           异或位运算 ^
           移位位运算 >>  右移  << 左移   >>>无符号右移   <<<---》×没有
           十进制  满10进1
           二进制  满2进1
         */
        // 与位运算 &
        int a = 13; //二进制值1101
        int b = 5; //二进制值101
        int c = a & b; //5
        System.out.println(c);
        // 说明 : 在与位运算中，如果参与运算的二进制值中有一个为0,那么运算的结果为0
        // 当前后运算的二进制的长度不一致时,那么程序会在短的那一方补0,短几位就补几个0
        // 或位运算符  | 参照逻辑运算符中的规律 有一个为1 结果即为1
        int a1 = 28; //二进制 011100
        int b1 = 36; // 二进制 100100
        int c1 = a1|b1;// 二进制 111100   十进制  60
        System.out.println(c1);
        //异或位运算符 ^ 参照逻辑运算符中异或的规律:同位0 异位1
        int a2 = 123; //01111011
        int b2 = 134; //10000110
        int c2 = a2^b2;//11111101
        System.out.println(c2);


    }
}

三目运算符

package com.zhiyou100;
// 三目运算符 ?:
public class Demo06_Operator {
    public static void main(String[] args) {
        /*
           三目运算符 ? :
           语法格式:
                布尔类型值(表达式)? 该布尔类型值的真的结果值:
                结果值要依据布尔类型表达式,当表达式为真,结果就是紧邻问号"?"后面的结果值
                当表达式为假的时候,结果就是冒号":" 后面的结果值

         */

        // 第一种用法: 直接在输出语句使用
        int a = 10;
        int b = 20;
        System.out.println(a > b ? "a > b?":"a < b √");
        System.out.println(a < b ? true : false );
        System.out.println(a<=b ? "a < b √":false);
        System.out.println(a>=b ? a:b);  //20=b
        // 第二种用法: 在语句中使用(不是输出语句) 赋值运算中
        int c =  a > b ? a : b;//获取的是a ,b 的最大值
        String d =  a > b ? "是真的吗？":"你是假的!";
        System.out.println(d);
        // 说明:如果三目运算符是在输出语句中,那么对三目运算符的结果值真假的数据类型不要求
        // 如果不是在输出语句中, 在其他的语句中,如赋值运算语句,那么就需要严格控制三目运算符的结果值真假的数据类型
        // 真假的结果值类型要一致,保持和赋值运算中的变量的数据类型一致.
    }
}