java SE 入门之运算符(第三篇)

在 java 中主要有以上运算符，分为 赋值运算符 ，算术运算符、关系运算符（比较运算符）,逻辑运算符和三目运算符（三元运算符）.

我们一起来学习下吧！

一、赋值运算符

赋值运算符主要有五个、分别是 = (赋值)、+=（加上一个在赋值）、-=（减去一个在赋值）、*=（乘以一个在赋值）、/=（注意斜杠别打反了，这是除以一个在赋值）和%=（取摸在赋值）

“=” 叫赋值运算符，就是把一个值付给一个变量，赋值时候使用的。这个就不详细说明了，前面有篇文章叫做java入门之八大基本类型、已经讲解过了,下面我看两行代码“+=”的使用

public class Hello {
     
     public static void main(String[] args ) {
           int a=1;
           a+=10;
           int b;
           b+=10;
        
    }
     
}

b+=10;这行代码等价于 b=b+10,我们上一节的曾经提到过，在java中变量如果要使用必须先赋值。

同理

b+=10<=等价于=>b=b+10; //变量加字面值10

b-=10<=等价于=>b=b-10;//变量减去字面值10

b*=10<=等价于=>b=b*10;//变量乘以字面值10

b/=10<=等价于=>b=b/10;//变量除以字面值10

b%=10<=等价于=>b=b%10;//变量取摸字面值10

取摸：就是取余数，就是变量除以一个数的余数(后边算术运算符会讲解)。

下面我们在来看下代码：

public class Hello {
     
     public static void main(String[] args ) {
          short s=1000;
          short sum=s+100;
    }
}

上述代码竟然报错啦！！！！？？？@￥#@**一脸懵逼啊。

其实 我们的s 变量是short 类型的，而我们的100是int 类型的。所以两个类型不一致，而我们的int类型的范围大，所以需要强制类型转换，这里在说下强制类型转换和自动类型转换的定义。

强制类型转换是我们的大类型转换到小类型的转换。我们小类型到大类型的转换，叫自动转换。所以如下代码就不会报错.

public class Hello {
     
     public static void main(String[] args ) {
          short s=1000;
          short sum=(short) (s+100);//圆括号"()"代表一个整体，方括号“[]”代表所引器、花括号“{}”代表体，如方法体，循环体等后续会讲到,这个必须要整体转换
          int count=s+100;
    }
}

现在代码我们不这样写了，我换一种写法，先看代码

public class Hello {
     public static void main(String[] args ) {
          short s=1000;
          //short sum=s+100;
          //int count=s+100;//
            s+=100;//s+=100 <===>s=s+100;
            short sum=s;
    }
}

当这个代码拷贝到分析器的时候，你会发现，是可以编译的，这个是为什么呢？？！@#￥%……，

有一脸懵逼。

这是因为，在java 中，内部给我们做了强制类型转换，所以这个地方容易出面试题。到这里，赋值运算符我们就学完了。

二、算术运算符

算术运算符主要有 ++（自加运算符） 、--（自检运算符）、*（乘法运算符）、/（触发运算符）、+（加法运算符）、-（减法运算符）和%（取摸运算符）,

其中 +，-，*，/,% 叫做单目运算符，也叫单元（一元）运算符。

++，-- 叫双目运算符，也叫双元运算符

下面来看下非了双目运算符的代码 

public class Hello {
     public static void main(String[] args ) {
         int a=1024;
         int b=128;
         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);//取余
    }
}

 在看下输出结果

有些人会认为很简单

可是在看下边的代码:

public class Hello {
     public static void main(String[] args ) {
         int a=11;
         int b=5;
          System.out.println(a/b);//取商
         System.out.println(a%b);//取余
    }
}

可是结果不一样了

这是为什么呢？11 除以5应当等于2.2啊可是结果为什么会是2呢,因为我们的变量是整数，要取整的。那第二个为什么删除的1 。我们先来你看下小学数据计算公式，

我们除号运算符求的是商，我们取摸运算符是取余。

有人会问，如果我想要小数怎么办？？

 
public class Hello {
     public static void main(String[] args ) {
         int a=11;
         double b=5;
          System.out.println(a/b);//取商
         System.out.println(a%b);//取余
    }
}

就是我们计算的表达式，至少有一个是小数，计算的结果就是小数.

