实例：

 1 class 逻辑运算符
 2 {
 3     public static void main(String[] args) 
 4     {
 5         var a=10;
 6         var b=5;
 7 
 8         //短路与&& 当第一个条件不满足时，不会判断第二个条件
 9         if(a>15&&a++>2)
10         {
11         }
12         System.out.println("a的值为："+a);
13 
14         //不短路与& 当第一个条件不满足时，人然会判断第二个条件
15         if(b>6&b++>2)
16         {
17         }
18         System.out.println("b的值为："+b);
19     }

---------- 运行Java ----------
a的值为：10
b的值为：6

输出完成 (耗时 0 秒) - 正常终止

  六、三目运算符

三目运算符只有一个：？：，三目运算符的语法格式如下：

1 (expression)? if-true-statement:if-false-statement;

class 三目运算符 
{
    public static void main(String[] args) 
    {
        String str=5>3?"5大于3":"5小于3";
        System.out.println(str);

        //三目运算符和if else功能相当

        String str1=null;
        if(5>3)
        {
            str1="5大于3";
        }
        else
        {
            str1="5小于或等于3";
        }
        System.out.println(str1);
    }
}
---------- 运行Java ----------
5大于3
5大于3

输出完成 (耗时 0 秒) - 正常终止

6、Java运算符

运算符的分类

算数运算符

二元运算符

算术运算符中 = - * / % 属于二元运算符，二元运算符指的是需要两个操作数才能完成的运算的运算术。 整数运算规则

1、如果两个操作数有一个为Long，则结果也为Long。 2、如果没有Long，结果则为int，即使操作数为short、byte，结果也为int。

    int a =1;
    long b = 2;
    //int c = a + b; //报错 因为有一个为Long，则结果也为Long
    
    byte a1 = 1;
    short a2 = 1;
    int d = a1 + a2; //正确 因为如果没有Long，结果则为int

浮点运算规则

1、如果两个操作数有一个为double，则结果为double。 2、只有两个操作数都为float，结果才为float。

    double a = 1.1;
    //float b = a + 2.2f; //报错，因为操作数有一个为double，则结果为double

取模运算：其操作数可以为浮点数，一般使用整数，结果是余数，余数符号和左边操作数相同。

一元运算符

一元运算符是该类运算只需要一个操作数的时候，比如:++,--

    int a = 2;
    int b = a++; //先是执行，b = 3,然后运算完以后再给a自增。
    System.out.println("a=" + a + "\tb=" + b);
    //运行结果：a=3	b=2
    
    a = 2;
    b = ++a; //先是执行a的自增，然后再赋值给b
    System.out.println("a=" + a + "\tb=" + b);
    //运行结果：a=3	b=3

赋值运算符

    int a = 2;
    int b = 3;
    a+=b;       //这个相当于a = a + b;
    System.out.println("a=" + a);
    //结果为：a = 5
    
    a = 2;
    a *= b + 3;     //这个相当于 a = a * (b + 3)
    //是先运算后面的，再运算前面的
    System.out.println("a=" + a);
    //结果为：a = 12;

关系运算符

关系运算符号是用来比较的，所以返回值只会是boolean，只有true/false

    int a = 2;
    int b = 3;
    boolean c = b > a;
    System.out.println("c="+c);
    //结果为：c=true

注意事项：

• == 和 != 是所有类型，引用和基本数据类型都可以用的。
• .>、<、>=、<=只是针对于数值类型，还有char可以使用。

逻辑运算符

Java中逻辑运算符的操作数和结果都是boolean类型的。

    boolean a = true;
    boolean b = false;
    //逻辑与 &
    //只有同时为true的时候才返回true，只要有一个为false，返回false
    boolean c = a & b;
    System.out.println("c=" + c);
    //结果为：c=false;

    //逻辑或 ｜
    //只要有一个值为true，结果就为true
    c = a | b;
    System.out.println("c=" + c);
    //结果为:c=true

    //逻辑非
    //取a的相返的值，如果a为true，c则为false，如果a为false，c则为true
    c = !a;
    System.out.println("c=" + c);
    //结果为：c=false;

    //逻辑异或
    //两个值相同的时候为false，不同的时候为true
    c = a ^ b;
    System.out.println("c=" + c);
    //结果为：true

    //短路或
    //因为逻辑或只要有一个值为true，结果就为true，但是还是为验证第二个值
    //短路或不一样，只要第一个值为true，第二个值就不验证了，直接返回true，这样做是为了提高效率。
    c = a || b;
    System.out.println("c=" + c);
    //结果为:c=true

    //短路与
    //因为逻辑与必须两个都为true，结果才为true，只要有一个为false结果就为false
    //短路与不一样，只要第一个值为false，结果就为false，第二个值就不验证了,这样做是为了提高效率。
    c = b && a;
    System.out.println("c=" + c);
    //结果为：false

位运算符

位运算符是进行二进制运算的。

    int a = 3;
    int b = 4;

    //取返操作
    System.out.println("~a=" + ~a);
    //结果为：~a=-4

    //按位与
    System.out.println("a&b=" + (a&b));
    //3的后四位二进制为 0011
    //4的后四位二进制为 0100
    //与 运算符是相同的为 1 不同的为 0 所以最后的结果为 0000
    //结果为：a&b = 0

    //按位或
    System.out.println("a|b=" + (a|b));
    //3的后四位二进制为 0011
    //4的后四位二进制为 0100
    //或 运算符是只要有一个为1,就为1 所以结果为 0111
    //结果为：a|b = 7

    //按位异或
    System.out.println("a^b=" + (a^b));
    //3的后四位二进制为 0011
    //4的后四位二进制为 0100
    //异或 运算符是不同的为1,相同的为0 所以最后结果为 0111
    //结果为：a^b = 7

    //左移运算符 <<
    //这个运算符的右边是要移运的位数，左边才是要运算的值
    System.out.println("a<<1=" + (a << 1));
    //向左边移动一位数是把a乘以2 ， 所以结果是 3 * 2
    //结果为：6

    //右移运算符 <<
    //这个运算符的右边是要移运的位数，左边才是要运算的值
    System.out.println("a>>1=" + (a >> 1));
    //向右边移动一位数是把a除以2 ， 所以结果是 3 / 2
    //结果为应该为1.5的，但是因为是整数运算，算动取整，所以才为1
    //结果为：a>>1=1
    System.out.println("b>>1=" + (b >> 1));
    //结果为：b>>1=2

& 、| 、^ 运算符：如果运算符，如果运算两边是boolean类型的值，那么这三个运算符就是逻辑运算符，如果是数值类型的，就是位运算符号。

字符串连接符

在我们前面的例子中，我们使用了 + 号，但是有的地方的 + 号不参与运算，是因为，这个时候， + 号变成了一个连接符号了，它变成连接符号的条件是 左右两边只要有一个String 类型的字符串，就会变成连接符号。

    int a = 2;
    //这里的3为字符串，由双引号引起来的都是字符串
    System.out.println(a + "3");
    //结果为:23

条件运算符

条件运算符号也叫三目条件运算符号。格式为：

x ? y : z

  这个运算表达式，有三个参数，x只能为boolean，另外两个参数可以为任意类型。

    boolean a = true;
    boolean b = false;
    System.out.println("第一个参数为true="+(a?"输出为true":"输出为false"));
    System.out.println("第一个参数为false="+(b?"输出为true":"输出为false"));
    //结果为：
    //第一个参数为true=输出为true
    //第一个参数为false=输出为false

这个三目运算符可以做一些小的判断，但是如果是情况复杂的最好还是用if else来进行计算。

运算符优先问题

  运算符的优先级不用特地的记，只要看看就可以了，因为工作的时候，复杂的运算符号，都会有小括号来进行组织的。不会全都按照运算符号优先级来进行设计。

<br> <hr> <center>

细节决定成败! 个人愚见，如有不对，恳请扶正!

</center>

8. Java的运算符

计算机的最基本用途之一就是执行数学运算，作为一门计算机语言，Java也提供了一套丰富的运算符来操纵变量。

我们把运算符具体分为：算数运算符，比较运算符，逻辑运算符，位运算符，赋值运算符，条件运算符，instanceof 运算符。

1. 算数运算符

算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。

以下代码：

public static void main(String[] args) { int a = 5; int b = 10; 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++)); System.out.println("“--” 运算："+(a--)); } 

