算术运算符：

package com.zhiyou100;

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

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

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

        // * 重量级 作用：乘法运算
        int a5 = 10;
        int b5 = 20;
        int c5 = a5*b5;
        System.out.println(c5);

        // / 作用：除法运算
        int a6 = 13;
        int b6 = 5;
        int c6 = a6/b6;
        System.out.println(c6);

        // % 作用：求余数（取模）
        int a7 = 13;
        int b7 = 5;
        int c7 = 13%5;
        System.out.println(c7);
        // / 正数 除以 负数
        System.out.println(a7 / (-b7));
        System.out.println(a7 % (-b7));
        //在除法运算中·，余数的正负随着被除数走，但是商的正负（只要除数和被除数其中有且仅有一个为负数即为负数），否则为正数

        // ++ 自加1
        int number = 10;
        number += 5;
        System.out.println("number="+ number);
        int number2 = 10;
        number2++;
        System.out.println("number2="+ number2);

        int num3 = 10;
        int plus = 5;
        num3 += plus++;
        //如果变量在++运算符左边，那么在运算过程中，先进行++运算符左边的运算，在执行++运算
        System.out.println(plus);// 6
        System.out.println(num3);// 15
        //变量在++运算符的右边
        int num4 = 10;
        int plus2 = 5;
        num4 += ++plus2;
        System.out.println("num4="+ num4);//16
        System.out.println("plus2="+ plus2);//6
        //如果变量在++运算符的右边，那么在运算过程中，先进行++运算，再运行其他运算

        // -- 自减运算
        int num5 = 10;
        int reduction = 5;
        --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 += 10;
        a1 = a1+10;//20
        System.out.println("a1="+ a1);
        int b1 = a1+a1;

        // -= 相减赋值
        int a2 = 10;
        //a2 = a2-5;
        a2 -= 5;
        System.out.println("a2="+ a2);

        // *= 相乘赋值
        int a3 = 10;
        //a3 = a3*5;
        a3 *= 5;
        System.out.println("a3="+ a3);

        // /= 相除赋值
        int a4 = 13;
        //a4 = a4/5;
        a4 /= 5;
        System.out.println("a4="+ a4);

        // %= 取余赋值
        int a5 = 13;
        //a5 = a5 % 5;
        a5 %= 5;
        System.out.println("a5="+ a5);

    }
}

比较运算符：

package com.zhiyou100;

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

        
        int a = 20;
        int b = 10;
        System.out.println("a > b: "+ (a > b));//false
        System.out.println("a < b: "+ (a < b));//true
        System.out.println("a == b: "+ (a == b));//false
        System.out.println("a != b: "+ (a != b));//true
        System.out.println("a <= b: "+ (a <= b));//true
        System.out.println("a >= b: "+ (a >= b));//false
        //比较运算符前后都是语句
        System.out.println("a++ > b--: "+ (a++ > b--));
    }
}

逻辑运算符：

package com.zhiyou100;
//逻辑运算符
public class Demo04_Operator { 
    public static void main(String[] args) { 
        
        boolean bool = true;
        boolean bool2 = false;
        boolean bool3 = bool & bool2;
        System.out.println(bool3);
        //说明：与运算符 在程序运算过程中，只要有一个fals，结果就是false，否则为true

        // 或运算 |
        boolean var01 = false;
        boolean var02 = false;
        boolean var03 = var01 | var02;
        System.out.println(var03);
        //说明：或运算，在程序运算过程中，只要有一个为true，结果就为true，否则为false。

        // 非运算 ！
        boolean var04 = false;
        boolean var05 = true;
        boolean var06 = !var04;//true
        //说明：非运算，在程序中运算中，一般只能连接一个布尔类型值，而且非运算符只能放在布尔类型值的左边
        //结果就是对连接的该布尔类型值取相反结果

        //异或 ^ 异或运算符
        boolean var07 = false;
        boolean var08 = true;
        boolean result = var07 ^ var08;
        System.out.println(result);
        //说明：异或运算符，在程序运算中，同为false，异为true
        // 如果异或运算符连接的左右布尔类型变量（表达式）的值不同，结果为true
        // 如果异或运算符连接的左右布尔类型变量（表达式）的值相同，结果为false
        //备注：如果和或运算符做对比，不同之处：当左右都为true的时候，结果为false

        //拓展：与& && 或| || 非! 异或 ^
        boolean bool4 = true;
        boolean bool5 = false;
        boolean bool6 = bool4 && bool5;
        System.out.println(bool6);
        //在程序中，与运算符，通常使用&&
        
        boolean bool7 = true;
        boolean bool8 = false;
        boolean bool9 = bool4 || bool5;
        System.out.println(bool9);
        //当||符号左边的布尔类型值可以确定为true的时候，那么在执行到||的时候，会发生跳跃，||后面的表达式不运行
    }

}

位运算符：

package com.zhiyou100;

public class Demo05_Operator { 
    public static void main(String[] args) { 
        
        // 与位运算 &
        int a = 13;
        int b = 5;
        int c = a & b;//5
        System.out.println(c);
        // 说明：在与位运算中，如果参与运算的二进制值中有一个为0，那么运算的结果即为0
        // 当前后运算的二进制的长度不一致时，那么程序会在短的那一方高位补0，短几位就补几个0，保持长度一致

        //或位运算符
        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);//253
    }
}

三目运算符：

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);//true
        System.out.println(a <= b ? "a<=b" : false);
        System.out.println(a >= b ? a : b);//20

        //第二种用法：在语句中使用(不是输出语句) 赋值运算中
        int c = a > b ? a : b;//20
        System.out.println(c);
        String d = a > b ? "是真的吗？" : "你是假的";
        System.out.println(d);
        
    }
}