目标：
1.了解各种运算符
一、运算符
1.运算符：进行特定操作的符号。例如：+
2.表达式：用运算符连起来的式子叫做表达式。例如：20 + 5。又例如：a + b
1.算数运算符：
1.种类
+ 加法运算，字符串连接运算
- 减法运算
* 乘法运算
/ 除法运算
% 取模运算，两个数字相除取余数
++、-- 自增自减运算
2.注意点
1) 对于一个整数的表达式来说，除法用的是整除，整数除以整数，结果仍然是整数。只看商，余数直接舍去
2) 只有对于整数的除法来说，取模运算符才有余数的意义。
3) 一旦运算当中有不同类型的数据，那么结果将会是数据类型范围大的那种。
3.代码
public class OperatorTest1 {
public static void main(String[] args) {
// 两个常量之间可以进行数学运算
System.out.println(20 + 30);
// 两个变量之间也可以进行数学运算
int a = 20;
int b = 30;
System.out.println(a - b); // -10
// 变量和常量之间可以混合使用
System.out.println(a * 10); // 200
int x = 10;
int y = 3;
int result1 = x / y;
System.out.println(result1); // 3
int result2 = x % y;
System.out.println(result2); // 余数，模，1
// int + double --> double + double --> double
double result3 = x + 2.5;
System.out.println(result3); // 12.5
}
}
4.四则运算当中的加号“+”有常见的三种用法：
1) 对于数值来说，那就是加法。
2) 对于字符char类型来说，在计算之前，char会被提升成为int，然后再计算。
char类型字符，和int类型数字，之间的对照关系表：ASCII、Unicode
3) 对于字符串String（首字母大写，并不是关键字）来说，加号代表字符串连接操作。
任何数据类型和字符串进行连接的时候，结果都会变成字符串
5.自增运算符：++ 自减运算符：--
1) 基本含义：让一个变量涨一个数字1，或者让一个变量降一个数字1
2) 使用格式：写在变量名称之前，或者写在变量名称之后。例如：++num，也可以num++
3) 使用方式：
1. 单独使用：不和其他任何操作混合，自己独立成为一个步骤。
2. 混合使用：和其他操作混合，例如与赋值混合，或者与打印操作混合，等。
4) 使用区别：
1. 在单独使用的时候，前++和后++没有任何区别。也就是：++num;和num++;是完全一样的。
2. 在混合的时候，有【重大区别】
A. 如果是【前++】，那么变量【立刻马上+1】，然后拿着结果进行使用。 【先加后用】
B. 如果是【后++】，那么首先使用变量本来的数值，【然后再让变量+1】。 【先用后加】
5) 注意事项：
只有变量才能使用自增、自减运算符。常量不可发生改变，所以不能用。
6)代码：
public class OperatorTest2 {
public static void main(String[] args) {
int num1 = 10;
System.out.println(num1); // 10
++num1; // 单独使用，前++
System.out.println(num1); // 11
num1++; // 单独使用，后++
System.out.println(num1); // 12
System.out.println("=================");
// 与打印操作混合的时候
int num2 = 20;
// 混合使用，先++，变量立刻马上变成21，然后打印结果21
System.out.println(++num2); // 21
System.out.println(num2); // 21
System.out.println("=================");
int num3 = 30;
// 混合使用，后++，首先使用变量本来的30，然后再让变量+1得到31
System.out.println(num3++); // 30
System.out.println(num3); // 31
System.out.println("=================");
int num4 = 40;
// 和赋值操作混合
int result1 = --num4; // 混合使用，前--，变量立刻马上-1变成39，然后将结果39交给result1变量
System.out.println(result1); // 39
System.out.println(num4); // 39
System.out.println("=================");
int num5 = 50;
// 混合使用，后--，首先把本来的数字50交给result2，然后我自己再-1变成49
int result2 = num5--;
System.out.println(result2); // 50
System.out.println(num5); // 49
System.out.println("=================");
int x = 10;
int y = 20;
// 11 + 20 = 31
int result3 = ++x + y--;
System.out.println(result3); // 31
System.out.println(x); // 11
System.out.println(y); // 19
// 30++; // 错误写法！常量不可以使用++或者--
}
}
-
赋值运算符
1) 赋值运算符分为： 基本赋值运算符：就是一个等号“=”，代表将右侧的数据交给左侧的变量。 int a = 30; 复合赋值运算符： += a += 3 相当于 a = a + 3 -= b -= 4 相当于 b = b - 4 *= c *= 5 相当于 c = c * 5 /= d /= 6 相当于 d = d / 6 %= e %= 7 相当于 e = e % 7 2) 注意事项： 1. 只有变量才能使用赋值运算符，常量不能进行赋值。 2. 复合赋值运算符其中隐含了一个强制类型转换。 3) 代码 public class OperatorTest3 { public static void main(String[] args) { int a = 10; // 按照公式进行翻译：a = a + 5 // a = 10 + 5; // a = 15; // a本来是10，现在重新赋值得到15 a += 5; System.out.println(a); // 15 int x = 10; // x = x % 3; // x = 10 % 3; // x = 1; // x本来是10，现在重新赋值得到1 x %= 3; System.out.println(x); // 1 // 50 = 30; // 常量不能进行赋值，不能写在赋值运算符的左边。错误写法！ byte num = 30; // num = num + 5;报错 // num = byte + int // num = int + int // num = int num为byte，而右边为int num += 5;//隐含强制类型转换num = (byte) int System.out.println(num); // 35 } }3.比较运算符
大于： > 小于： < 大于等于： >= 小于等于： <= 相等： == 【两个等号连写才是相等，一个等号代表的是赋值】 不相等： != 注意事项： 1. 比较运算符的结果一定是一个boolean值，成立就是true，不成立就是false 2. 如果进行多次判断，不能连着写。 数学当中的写法，例如：1 < x < 3 程序当中【不允许】这种写法。应当这样1<x && x<3 public class OperatorTest4 { public static void main(String[] args) { System.out.println(10 > 5); // true int num1 = 10; int num2 = 12; System.out.println(num1 < num2); // true System.out.println(num2 >= 100); // false System.out.println(num2 <= 100); // true System.out.println(num2 <= 12); // true System.out.println("==============="); System.out.println(10 == 10); // true System.out.println(20 != 25); // true System.out.println(20 != 20); // false int x = 2; // System.out.println(1 < x < 3); // 错误写法！编译报错！不能连着写。 } }
4.逻辑运算符
与（并且） && 全都是true，才是true；否则就是false
或（或者） || 至少一个是true，就是true；全都是false，才是false
非（取反） ! 本来是true，变成false；本来是false，变成true
与“&&”，或“||”，具有短路效果：如果根据左边已经可以判断得到最终结果，那么右边的代码将不再执行，从而节省一定的性能。
注意事项：
1. 逻辑运算符只能用于boolean值。
2. 与、或需要左右各自有一个boolean值，但是取反只要有唯一的一个boolean值即可。
3. 与、或两种运算符，如果有多个条件，可以连续写。
两个条件：条件A && 条件B
多个条件：条件A && 条件B && 条件C
对于1 < x < 3的情况，应该拆成两个部分，然后使用与运算符连接起来：
int x = 2; 1 < x && x < 3;
4.代码
public class OperatorTest5 {
public static void main(String[] args) {
System.out.println(true && false); // false
// true && true --> true
System.out.println(3 < 4 && 10 > 5); // true
System.out.println("============");
System.out.println(true || false); // true
System.out.println(true || true); // true
System.out.println(false || false); // false
System.out.println("============");
System.out.println(true); // true
System.out.println(!true); // false
System.out.println("============");
int a = 10;
// false && ...
System.out.println(3 > 4 && ++a < 100); // false
System.out.println(a); // 10
System.out.println("============");
int b = 20;
// true || ...
System.out.println(3 < 4 || ++b < 100); // true
System.out.println(b); // 20
}
}
5.移位操作符
1)分类：
>> : 算术右移位运算，也称做带符号右移位运算。
>>> : 逻辑右移位运算，也称为不带符号右移位运算。高位补0
<< : 左移位运算，也称为不带符号左移位运算。
2)举例以及介绍
1. >>：
int a1 = 12 >> 1; //a1变量的取值为6;
int a2 = 128 >> 2; //a2变量的取值为32;
int a3 = 130 >> 2; //a3变量的取值为32;
int a3 = 12 >> 33 ; //a3变量的取值为6;
算数右移动的公式: 数字(正数)/2^n(n表示移动位数).
即使除不尽也不要紧,商就是最后需要保留数(计算的数)，即舍去小数位
移动位数n 如果n>32 使用n%32做为移动的位数
注解：
a. 对12右移一位的过程为：舍弃二进制数的最后一位，在二进制数的开头增加一位符号位，由于12是正整数，因此增加的符号位为0;
b. 对-12右移二位的过程为：舍弃二进制数的最后二位，在二进制数的开头增加二位符号位，由于-12是负整数,因此增加的符号位为1;
2.<<<：
int a1 = 12 >>> 1; //a1变量的取值为6;
int a2 = -12>>>1; //a2变量的取值为2147483642;
注解：无论是正数还是负数高位补0，负数的无符号位右移一定为非负数
3.>>:
int a1 = 12 << 1; //a1变量的取值为24;
int a2 = -12 << 2; //a2变量的取值为-48;
int a3 = 128 << 2; //a3变量的取值为512;
int a4 = -1 << 2; //a4变量的取值为-4;
左移:由于没有符号位，对于负数而言,也不需要求负数的源码.可以直接使用负数对应的正数的补码来进行移位运行不需要分情况,
可以直接使用公式:数字(不区分正负数)*2^n(n表示移动位数)
注解：
a. 对12左移一位的过程为：舍弃二进制数的开头一位，在二进制数的尾部增加一个0;
b. 对-12左移二位的过程为：舍弃二进制数的开头二位，在二进制数的尾部增加二个0;
6.位运算操作符：
& : 与运算，对两个操作元的每个二进制位进行与运算，
运算规则为：1&1->1, 1&0->0, 0&1->0, 0&0->0;
全1为1,有0为0
1010&0001 = 0000
| : 或运算，对两个操作元的每个二进制位进行或运算，
运算规则为：1|1->1, 1|0->1, 0|1->1, 0|0->0;
全0为0,有1为1
1010 | 0001 1011
^ : 异或运算，对两个操作元的每个二进制位进行或运算，
运算规则为：1^1->0, 1^0->1, 0^1->1, 0^0->0;
两个值相同，为0， 不同为1；
1010 ^ 0001 1011
~ : 取反运算, ~1->0, ~0->1;
~0000 1010
注意：
&& 具有短路效应，而&也可以作为逻辑操作符，与&&相同但是没有短路效应
||同样具有短路效应，而|也可以作为逻辑操作符，与||相同但是没有短路效应
7.三元运算符
一元运算符：只需要一个数据就可以进行操作的运算符。例如：取反!、自增++、自减--
二元运算符：需要两个数据才可以进行操作的运算符。例如：加法+、赋值=
三元运算符：需要三个数据才可以进行操作的运算符。
1.格式：
数据类型 变量名称 = 条件判断 ? 表达式A : 表达式B;
2.流程：
首先判断条件是否成立：
如果成立为true，那么将表达式A的值赋值给左侧的变量；
如果不成立为false，那么将表达式B的值赋值给左侧的变量；
二者选其一。
3.注意事项：
1. 必须同时保证表达式A和表达式B都符合左侧数据类型的要求。
2. 三元运算符的结果必须被使用。
4.代码
public class OperatorTest6 {
public static void main(String[] args) {
int a = 10;
int b = 20;
// 数据类型 变量名称 = 条件判断 ? 表达式A : 表达式B;
// 判断a > b是否成立，如果成立将a的值赋值给max；如果不成立将b的值赋值给max。二者选其一
int max = a > b ? a : b; // 最大值的变量
System.out.println("最大值：" + max); // 20
// int result = 3 > 4 ? 2.5 : 10; // 错误写法！
System.out.println(a > b ? a : b); // 正确写法！
// a > b ? a : b; // 错误写法！
}
}
6.注意点：
1.对于byte/short/char三种类型来说，如果右侧赋值的数值没有超过范围，
那么javac编译器将会自动隐含地为我们补上一个(byte)(short)(char)。
如果没有超过左侧的范围，编译器补上强转。
如果右侧超过了左侧范围，那么直接编译器报错。
2. 代码
public class NoticeTest1 {
public static void main(String[] args) {
// 右侧确实是一个int数字，但是没有超过左侧的范围，就是正确的。
// int --> byte，不是自动类型转换
byte num1 = /*(byte)*/ 30; // 右侧没有超过左侧的范围
System.out.println(num1); // 30
// byte num2 = 128; // 右侧超过了左侧的范围
// int --> char，没有超过范围
// 编译器将会自动补上一个隐含的(char)
char zifu = /*(char)*/ 65;
System.out.println(zifu); // A
}
}
3.编译器的常量优化：
在给变量进行赋值的时候，如果右侧的表达式当中全都是常量，没有任何变量，
那么编译器javac将会直接将若干个常量表达式计算得到结果。
例如：
short result = 1 + 2; // 等号右边全都是常量，没有任何变量参与运算
编译之后，得到的.class字节码文件当中相当于【直接就是】：
short result = 3;
注意：一旦表达式当中有变量参与，那么就不能进行这种优化了。
4.代码：
public class NoticeTest2 {
public static void main(String[] args) {
short num1 = 10; // 正确写法，右侧没有超过左侧的范围，
short a = 5;
short b = 8;
// short + short --> int + int --> int
// short result = a + b; // 错误写法！左侧需要是int类型
// 右侧不用变量，而是采用常量，而且只有两个常量，没有别人
short result = 5 + 8;
System.out.println(result);
short result2 = 5 + a + 8; // 18
}
}
7.扩展题目
1.下面的程序有问题吗？
public static void main(String[] args){
short s = 1;
s+=1;
System.out.println(s);
}
解析：
1) s += 1 逻辑上看作是 s = s + 1 计算结果被提升为int类型，再向short类型赋值时发生错误，因为不能将取值范围大的类型赋值到取值范围小的类型。
2) 但是， s=s+1进行两次运算 ， += 是一个运算符，只运算一次，并带有强制转换的特点，
3) 也就是说 s += 1 就是 s = (short)(s + 1) ，因此程序没有问题编译通过，运行结果是2.
2.下面的程序有问题吗？
public static void main(String[] args){
byte b1=1;
byte b2=2;
byte b3=1 + 2;
byte b4=b1 + b2;
System.out.println(b3);
System.out.println(b4);
}
解析：
1) b3 = 1 + 2 ， 1 和 2 是常量，为固定不变的数据，
2) 在编译的时候（编译器javac），已经确定了 1+2 的结果并没有超过byte类型的取值范围
3) 可以赋值给变量 b3 ，因此 b3=1 + 2 是正确的。
4) 反之， b4 = b2 + b3 ， b2 和 b3 是变量，
5) 变量的值是可能变化的，在编译的时候，编译器javac不确定b2+b3的结果是什么，
6) 因此会将结果以int类型进行处理，所以int类型不能赋值给byte类型，因此编译失败。
扫一扫
209
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