输出结果：
“+” 运算：15
“-” 运算：-5
“*” 运算：50
“/” 运算：0
“%” 运算：5
“++” 运算：5
“–” 运算：6

另外，进行除法运算时，若两个操作数是整型的，结果也会是整型的，舍弃掉小数部分；如果有一个数是浮点数，结果将自动转型为浮点型。进行取余运算时，若两个操作数是整型的，结果也会是整型的，如果有一个数是浮点数，结果将自动转型为浮点型

**其中，自加和自减运算符针对一个数值本身的运算；且前缀自增自减（++a，–a）是先进行自增或者自减运算，再进行表达式运算。后缀自增自减(a++,a–)是先进行表达式运算，再进行自增或者自减运算。我们给出例子：

 public static void main(String[] args) { int a = 5; int b1 = 10; int b2 = 10; int c1 = 10; int c2 = 10; System.out.println("前缀自增b1参与表达式计算后值为："+(a*++b1)); System.out.println("后缀自增b2参与表达式计算后值为："+(a*b2++)); System.out.println("前缀自减b1参与表达式计算后值为："+(a*--c1)); System.out.println("后缀自减b2参与表达式计算后值为："+(a*c2--)); } 

2. 比较运算符

比较运算符的结果一定是boolean类型，也叫关系运算符