下面我们在来看下++和--,

++是什么意思呢，就相当于自身加1，下面我们来看下代码

public class Hello {
     public static void main(String[] args ) {
         int i=0;
         i++;
         System.out.println(i);
    }
}

这个输出的结果是1，“--”同理，就是自身减去1.i++ 等价于 i=i+1 同时还等价于 i+=1;

那么 i++和++i的结果是不是一样的.在java 中 ++和--是可以出现在变量前后的，只是位置不同.

 
public class Hello {
     public static void main(String[] args ) {
         int i=0;
         int num=i++;
         System.out.println(i);
         System.out.println(num);
         int n=0;
         int number=++n;
         System.out.println(n);
         System.out.println(number);
    }
}

 看到结果，我们回答县，i++输出的是0，而++n输出的是1，这就终结了一句话。

变量++是先赋值使用后自加，++变量是先自加后使用赋值.“--”同理。

三、关系比较运算符

在java中比较运算符常用的有这6个   >、  <、  ==、  !=、  >=、  <=， 他们的到的值有且只能是布尔值 boolean 类型的.下边我们来看下这个表格，你就明白了，这个就是小学一年级的比较运算。比较结果成立我们得到的是true，不成立得到的是false.

比较运算符成立表达式

序号	运算符	说明	b变量a =11 ,值b=10 （a 不等式b）	a=10，b=11(a不等式b)	案列
1	>	大于	true	false	无
2	<	小于	false	true	无
3	==	恒等于	false	false	无
4	!=	不等于	true	true	无
5	>=	大于等于	true	false	无
6	<=	小于等于	false	true	无

这个没什么好演示的，就此揭过，后续会经常用到这些不等式的.

四、字符串连接符

在java 中字符串拼接有且只有“+”一个拼接符号。但是在NET中会推出很多，后续会讲解NET 中的字符串拼接符， 字符串连接符就是“+”号, 字符串拼接分在算术运算符中就是相加的意思，但是在字符串中是拼接的意思，我们在java中字符串用双引号表示。

public class Hello {
     public static void main(String[] args ) {
      int a=10;
      int b=5;
      System.out.println(a+b);
      double c=3.14;
      System.out.println(c+a);
      
      System.out.println("wbcsky"+a);
      
      System.out.println(a+"wbcsky");
      System.out.println( "a+b="+a+b);
    }
}

根据上面胡代码，我们可以总结一句话:“当加号的两边是数字（含小数）就进行加法运算，如果加号的任意一边是字符串，就进行字符串拼接”; 注意，拼接不是做强制类型转换,做的是自动转换。

在上述代码中

  System.out.println( "a+b="+a+b);这句话的结果没有截图，这句话的结果是 a+b=105;
解释下，a+b= 这部分是一个字符串，当加上a的时候 "a+b="+a 也是一个字符串，所以在加b的时候是拼接字符串.
这里留下个问题？当我想输出 10+5=15 和 a+b=15,这个要怎么写.

五、逻辑运算符

在java 中逻辑运算符分为两种，一种 叫做 逻辑运算符   && （并且） ||（或者）

另一种  叫做 位运算符  “!” (非)   “^” （异或）“|”（或）  “&”（与）  

位运算

我们先学习位运算符，位运算符是针对二进制进行计算的，也就是说，把我们任何类型转换成为二进制，通过二进制去比较，位运算两边的类型相同返回的类型相同，两边类型不同，返回得不一定是哪个，这个没有深入研究，太底层了

。看代码

 
public class Hello {
     public static void main(String[] args ) {
      int a=1;
      int b=2;
      int c=a&b; //a与b
      System.out.println(c);
      int d=a|b;//a或b
      System.out.println(d);
      int e=a^b;//a 异或 b
      System.out.println(e);
      //  boolean f=a!b;// a 非 b 是会报错的，在JDK 1.5以前的版本，是可以写的
    //  System.out.println(d);
    }
}输出结果位0、3、3.

来看下a 与 b 是怎么来比较的。 因为a=1 a 是四个字节 也就是说是32 位 。二进制换算在上一篇文章有介绍 ，我们这里只描述后面8位，因为前面都是0.
变量a 的二进制表示为 0000 0001 ，变量b的二进制表示为 0000 0010 。看下图

