1.算数运算符

class Demo01 
{
    public static void main(String[] args) 
    {
        //算术运算符。 +  -  *  /   %(取余，模运算，如果左边小于右边就得到左边的数：2%5=2,3%5=3)
        //  ++ (自增：在原有数据基础上+1，再赋给原有的数据。)  
　　　　　int x = 6370;
        x = x / 1000 * 1000;
        System.out.println(x);
　　　　 System.out.println(3+"2");   //  32    不是32，是3和2连一起。
　　　　　　
　　　　 int  a = 4, b=5;
　　　　 System.out.println("a="+a+",b="+b); //a=4.b=5
　　　　  
　　　　　int a = 3;
　　　　  a++;   //a = a+1;
　　　　  System.out.println("a="+a);

} }

注意：

1.JAVA是的强烈型语言

2.任何数据和字符串相加，得出的结果都是相连。

3.运算中，一般地变量会先参与其他的运算，在运行自身自增的动作。

内存原理："把右边运算完以后，在赋值给右边"

分析：开始a=3，它会先建立一个a=3的空间，它会先参与其它的运算，a++=3+1=4, 自身a=4, 之后再把原来a=3的内容值3赋值给右边b，所以b=3.

2.赋值运算符

class Demo02
{
    public static void main(String[] args)
    {
        //赋值运算符，  =  +=  *=  /=  %=
        //int a,b,c
        // a = b = c =4;

        //int  a = 4;
        //a +=2; //  a = a + 2;

        short s = 3;  // short 本身可存 2个字节，赋值运算，s要进行检查
        // s += 4;    //成功，它是一次运算，+=动作时候它在里面做了强转，即：自动转换。
        //s = (short) (s+4)  这个可以代表： s = s+4  .
        s = s + 4;   //失败  它是两次运算，因为s是不确定的值，所以检查不出来。失败
        System.out.println("s+="+s)

        //分析：
        //1个编译失败的原因：因为实现自动类型的提升，所以类型已经不能赋给低空间的类型，会丢失精度
    　　//1个编译成功的原因：因为它里面做了类型的强转。
        
    }
}

3.比较运算符

class Demo03
{
    public static void main(string[] args)
    {
        /*
        比较运算符，运算完的结果必须是true或者false
        */
        System.out.println(3>2); //true   
        System.out.println(3==2); //false
    }
}

4.逻辑运算符

class Demo03
{
    public static void main(string[] args)
    {
        /*
        比较运算符，运算完的结果必须是true或者false
        */
        //System.out.println(3>2); //true   
        //System.out.println(3==2); //false

        //2<x<5  java中这种形式要拆分： x>2  x<5
        /*
        逻辑运算符有什么用？
        答： 用于连接两个布尔型的表达式
        
        & ： 与
        | ： 或
        
        &：符号的运算特点：
            true & true  = true;
            true & false = false;
            false & true = false;
            false & false = false;

        &：运算规律：
            &运算的两边只有一个false，结果肯定是false，
            只有两边都为true，结果才是true。

        |：运算特点：
            true | true = true;
            true | false = true;
            false | ture = true;
            false | false = false;

        ||运算规律：
            |运算的两边只要有一个是true，结果肯定是true，
            只有两边都为false，结果都是false。

        ^  异或 ： 和 “或” 有点不一样，  
            true  | true = false;
            true  | false = true;
            false | ture = true;
            false | false = false;
        
        ^ 异或的运算规律：
        ^ 符号的两边结果如果相同，结果是false
            两边的结果不同，结果是true。
    
        ！： 非运算，判断事物的另一面。
            !true = false     非真为假
            !false = true;    非假为真

            !!true = true;     非非真为真
        
        && 双与：
            int x = 6
            x > 2 && x<5  真与与假为假
            x > 2 & x<5   真与假为假

            int x = 1;

            x>2 % x<5   假与真为假
            x>2 && x<5  双与一旦左边为假，右边就不比较了。双与比单与高效。 可做运费运算。

        && 双与的特点：
            和& 运算的结果是一样的，但是有点小区别。
            单& :无论左边的运算结果是什么，右边都参与运算。
            双&&:当左边为false时，右边是不参与运算的。

        ||： 
            和| 运算的结果是一样的，但是有点小区别。
            单| :无论左边的运算结果是什么，右边都参与运算。
            双||:当左边为true时，右边是不参与运算的。

        */
        int x = 6;
        System.out.println(x>2&x<5)  //与：左边为真，右边为假，总体结果就为假
        System.out.println(x>2|x<5)  //或：左边为真，右边为假，总体结果就为真

    }
}

5.位运算符

移位运算符：

6.三元运算符

格式：
    1.（条件表达式）？ 表达式1：表达式2;
    2.如果条件为true，运算后的结果是表达式1;
    3.如果条件为false，运算后的结果是表达式2;

示例：
    1.获取两个数中较大的数。
    2. int x =3 ,y=4,z;
    3. z = (x>y)?x:y;  // z变量存储的就是两个数中较大的数。

示例：

class Demo
{
    public static void main(String[] args)
    {
        int x = 0;y;
        y = (x>1)?100:200;
        System.out.println("y="+y);

　　　　 int a,b;
　　　　 int max = a>b?a:b;

　　　　 int o,p,q;
        int temp = o>p?o:p;
　　　　 int max2 = temp>q?temp:q;
    }
}