java运算符

一：运算符

二：算数运算符

算数运算符是比较简单的，和我们平时所知道的加减乘除取余类似。但java中的%运算算符的操作数以是小数。
算数运算符都是二元操作数，使用时必须有两个操作数；
做除法和取模运算时，右操作数不能为0；

public class Test {
    public static void main(String[] args) {
        int a=7;
        int b=3;
        float c=3.0f;
        System.out.pintln("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("a%b="+(a%b));
        System.out.println("a%c="+(a%c));
    }
}

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

两侧操作数类型不同时，向类型大的提升；

public class Test {
    public static void main(String[] args) {
         System.out.println(1+0.2);
    }
}

1
2
3
4
5
6

三：增量运算符

该种类型运算符操作完成后，会将操作的结果赋给左操作数
但只有变量才可以使用该操作数，常量不能使用

public class Test {
    public static void main(String[] args) {
        int a=1;
        System.out.println(a+=2);//a=a+2
        System.out.println(a-=2);//a=a-2
        System.out.println(a*=2);//a=a*2
        System.out.println(a/=2);//a=a/2
    }
}
1
2
3
4
5
6
7
8
9

四：自增，自减运算符

如果单独使用，前置++和后置++没有区别
如果混合使用，前置++，先加1，然后使用变量+1之后的值，
后置++，先使用变量原来的值，表达式结束后+1；
只有变量才可以使用自增/自减运算符，常量不能使用，因为常量不能被修改。

public class Test {
    public static void main(String[] args) {
        int a=1;
        a++;//a=2
        System.out.println(a++);
        System.out.println(a);
        int b=1;
        ++b;//b=2
        System.out.println(++b);
        System.out.println(b);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

五：关系运算符

在数学中，3 在关系运算符中，计算结果只能是true/false.

public class Test {
    public static void main(String[] args) {
        int a=10;
        int b=20;
        System.out.println(a==b);
        System.out.println(a>b);
        System.out.println(a>=b);
        System.out.println(a<b);
        System.out.println(a<=b);
        System.out.println(a!=b);
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13

六：逻辑运算符

1：逻辑与&&
左右表达式全为真时，结果才为真。
2：逻辑或||
左右表达式全为假时，结果才为假。
3：逻辑非！
真变假假变真。
这里值得注意的是&&和||具有短路效应。
&&：当第一个表达式为假时，第二个表达式将不再再执行。
||：当第一个表达式为真时，第二个表达式将不再执行。

public class Test {
    public static void main(String[] args) {
        System.out.println(10>20&&10/0==0);
        System.out.println(10<20||10/0==0);
    }
}

1
2
3
4
5
6
7

我们知道0是不能做分母的，但编译器并没有报错，所以验证了&&/||具有短路效应

七：位运算符

位运算符的操作对象是二进制数
1：按位与：&
如果两个二进制位都是1，则结果是1，否则结果为0；
2：按位或：|
如果两个二进制数都是0，则结果是0，否则结果为1；
3：按位异或：^
如果两个二进制位相同，则结果为0，反之，则为1.

/*
* 00001001
* 00010101
* 按位与
* 00000001
* 按位或
* 00011101
*按位异或
* 00011100
* */
1
2
3
4
5
6
7
8
9
10

八：条件运算符

表达式1？表达式2：表达式3
1

当表达式1为true时，整个表达式的结果就是表达式2的值；
当表达式1为false时，整个表达式的结果就是表达式3的值。

public class Test {
    public static void main(String[] args) {
        int a=10;
        int b=20;
        int max=a > b? a : b;
        System.out.println(max);
    }
}
1
2
3
4
5
6
7
8

注意：
1：表达式2和表达式3的结果只能是同类型的或者能发生与隐形类型转换；

public class Test {
    public static void main(String[] args) {
        int a=10;
        int b=20;
        int c=a > b ? 2.0 : 1;//会报错
        double d=a > b ? 1 : 2.0;//不会报错
        System.out.println(d);
        System.out.println(c);
    }
}

1
2
3
4
5
6
7
8
9
10
11

2：表达式不能单独存在，它产生的结果必须被使用。

public class Test {
    public static void main(String[] args) {
        int a=10;
        int b=20;
        a > b ? 2 : 5;

    }
}
1
2
3
4
5
6
7
8