总结：运算时均把运算数转换为二进制再做比较。
规则（&）：当相同的位上均为1时结果为1，否则结果为0 ,术语叫做“有0则为0”，下图的案列就有均为1。

 

规则（|）：当上下两边操作数的位有一边为1时，结果为1，否则为0,0000 0011 二进制转10进制结果为3 ，术语叫做有1则为1

  怕大家看不懂，后边在列个例子

 

a^b(a异或b)规则 两边的位不同时，结果为1，否则为0.如0000 0001^0000 0010=0000 0110 转换成为十进制则为3.，术语叫做 1,0不等则为1，这里就不过多解释了。

 

"非"的位运算往往返回的是boolean 类型，主要是和“=”等号一起使用，用于表示等于和不等于，！的术语叫做 “0变1,1变0” ，就是说 0代表的是false,1 代表的是true（这句话不懂没关系，往下学），true 取反的时候就是false,反之亦然。

在开发过程中，位运算符往往用在逻辑上，主要用在同类型的数据对比上，但是非和异或用的很少，大家主要记住或和与。

逻辑运算

刚学习了位运算，下边我们看下  怎么在逻辑运算里面使用位运算。

public class Hello {
     public static void main(String[] args ) {
     int a=9;
     int b=1;
     System.out.println(a>0&b<10); //  true |true = True  有假则为假  有0则为0
     System.out.println(a>10&b<0); // false|false =false 有假则为假 有0则为0
     System.out.println(a>0&b<0);// True|false=false 有假则为假 有0则为0
     System.out.println(a>0|b<10); // true |true = True 有真则为真  有1则为1
     System.out.println(a>10|b<0); // false|false =false  有真则为真,没有就是false   有1则为1 
     System.out.println(a>0|b<0); // True|false=true  有真则为真  有1则为1
       
    }
}

可以把上面的代码输出结果整理下，就出现如下：

再来学习下 &&和 & ，|| 和| 的区别,我们管&& 叫”短了与“，||叫”短路或”。

public class Hello {
     public static void main(String[] args ) {
         boolean b1=true;
         boolean b2=false;
         System.out.println(b1&&b2);
         System.out.println(b1&b2);
       
    }
}

这个代码执行的结果都是false,也就是说，他们在使用的结果是一样的。那他们有没有什么不通点呢，看下边的代码：

public class Hello {
     public static void main(String[] args ) {
        boolean isBool=false;
        boolean b=true;
        boolean ool=true;
        int num=1;
         b=isBool&num++>0;
         System.out.println(b);//false
         System.out.println(num);//2
         int number=1;
         ool=isBool&&number++>0;
         System.out.println(ool);//false
         System.out.println(number);//1
    }
}

根据上面的输出结果我们可以看出， isBool 变量是false，后边的num++>0 是一个true的表达式，一个false 与上任何一个布尔表达式返回的都是false（其实第一个不等式就已经可以分别出结果了）,而一个运算符“&”执行了i++,而两个的没有执行，说明两个运算符合起来使用效率更高.

总结：一个“与”的逻辑运算符效率低，两个“与”的逻辑运算符效率会高跟多，不会再次计算。

六、三目运算符

三目运算符也叫做三元运算符，，之前我们学习了一目运算是一个运算符，二目运算是两个运算符组合，现在三目运算就是三个运算符组合使用。

语法格式为 布尔表达式？表达式1:表达式2; 以问好开始，以冒号分割，以分号结尾。当布尔表达式为真，执行表达式1，如果布尔表达式为假，执行表达式2.表达式1和表达式2可以是一个值。

public class Hello {
     public static void main(String[] args ) {
         System.out.println(1>2?"为真进入":"为假进入");
         String result=2>1? "true": "false";//String 代表字符串，后续会讲解字符串
         System.out.println(result);
    }
}

 上诉代码输出了“为假进入”和“false”.。三目运算符是可以嵌套的，下边我们在来看下列子

public class Hello {
     public static void main(String[] args ) {
          int a,b=20;
          a=10;
          int num=a>b?a<b?5:6:a<5?a:b;
          System.out.println(num);
          System.out.println(a>b?(a<b?5:6):(a<5?a:b));
    }
}

两种写法输出结果都是20，第一种方法，可读性比较差。到这里，我们基本学习了java 中常用的运算符了。后续想起什么，在更新。