如，

 public static void main(String[] args) { int a = 5; int b = 10; 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 ); } 

输出结果：
false
true
false
false
true
true
注意，比较运算符“==”用来比较基本数据类型是比较的是值是否相等，比较引用数据类型是比较的是引用是否相等，引用数据类型用equals()来比较字面量是否相等。

3. 逻辑运算符

逻辑运算符中，“与”运算符和“或”运算符都有两个，“&&”我们称之为短路与。“||”我们称之为短路或，短语与“&&”从左到右一次判断，遇到false则停止判断，得出结果未false；逻辑与“&”从左到右一次判断，直至结束。短语或“||”从左到右一次判断，遇到true则停止判断，得出结果未true；逻辑或“|”从左到右一次判断，直至结束。我们给出例子：

 public static void main(String[] args) { int a = 5; int b = 10; //短路与，前一个表达式的值为false，不在判断下一个表达式，故a++不执行 System.out.print((a>b)&&(a++ == 1)); System.out.println(" a的值:"+ a); //逻辑与，前一个表达式的值为false，仍依次判断下一个表达式 System.out.print((a>b)& (a++ == 1)); System.out.println(" a的值:"+ a ); //短路或，前一个表达式的值为true，不在判断下一个表达式，故a++不执行 System.out.print((a<b)|| (b++ == 1)); System.out.println(" b的值:"+ b ); //逻辑或，前一个表达式的值为true，仍依次判断下一个表达式 System.out.print((a<b)| (b++ == 1)); System.out.println(" b的值:"+ b ); //非运算符 System.out.print(!(a<b)); } 

4. 位运算符

Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。位运算符作用在所有的位上，并且按位运算。

我们给出例子：

public static void main(String[] args) { int a= 10; int b = 20; //a转化成二进制表示为：1010；b转化为二进制表示为：10100 //按位运算时，我们把a表示为：01010 System.out.println(a&b); //按位与运算，有零则为零，都为1则表示为1，与的结果为：00000，即十进制的0 System.out.println(a|b); //按位或运算，有1则为1，都为0则表示为0，或的结果为：11110，即十进制的30 System.out.println(a^b); //按位或运算，对应位置相同则为0，否则为1，取反的结果为：11110，即十进制30 } 

运行结果：
0
30
30

下面，我们来说一下按位取反，计算机内部都是以补码的形式在做数学运的，而我们所用的编码规则，例如原码、反码则是我们自定义的，用来方便和计算机中的补码来形成转化。故而，我们在进行按位取反是要把原码或者反码转化成补码的形式。正数的反码和补码与原码相等； 负数的反码是符号位不变，其余按位取反，补码为反码+1。负数的最高符号位为1。
如，

  public static void main(String[] args) { int a= 10; int b= -10; System.out.println(~a); System.out.println(~b); } 

运行结果为：-11，9。 分析如下： a为正数，其补码形式与原码相同，表示为：00001010，按位取反后为11110101，注意，此时为补码形式，转化为反码表示为，11110100，再转化为原码表示为：10001011，即十进制的-11.同样的，b为负数，其补码表示为：11110110，按位取反后为00001001，此时依然为补码形式，转化为原码即其本身00001001，即十进制的9。故，按位取反后的结果可表示为-（X+1）

接下来，我们给出例子来看一下位移运算符

public static void main(String[] args) { int a= 10; int b = -10; //int为4个字节，也就是32位，为了简化a表示为：00001010, // b为负数我们表示为：1000 0000 0000 0000 0000 0000 0000 1010 //b的补码形式为 1111 1111 1111 1111 1111 1111 1111 0110 System.out.println( a<<1 ); //按位左移,原则舍弃高位，低位补零表示为：00010100，即20 System.out.println(a>>1); //按位右移,原则舍弃低位，高位补零表示为：00000101，即5 System.out.println(a>>1); //按位右移,原则舍弃低位，高位补零表示为：10000101，即5 System.out.println(a>>>1); //按位右移,原则舍弃低位，高位补零表示为：0000010，即5 System.out.println(b>>1); //有符号按位右移,原则舍弃低位，符号位不变，其余高位补零原码表示为： // 1000 0000 0000 0000 0000 0000 0000 0101，即-5 System.out.println(b>>>1); //无符号按位右移,原则舍弃低位，高位补零（补码=原码）表示为： // 0111 1111 1111 1111 1111 1111 1111 011，即十进制的，2147483643 } 

输出结果：
20
5
5
5
-5
2147483643
总结一下，原则上，按位左移时,原则舍弃高位，低位补零;有符号按位右移,原则舍弃低位，符号位不变，其余高位补零；无符号按位右移,原则舍弃低位，高位补零。再次强调，做位移运算时，是按补码来进行运算的

5. 赋值运算符

基本的赋值运算符是“=”。他的优先级别低于其他的运算符，所以对该运算符往往最后读取,他不是“等于”，它的作用是将一个表达式的值赋给一个左值。所谓左值是指一个能用于赋值运算左边的表达式。左值必须能够被修改，不能是常量，以上其他是复合的赋值运算符，又称为带有运算的赋值运算符，也叫赋值缩写。等同与先按运算符运算后再把运算结果付给左值（见表格）。具体运算方法上边儿已经罗列，此处不再赘述

6. 条件运算符

条件运算符也叫三目运算符

语法：

(条件) ? 结果一 : 结果二; 

当条件成立，执行结果一，否则执行结果二。，“？”前的值必须是true或flase
我们给出例子：

if(a<b) min=a; else min=b; 可以用下面的三目运算符来处理 min = a<b ? a : b; 

7. instanceof 运算符

instanceof运算符可以确定对象是否属于一个特定的类.该运算符是二目运算符，左边的操作元是一个对象，右边是一个类，当左边的对象是右边的类或子类创建的对象时，该运算符运算的结果是true,否则是false。，使用格式：( Object reference variable ) instanceof (class/interface type)

我们给出例子：

public static void main(String[] args) { String a = "name"; System.out.println(a instanceof String); System.out.println(a instanceof Object); } 

输出结果：true，true

8. 运算符优先级

在一个表达式中可能包含多个有不同运算符连接起来的、具有不同数据类型的数据对象；由于表达式有多种运算，不同的运算顺序可能得出不同结果甚至出现错误运算错误，因为当表达式中含多种运算时，必须按一定顺序进行结合，才能保证运算的合理性和结果的正确性、唯一性。相同优先级中，按结合顺序计算。

通常优先级由高到底的顺序依次是：
1. 括号级别最高，逗号级别最低；
2. 单目 > 算术 > 位移 > 关系 > 逻辑 > 三目 > 赋值。
3. 除了单目运算符、赋值运算符和条件运算符，其他的运算符都是从左到右结合的。

今天关于4、Java的运算符和java中运算符的分享就到这里，希望大家有所收获，若想了解更多关于14、Java的异常、2、Java运算符、6、Java运算符、8. Java的运算符等相关知识，可以在本站进行查询。