第九节.Java中运算符号
两个 简单的小知识点。
运算符：在程序中出现的一些特殊符号，如 + - * / > = 等，这写符号我们称作运算符号。运算符号都有不同的功能，比如进行数学运算，赋值，比较大小等。可以理解为在程序中拥有不同功能的特殊符号。这节课我们对运算符进行详细的讲解。
表达式：表达式可以理解为由运算符参与，并且最终能计算出结果的算式。当我们输出一个表达式的时候，输出的是这个表达式的计算结果。例如有算术表达式、逻辑表达式、字符表达式等。
运算符号的简单分类: 运算符号可以分为 一元运算 二元运算 和三元运算。所谓的元，指的时参与运算的最少元素个数。例如 + 法 -法 这些运算至少需要两个元素参与所以是二元运算符号。
1. Java中的运算符号分类
Java中常用的运算符号包括: 算数(数学)运算符号，赋值运算符号，比较(关系)运算符号，布尔(逻辑)运算符号，字符串链接符号，三元运算符号，位运算符号 等.
| 数学运算符号 | + 加 ， - 减 ，* 乘 ，/ 除 ， % 模 ，++自增 ，--自减 | ||
| 赋值运算符号 | = 赋值 ，+= 加等于 ， -= 减等于 ， *= 乘等于 ， /= 除等于 ， %= 模等于 | ||
| 比较运算符号 | == 相等于 ， ！= 不等于 ， < 小于 ， > 大于 ， <= 小于等于 ， >= 大于等于 | ||
| 布尔运算符号 | & 与 ， && 短路与 ， | 或 ， || 短路或 ， ！非 ， ^ 异或 | ||
| 位运算符号 | & 按位与 ， | 按位或 ， ~ 取反 ， ^ 按位异或 ， << 左移 ， >> 右移 ， >>> 无符号右移 | ||
| 字符串链接符号 | + 字符串链接 | ||
| 三元运算符号 | ? : 三元运算 | ||
在以上的运算符号中: ++ -- ! 这些就是一元运算符号，？：组合是三元运算符号，其他的大多是二元运算符号。
2. Java运算符号详解
数学运算符号:
+ 加 ， - 减 ，* 乘 ，/ 除 ， % 模 ，++自增 ，--自减
数学运算的运算方式和结果大多和我们之前数学学习的相同。其中运算过程中又一些注意事项，下边我们通过代码学习和解释。
注意:所有的数学运算结果的类型，都以参与运算的最大的数据类型和精度为准。
例如：1+2.0 的结果是 3.0 ，1是int类型3.0是double类型。所以计算结果是double类型。再比如 int a=10；long b=100； a+b 的结果将是一个 long类型。如果想用变量来存储一个计算的结果必须要搞清楚计算结果的类型。
代码演示:
public class Demo1{
public static void main(String[] args){
// 数学运算
int a = 10;// int类型变量a 赋值为10
long b = 100;// long类型变量b 赋值为100
long c = a+b;// a和b计算的结果以 空间较大的数据类型long类型为准 所以c的类型是long
System.out.println(c);
}
}
运行结果:
分析一波：以上代码中，用来存储 a+b 结果的变量c 是long类型，因为a和b计算的结果以 较大的b的数据类型为准。这也衍生了一个情况，如果两个整数进行除法运算是获得不到小数结果的。如下：
代码演示:
public class Demo1{
public static void main(String[] args){
// 数学运算
int a = 10;//int类型变量a 赋值10
int b = 3;// int类型变量b 赋值3
System.out.println("a/b的结果是"+(a/b));// 两个计算结果不会出现小数
int c = 10;// int 类型变量c 赋值10
double d = 3.0;// double类型变量d 赋值3.0
System.out.println("c/d的结果是"+(c/d));// d是double类型 所以计算结果是小数
}
}
运行结果:
分析一波:
结果如上图，a和b都是整数所以结果也是整数，就没有小数点后的数字。而c和d计算d是double类型所以结果是double类型 ，就保留了小数点后的数字。也就是说想获得小数的结果必须要有小数参与运算。
注意：% 模运算的结果是 获得余数。如果%计算的结果是0证明被整除了。
代码演示：
public class Demo1{
public static void main(String[] args){
// 数学运算
System.out.println(10%2);// 余数为0
System.out.println(10%3);// 余数为1
System.out.println(10%4);// 余数为2
System.out.println(10%5);// 余数为0
}
}
执行结果:
递增和递减 ++ --
递增表示变量的值自己增加1，递减表示变量值自己减少1。递增和递减的符号有4种表现形式。 变量++，++变量，变量--，--变量。下面让我们来研究下他们的不同。我们从递增开始看，递增和递减的使用方式是一样的。首先我们先看下边一段代码：
代码演示：
public class Demo1{
public static void main(String[] args){
// 数学运算
int a = 10;
a++; // a变量的值 +1
System.out.println(a);
int b = 10;
++b; // b变量的值 +1
System.out.println(b);
int c = 10;
c--; // c变量的值 -1
System.out.println(c);
int d = 10;
--d; // d变量的值 -1
System.out.println(d);
}
}执行结果：
分析一波：分析上边的代码和结果。定义变量a赋值为10，之后a++执行自增输出结果为11，定义变量b也赋值，10 之后执行b++输出结果为11。在这里a++和++b的结果相同。也就是说如果一行代码只执行 变量++和++变量结果是一样的。那么他们就没有不同了吗？我们再来看下边的代码：
代码演示：
public class Demo1{
public static void main(String[] args){
// 数学运算
// 代码块1
int c = 10;
System.out.println(c++);// 先输出了c 然后再c+1
System.out.println(c);
System.out.println("-------");// 一条分割线
// 代码块2
int d = 10;
System.out.println(++d);// 先给d+1 然后输出d
System.out.println(d);
System.out.println("-------");// 一条分割线
// 代码块3
int x = 10;
int y = x++; //先给y赋值 之后x+1
System.out.println("x="+x);
System.out.println("y="+y);
System.out.println("-------");// 一条分割线
// 代码块4
int m = 10;
int n = ++m;//先给m+1 之后给n赋值
System.out.println("m="+m);
System.out.println("n="+n);
}
}执行结果:
分析一波:
如上所示：当++变量，变量++ 和赋值或输出一起使用的时候表现是不同的。如代码块1和2 的结果，代码块1先输出的 c++的结果是10，而代码块2先输出的++d的结果是11。在这里我们可以将 +1 和输出看成两步操作。 当代码是 变量++时表示先输出变量当前的值再给变量的值+1,当代码是++变量时表示先给变量的值+1再输出变量。我们在来观察代码块3和4 在 y和n赋值的时候 y = x++ 好n=++m，这里赋值和+1也可以看成两个操作，当++在后时 先执行赋值操作在个变量+1。当++在前时先执行给变量+1 在进行赋值操作。总结，当++变量和变量++在和赋值，输出等其他操作一起联合使用时，++在前表示先+1再使用，++在后表示先使用再+1。
赋值运算符号:
= 赋值 ，+= 加等于 ， -= 减等于 ， *= 乘等于 ， /= 除等于 ， %= 模等于
赋值符号=的功能是将 常量，变量 或者表达式的结果赋值给 = 前一个变量。在赋值的过程中运算顺序从右向左，将右边表达式的结果赋值给左边的变量。
代码演示：
public class Demo1{
public static void main(String[] args){
// 赋值运算
int a = 1; // 变量啊赋值为1
System.out.println(a);
int b = 2+1+1; // 变量b 赋值为 2+1+1 ,这里先计算结果再赋值
System.out.println(b);
int c = a; // 变量b 赋值为a 的值 也是1
System.out.println(c);
// 也可以一次 给多个变量赋值 ，单不推荐这样书写，可读性较差。
int x,y,z;// 一次定义三个int类型的变量 x y z
x = y = z = 100; //x y z 都赋值为100
System.out.println(x);
System.out.println(y);
System.out.println(z);
}
}运行结果：
分析一波：
注意:这里我们可以仔细观察一下，等号= 后可以是 一个常量值，表达式或者变量。但是等号=前一定要是一个变量。
+=，-=，*=，/=,%=特殊运算符号的使用，以+=为例：x+=3 相当于 x=x+3。首先进行x+3的运算在将运算结果赋值给变量x。其他的赋值符号以此类推。
代码演示:
public class Demo1{
public static void main(String[] args){
// 赋值运算
int x = 10;
x+=5;//这里的代码相当于 x = x+5; 也就是再x变量值10的基础上+5 再赋值给x
System.out.println(x);
}
}运行结果:
自行尝试:将 代码中的+= 换成 -= ， *= ， /= ， %= 结果有和变化 。
在程序中使用 +=,-=… 等符号完成赋值运算时强制类型转换会自动完成不需要显示的声明。
代码演示：
public class Demo1{
public static void main(String[] args){
// 赋值运算
byte a = 1; // a是byte类型
int b = 2; // b 是int类型
/*
注意下边这行代码 详单与a=a+b;
*/
a+=b;// 这里发生了一次自动的强制转换 将int类型结果转换为byte 赋值给a
System.out.println(a);
}
}运行结果:
分析一波: a是byte类型 ，b是int类型。 a+=b 代码相当于 a= a+b，但是 a和b相加结果应带是int类型。最终结果却在byte类型的a中。所以这里发生了一次没有显示声明的强制转换。
比较运算符号:
== 相等于 ， ！= 不等于 ， < 小于 ， > 大于 ， <= 小于等于 ， >= 大于等于
比较运算符号用于对两个数值或变量进行比较。所有比较运算的结果都是boolean值，也就是true或false，用来表示关系是否成立。在这里值得注意的是区分一个=号 表示赋值 两个等号 ==表示的是比较。比较运算和数学中使用的基本相同。
代码演示：这段代码有些多 建议按照注释分段 书写 执行 对照结果。
public class Demo1{
public static void main(String[] args){
// 比较运算
System.out.println(10>11);
// 比较结果赋值给 boolean类型变量
boolean b1 = 1<2;
System.out.println(b1);
// 变量和常量也可以比较
int n1 = 100;
boolean b2 = n1<=100;
System.out.println(b2);
// 变量和变量也可以比较
int n2 = 1;
boolean b3 = n2>=n1;
System.out.println(b3);
// == 表示 两边相等 才是true
System.out.println(1==1);
System.out.println(1==2);
System.out.println(1==3);
// != 表示 两边不等 才是 true
System.out.println(1!=1);
System.out.println(1!=2);
System.out.println(1!=3);
// 当数学运算和 比较运算 一起使用时先进行 数学运算再比较
System.out.pritnln(1+1>=1+2);
}
}
运行结果：
布尔运算符号:
& 与 ， && 短路与 ， | 或 ， || 短路或 ， ！非 ， ^ 异或
逻辑运算符号只能用于对boolean类型进行操作，其结果也是boolean类型。
这里我们需要先了解一些4种布尔运算的规则：
- 与（& 和&&） :两边都真才是真，一边为假就是假。
- 或（|和||）：两边都假才是假，一边为真就是真。
- 非（！）：非真即为假，非假即为真，取反。
- 异或（^）：两边相同就为真，两边不同就是假。
通过代码来具体了解规则的使用
代码演示:代码较多 建议 按照注释分块 逐步书写和 编译执行 对照查看结果。
public class Demo1{
public static void main(String[] args){
// 布尔运算
// && 号必须两边都是 true 最后结果为true
System.out.println(true && true);
// && 号只要有一边都是 fasle最后结果为false;
System.out.println(false && true);
System.out.println(true && false);
System.out.println(false && false);
// || 号有一边为 true 最后结果为true
System.out.println(true || true);
System.out.println(false || true);
System.out.println(true || false);
// || 号两边都是 false 最后结果为 false
System.out.println(false || false);
// ! 取反 非真即假 非假即真
System.out.println(! true);
System.out.println(! false);
// ^ 异或 两边相同就是假 两边不同就是真
System.out.println(true ^ true);
System.out.println(false ^ true);
System.out.println(true ^ false);
System.out.println(false ^ false);
}
}运行结果：
当让并不是只有 boolean值 true和false 才能使用这些符号，boolean类型的变量和结果时boolean类型的表达式也可以使用布尔符号进行计算。
代码演示:
public class Demo1{
public static void main(String[] args){
// 布尔运算
// 两个boolean类型变量进行运算
boolean b1 = true;
boolean b2 = false;
boolean b3 = b1&&b2;
System.out.println(b3);
// 两个比较表达式进行运算
boolean b4 = 1<2 && 2<1;
System.out.println(b4);
}
}运行结果:
关于短路：在逻辑运算中 && 和|| 相比 & | 的不同就是两个的会发生短路的现象。那么什么是短路的？我们先来观察下下边的代码和结果。
代码演示:
public class Demo1{
public static void main(String[] args){
// 布尔运算
int a = 1;
int b = 1;
/* 下边这行代码 ()内先执行赋值 a的值编程2
之后a<2 比较结果为 false
之后的符号是 &&运算 规则是一边为假就是假
所以这时整个 表达式的结果就是假了
&& 号之后的结果不管是什么 都不重要了
这时 && 后的代码就不执行了
这种情况就叫做短路
&& 后 b=2 没有执行 所以最后 b的结果还是1
*/
boolean c = (a=2)<2 && (b=2)>1;
System.out.println(a);
System.out.println(b);
System.out.println(c);
}
}运行结果:
分析一波:
如上方代码显示第5行 boolean c 赋值的代码。在这里赋值符号后的表达式(a=2) <2&&(b=2)>1 在这里我们先要执行 赋值操作 a=2 之后a的值是2 。然后执行a<2的比较。这是a的值是2 所以a<2的结果是false。我们中间使用了符号是&& 这时候&&前的值是false ，已经决定了最终的结果肯定是false。所以&& 后的 b=2的赋值是没有执行的。最后查看结果 a的值是2，b的值还是1。这就是所谓的短路：当&&和||号之前的值已经决定了整个表达式的结果，符号后的表达式不再执行。&&号前如果值是false将会短路。||前的值是true时将会短路。
字符串链接符号:
+ 字符串链接
字符串连接符号就是+号。而字符串连接符号就是出现在字符串值两边的+号。字符串连符表示将值原样接连接到字符串上，结果也是字符串。我们来观察以下代码和结果。
代码演示：
public class Demo1{
public static void main(String[] args){
// 字符串链接操作
// 下边一行代码的两个 + 号都是字符串链接操作
System.out.println("你好我的年龄是"+18+"岁");
// 下边一行的代码中 第 2 3 4 个+号都是字符串链接操作
System.out.println(1+1+"1"+1+1);
// 下边一行 因为有() 内的内容先计算 所以只有第 2 3 个加号是链接操作
System.out.println(1+1+"1"+(1+1));
// str变量是字符串内容所以 += 也做字符串链接操作
String str = "100";
str += 1;
System.out.println(str);
}
}运行结果：
分析一波:
输出 1+1+”1”+1+1 的结果是 “2111” ,根据结果我们可以看出第一个+号做得是数学运算。之后的所有+号做的都是字符串连接运算。输出1+1+”1”+(1+1)的结果是212，根据结果我们可以发现第一个+号和（）内的+号做的是数学运算，其余的+号做得是字符串连接运算。最后str+=1的运算可以转换成 str=str+1，因为str本身就是字符串类型的变量所以这里的+=也是做的字符串连接运算，最后str的值是1001。
三元运算符号:
? : 三元运算
条件运算符号由？和：两个符号组成。它的格式是这样的， 条件？ 选项1：选项2；？号前的条件表达式结果必须是boolean类型的结果。当？前的表达式值为true真的时就使用 ：前的选项1结果。当？前的表达式值1为false假的时就使用：后的选项2结果。
代码演示：
public class Demo1{
public static void main(String[] args){
// 三元运算
int a = 100;
int b = 200;
int c = a>b? a:b; // a>b 结果为假 c赋值为b
System.out.println(c);
}
}运行结果:
位运算符号:
& 按位与 ， | 按位或 ， ~ 取反 ， ^ 按位异或 ， << 左移 ， >> 右移 ， >>> 无符号右移
位运算使用的并不多，在这里不做过多演示想要了解的同学可以参照下边的代码自己学习一下。
位运算符主要针对二进制，它包括了：“与”、“非”、“或”、“异或”。从表面上看似乎有点像逻辑运算符，但逻辑运算符是针对两个关系运算符来进行逻辑运算，而位运算符主要针对两个二进制数的位进行逻辑运算。下面详细介绍每个位运算符。
1．与运算符
与运算符用符号“&”表示，其使用规律如下：
两个操作数中位都为1，结果才为1，否则结果为0，例如下面的程序段。
public class data13
{
public static void main(String[] args)
{
int a=129;
int b=128;
System.out.println("a 和b 与的结果是："+(a&b));
}
}
运行结果
a 和b 与的结果是：128
下面分析这个程序：
“a”的值是129，转换成二进制就是10000001，而“b”的值是128，转换成二进制就是10000000。根据与运算符的运算规律，只有两个位都是1，结果才是1，可以知道结果就是10000000，即128。
2．或运算符
或运算符用符号“|”表示，其运算规律如下：
两个位只要有一个为1，那么结果就是1，否则就为0，下面看一个简单的例子。
public class data14
{
public static void main(String[] args)
{
int a=129;
int b=128;
System.out.println("a 和b 或的结果是："+(a|b));
}
}
运行结果
a 和b 或的结果是：129
下面分析这个程序段：
a 的值是129，转换成二进制就是10000001，而b 的值是128，转换成二进制就是10000000，根据或运算符的运算规律，只有两个位有一个是1，结果才是1，可以知道结果就是10000001，即129。
3．非运算符
非运算符用符号“~”表示，其运算规律如下：
如果位为0，结果是1，如果位为1，结果是0，下面看一个简单例子。
public class data15
{
public static void main(String[] args)
{
int a=2;
System.out.println("a 非的结果是："+(~a));
}
}
4．异或运算符
异或运算符是用符号“^”表示的，其运算规律是：
两个操作数的位中，相同则结果为0，不同则结果为1。下面看一个简单的例子。
public class data16
{
public static void main(String[] args)
{
int a=15;
int b=2;
System.out.println("a 与 b 异或的结果是："+(a^b));
}
}
运行结果
a 与 b 异或的结果是：13
分析上面的程序段：a 的值是15，转换成二进制为1111，而b 的值是2，转换成二进制为0010，根据异或的运算规律，可以得出其结果为1101 即13。
移位运算符也针对二进制的“位”，它主要包括：左移位运算符（<<）、右移位运算符（>>>）、带符号的右移位运算符（>>）。
1．左移运算符
左移运算符用“<<”表示，是将运算符左边的对象，向左移动运算符右边指定的位数，并且在低位补零。其实，向左移n 位，就相当于乘上2 的n 次方，例如下面的例子。
public class data17
{
public static void main(String[] args)
{
int a=2;
int b=2;
System.out.println("a 移位的结果是："+(a<<b));
}
}
运行结果
a 移位的结果是：8
分析上面的程序段：
首先从本质上来分析，2 的二进制是00000010，它向左移动2 位，就变成了00001000，即8。如果从另一个角度来分析，它向左移动2 位，其实就是乘上2 的2 次方，结果还是8。
2．右移运算符
右移运算符用符号“>>>”表示，是将运算符左边的对象向右移动运算符右边指定的位数，并且在高位补0，其实右移n 位，就相当于除上2 的n 次方。
public class data18
{
public static void main(String[] args)
{
int a=16;
int b=2;
System.out.println("a 移位的结果是："+(a>>>b));
}
}
运行结果
a 移位的结果是：4
分析上面的程序段：从本质上来分析，16 的二进制是00010000，它向右移动2 位，就变成了00000100，即4。如果从另一个角度来分析，它向右移动2 位，其实就是除以2 的2 次方，结果还是4。
3．带符号的右移运算符
带符号的右移运算符用符号“>>”表示，是将运算符左边的运算对象，向右移动运算符右边指定的位数。如果是正数，在高位补零，如果是负数，则在高位补1，先看下面一个简单的例子。
public class data19
{
public static void main(String[] args)
{
int a=16;
int c=-16;
int b=2;
int d=2;
System.out.println("a 的移位结果："+(a>>b));
System.out.println("c 的移位结果："+(c>>d));
}
}
运行结果
a 的移位结果：4
c 的移位结果：-4
分析上面的程序段：
a 的值是16，转换成二进制是00010000，让它右移两位成00000100 即4。
c 的值是-16，转换成二进制是11101111，让它右移一位成11111011 即-4。
3. 表达式的自动提升
表达式的自动提升是一种特殊的情况，之前我们我们说过 :所有的数学运算结果的类型，都以参与运算的最大的数据类型和精度为准。但是当参与运算的变量都是较小的数据类型时，为了防止运算结果变大导致容纳不下发生异常，这是的表达式结果类型会自动提升变大。
代码演示：
public class Demo1{
public static void main(String[] args){
// 数学运算
byte a = 1;
byte b = 2;
// 这里 两个byte类型相加 貌似会得到一个byte类型的结果
byte c = a + b; // 但是这里编译时会报错 因为结果会自动提升为 int类型
System.out.println(c);
}
}运行结果：
分析一波：所有的byte型. short型和char型在计算的时候将被自动提升到int型(例外: final修饰的short, char变量相加后不会被自动提升。)
所以我们修改代码中的第7行的 c的类型为 int后代码将可以正常编译和执行。
代码演示：
public class Demo1{
public static void main(String[] args){
// 数学运算
byte a = 1;
byte b = 2;
// 将之前的byte 类型修改为int
int c = a + b; // 此处可以顺利编译了
System.out.println(c);
}
}运行结果：
4. 运算符号的优先级
在我们之前学过的数学中有 "先乘除后加减的口诀"。编程中的计算也有优先级。我们简单来了解一下就可以，因为程序中运算时自动按优先级进行的。只要我们能读懂就可以，编程中运算中也是可以添加小括号的，也是先算括号里后算括号外。
我试着看一个口诀： 单目乘除位关系，逻辑三目后赋值。
单目：单目运算符+ –(负数) ++ -- 等
乘除：算数单目运算符* / % + -
位：位移单目运算符<< >>
关系：关系单目运算符> < >= <= == !=
逻辑：逻辑单目运算符&& || & | ^
三目：三目单目运算符A > B ? X : Y
赋值：赋值=
也可以简单看一下，下边的表格
1258
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
