1.运算符

1.1 算术运算符

算术运算符是对数值型的变量进行运算

public class Operator {
    public static void main(String args[]){
        System.out.println(10/4); //2
        System.out.println(10.0/4); //2.5
        double d=10/4;
        System.out.println(d); //2.0

        //%取模，取余，其本质，可以看一个公式 a % b=a-a/b*b
        System.out.println(-10%3); //-10-(-10)/3*3=-10+9=-1
        System.out.println(10%-3); //10-10/(-3)*(-3)=10-9=1
        System.out.println(-10%-3); //(-10)-(-10)/(-3)*(-3)=-10+9=-1
        System.out.println(10%3); //1

        //++的使用
        int i=10;
        i++;//自增,等价于i=i+1;=>i=11
        ++i;//自增，等价于i=i+1;=>i=12
        System.out.println("i="+i);
        /*
        * 作为表达式使用
        * 前++：++i 先自增后赋值
        * 后++：i++ 先赋值后自增
        * */

        int j=8;
        int n=8;
        int k=++j;//等价于 j=j+1;k=j;
        int m=n++;//等价于 m=n;n=n+1;
        System.out.println("k="+k+"\tj="+j); //k=9 j=9
        System.out.println("m="+m+"\tn="+n); //m=8 n=9

    }
}

说明：

• 对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分，例如：10/3 结果是3
• 当对一个数取余时，可以等价于 a%b=a-a/b*b,这样我们可以看到取余的一个本质运算
• 当自增独立使用时，不管是++i,还是i++;都一样的，等价
• 当自增当作一个表达式使用时，j=++i 等价于 i=i+1,j=i(先自增，再赋值)
• 当自增当作一个表达式使用时，j=i++ 等价于 j=i i=i+1(先赋值，再自增)

思考：

int i=1;

i=i++;

结果是多少，为什么？

int i；

i=++i;

结果是多少，为什么？

public class Operator02 {
    public static void main(String[] args) {
        int i=1;
        i=i++;//规则使用临时变量：(1)temp=i (2)i=i+1 i=temp
        System.out.println(i); //1

        int j=1;
        j=++j; //规则使用临时变量：(1)j=j+1;(2)temp=j;(3)j=temp
        System.out.println(j); //2
    }
}

1.2 关系运算符

关系运算符的结果都是boolean型，也就是要么是tru,要么是false

关系表达式 经常用在if结构中或循环结构的条件中

public class RelationalOperator {
    public static void main(String[] args) {
        int a=9;
        int b=8;
        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); //false
        System.out.println(a!=b); //true
        boolean flag=a>b;
        System.out.println("flag="+flag); //true
    }
}

 1.3 逻辑运算符

用于连接多个条件（多个关系表达式），最终的结果也是一个boolean值

逻辑与&，逻辑或|，逻辑异或^

短路与&&，短路或||,取反！

逻辑运算规则说明：

• a&b：逻辑与，规则：当a和b同时为true，则结果为true，否则为false
• a&&b：短路与，规则：当a和b同时为true，则结果为true，否则为false，如果a为flase，则不用判断b。效率高
• a|b：逻辑或，规则：当a和b，有一个为true，则结果为true，否则为false
• a||b：短路或，当a和b，有一个为true，则结果为true，否则为false，如果a为true，则不用判断b。效率高
• !a：取反，或者非运算。当a为true，则结果为false，当a为false时，结果为true
• a^b：叫做逻辑异或，当a和b不同时，则结果为true，否则为false

public class InverseOperator {
    public static void main(String[] args) {
        int x=5;
        int y=5;
        if(x++==6 & ++y==6){
            x=11;
        }
        System.out.println("x="+x+",y="+y); //x=6,y=6
        x=5;
        y=5;
        if(x++==5 |++y==5){
            x=11;
        }
        System.out.println("x="+x+",y="+y); //x=11,y=6

        x=5;
        y=5;
        if(x++==6 &&++y==6){
            x=11;
        }
        System.out.println("x="+x+",y="+y);//x=6,y=5

        x=5;
        y=5;
        if(x++==6 || ++y==6){
            x=11;
        }
        System.out.println("x="+x+",y="+y);//x=11,y=6

        boolean flag=true;
        System.out.println(!flag); //false

        x=5;
        y=5;
        if(x++==6 ^ ++y==6){
            x=11;
        }
        System.out.println("x="+x+",y="+y); //x=11,y=6

        System.out.println(true ^ true); //false
        System.out.println(false ^ true); //true
        System.out.println(true ^ false); //ture
        System.out.println(false ^ false); //false
    }
}

1.4 赋值运算符

 =，+=，-=，*=,/+,%=

a+=b；等价于 a=a+b;

1.5 三元运算符

语法：条件表达式?表达式1:表达式2

运算规则：

1. 如果条件表达式为ture,运算后的结果是表达式1
2. 如果条件表达式为flase,运算后的结果是表达式2

public class TernaryOperator {
    //三目运算符使用
    public static void main(String[] args) {
        int a=10;
        int b=99;
        int result=a>b?a++:b--;
        System.out.println("result="+result); //99
        System.out.println("a="+a); //10
        System.out.println("b="+b); //98
    }
}

1.6 运算符的优先级

运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序

只有单目运算符，赋值运算符是从右向左运算的