运算符是一种特殊的符号，用以表示数据的运算、赋值，比较等。
2. 二元运算符 2.1加减乘除（+ - * /）public class Operator {
public static void main(String[] args) {
//二元运算符
int a = 10;
int b = 15;
int c = 20;
int d = 25;
double d1 = 10/4; //计算结果先为int 取2，然后转换为double类型取2.0
System.out.println(a+b); // 25
System.out.println(a-b); // -5
System.out.println(a*b); // 150
//System.out.println(a/b); 0 结果为int，数据取整为0
System.out.println(a/(double)b); //0.666
System.out.println(d1); // 2.0 计算结果先为int 取2，然后转换为double类型取2.0
}
}
如果运算数据中存在long类型，那么运算结果也为long类型，其余为int；如果运算数据中存在double类型，那么运算结果也为double类型。
public class Operator {
public static void main(String[] args) {
long a = 123456789L;
int b = 123;
short c = 10;
byte d = 8;
System.out.println(a+b+c+d); // 123456930 long类型
System.out.println(b+c+d); // 141 int
System.out.println(c+d); // 18 int
// 如果运算数据中存在long类型，那么运算结果也为long类型，其余为int
System.out.println((double)c+d); // 18.0 double
System.out.println("=================================================");
double e = 10.2;
long f = 123L;
System.out.println(f+b+c+d+e); // 274.2 double类型
System.out.println(b+c+d+e); // 151.2 double
System.out.println(c+d+e); // 28.2 double
System.out.println(d+e); // 18.2 double
// 如果运算数据中存在double类型，那么运算结果也为double类型
}
}
2.2 模运算（%）
public class Operator {
public static void main(String[] args) {
//% 模运算，即取余数
//% 模运算的本质即一个公式：a % b = a - a / b * b
int a = 10;
int b = 20;
int c = 23;
System.out.println(c%a);// 3 23/10=2...3 ===> 23/10=23-23/10*10=23-20=3
System.out.println(c%b);// 3 23/20=1...3
System.out.println(c%c);// 0 23/23=1...0
//% 当 a 是小数时 模运算的本质即一个公式：a % b = a - (int)a / b * b
System.out.println(-10.5%3); // -1.5 的近似值 有小数运算，得到的结果是近似值
}
}
3. 一元运算 自增（++）、自减（–）
自增（++）、自减（–）作为独立的语句使用，i++ 和 ++i 都完全等价与 i = i + 1; 作为表达式使用时：
i++ 表示：先赋值后自增；
++i 表示：先自增后赋值；
例:
public class Operator {
public static void main(String[] args) {
// 一元运算
//++ 自增 a++即为 a=a+1
//-- 自减 a--即为 a=a-1
int a = 3;
System.out.println(a); // 3
//a++ 先赋值，再自加
int b = a++; // 先赋值，此时b=3，再自加，此时a=4
System.out.println(a); // a=4
//a++ 先自加，再赋值
int c = ++a; // 先自加，此时 a=5，再赋值给c，此时c=5
System.out.println(a); // a=5
System.out.println(a); // 5
System.out.println(b); // 3
System.out.println(c); // 5
}
}
分析如下:
4.关系运算符- 4.1 关系运算符返回的结果为Boolean类型：true、false ，经常与if语句一同使用。
- 4.2 关系运算符组成的表达式称为关系表达式，例a>b。
- 4.3 比较运算符为"==“，不能写为”="。
public class Operator {
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 23;
System.out.println(a>b); //false
System.out.println(a=b); //false
System.out.println(a<=b); //true
System.out.println(a!=b);// true 不等于
}
}
5.逻辑运算符
-
5.1 逻辑运算符用于连接多个条件（多个表达式），最终的结果也是一个Boolean值；
-
5.2 常用的逻辑运算符为： && (短路与) ||(短路或) ！非(取反)
& (逻辑与) | (逻辑或) ^ (逻辑异或) ~ (逻辑取反)
public class LogicOperator {
public static void main(String[] args) {
//and(与) or(或) 非 (取反)
//&& || ！
boolean a = true;
boolean b = false;
System.out.println("a&&b:"+(a&&b)); // false 逻辑与运算:真真为真；
System.out.println("a||b:"+(a||b)); // true 逻辑与运算:遇真为真；
System.out.println("!(a&&b:)"+!(a&&b)); // true 逻辑与运算:变假为真，变真为假；
System.out.println("==========================");
//短路运算
int c = 5;
boolean d = (c<4)&&(c++<4);
System.out.println(d); // false 错误后&&后面的代码不再执行
//对于短路与而言，第一个条件为false，后面的代码便不会执行。
System.out.println(c); // 5
// & | ^ ~
int i = 5;
boolean l = (i<4)&(++i<4); //false 错误后&后面的代码仍然会执行并判断
System.out.println(i);// 6
//对于逻辑与而言，第一个条件为false，后面的代码仍会执行。
//开发过程中基本上使用短路与&&，效率较高；短路或、逻辑或同理
}
}
- 5.3 练习01
public class Operator {
public static void main(String[] args) {
//练习01
int x = 5;
int y = 5;
if(x++ == 6 & ++y == 6){
x = 11;
}
System.out.println("x=" + x,"y=" + y); // x = 6，y = 6；
}
}
- 5.4 练习02
public class Operator {
public static void main(String[] args) {
//练习02
int x = 5;
int y = 5;
if(x++ == 6 && ++y == 6){
x = 11;
}
System.out.println("x=" + x,"y=" + y); // x = 6，y = 5；
}
}
- 5.4 练习03
public class Operator {
public static void main(String[] args) {
//练习03
int x = 5;
int y = 5;
if(x++ == 5 | ++y == 5){
x = 11;
}
System.out.println("x=" + x,"y=" + y); // x = 11，y = 6；
}
}
- 5.4 练习04
public class Operator {
public static void main(String[] args) {
//练习04
int x = 5;
int y = 5;
if(x++ == 5 || ++y == 5){
x = 11;
}
System.out.println("x=" + x,"y=" + y); // x = 11，y = 5；
}
}
- 5.5 练习05
public class Operator {
public static void main(String[] args) {
//练习05
boolean x = true;
boolean y = false;
short z = 46;
if(z++ == 46 && y = true){
z++;
}
if(x = false || ++z == 49){
z++;
}
System.out.println("z=" + z); // z = 50；
//经测试：赋值语句作为判断条件时，赋值后的布尔变量作判断条件，也就是返回左值。
}
}
6.位运算符（含重点）
6.1位运算 <<(算术左移) >>(算术右移) >>>(逻辑右移)
6.1.1 <<(算术左移)
运算规则：符号位不变，低位补0。
6.1.2 >>(算术右移) 运算规则：低位溢出，符号位不变，并用符号位补溢出的高位。
6.1.3 >>>(逻辑右移) 也叫无符号右移 运算规则：低位溢出，高位补0。
6.1.4 特殊说明，没有 <<< 符号public class BitOperator {
public static void main(String[] args) {
int a = 1 >> 2;// 1 向右位移 2位 相当于 1 /2 /2
int b = 1 << 2;// 1 向左位移 2位 相当于 1 *2 *2
int c = 15>> 2;// 15向左位移 2位 相当于 15/2 /2
int d = 4 << 2;// 4 向左位移 2位 相当于 4 *2 *2
System.out.println(2<<3); // 16
}
}
6.2 ~ （按位取反） & （按位与） |（按位或） ^ （按位异或）
例：
public class BitOperator {
public static void main(String[] args) {
A = 0011 1100
B = 0000 1101
A & B = 0000 1100 // 按位与，A、B每一位数均为1取1，否则取0，真真为真
A | B = 0011 1101 // 按位或，A、B每一位数均为0取0，否则取1，假假为假
A ^ B = 0011 0001 // 按位异或，A、B每一位数相同为0，不同为1
~ B = 1111 0010 // 按位取反，每一位数都与B完全相反 （0变1,1变0）
}
}
6.3 原码、反码、补码（重点）
6.3.1 运算规则：
对于有符号的数而言：
- 1.二进制的最高位是符号位: 0表示正数，1表示负数。
- 2.正数的原码、反码、补码是一样的。(三码合一)
- 3.负数的反码 = 它的原码符号位不变，其他位取反。（符号位不变，0变1,1变0）
- 4.负数的补码 = 它的反码 + 1。（负数的反码 = 负数的补码 - 1）
- 5.0的反码、补码都是0。
- 6.java没有无符号数，换言之，java中的数都是有符号的。（数据有符号）
- 7.在计算机运算的时候，都是以补码的形式来运算的。（运算用补码，补码是为了将正数、负数统一起来）
- 8.当我们查看运算结果的时候，应该查看它的原码。（结果看原码）
public class BitOperator {
public static void main(String[] args) {
// 01 2&3
System.out.println(2&3); // 2
// 02 ~-2
System.out.println(~-2); // 1
// 02 ~2
System.out.println(~-2); // -3
}
}
7 三元运算符
- 7.1 基本语法：条件表达式？表达式1：表达式2;
- 7.2 如果条件表达式的结果为true，那么运算后的结果为表达式1；如果条件表达式的结果为false，那么运算后的结果为表达式2。
- 7.3 表达式1和表达式2应为可以赋值给接受变量的值或者类型（或者可以自动转换、或者进行强制转换）。
- 7.4 三元运算符可以转换为if-else语句。
- 7.5 例：
public class TernaryOperator {
public static void main(String[] args) {
//三元运算符
//x ? y : z
//如果 x==true，则结果为y，否则结果为z
//必须掌握
int socre = 80;
String type = socre < 60 ? "不及格" : "及格";
System.out.println(type); // 及格
//可以转换为if 语句
int a = 10;
int b = 99;
int result = a > b ? a++ :--b ;
System.out.println(result); // 98
}
}
- 7.6 练习
public class TernaryOperator {
public static void main(String[] args) {
//实现三个数中的最大值
int num1 = 10;
int num2 = 50;
int num3 = 40;// 定义三个数值。
int max1 = num1 >= num2 ? num1 : num2;
int max2= num2 >= num3 ? num2 : num3; // 两两进行比较，选出较大的两个值。
int max3= max1 >= max2 ? max1 : max2; // 较大的值进行比较，选出最大的值。
System.out.println("最大值为:"+max3); // 50
}
}
8 赋值运算符
- 8.1 赋值运算符就是将某个运算后的值赋给制定的变量。
- 8.2 基本赋值运算符为 " = ",例: int i = 10；
- 8.3 复合赋值运算符为 " += "、 " -= "、 " *= "、 " /= "。
- 8.4 以 " += " 、" -= "为例进行说明：
public class AssignOperator {
public static void main(String[] args) {
int a = 10;
int b = 20;
a+=b; // 等价于a = a+b; 10+20=30
a-=b; // 等价于a = a-b; 30-20=10
//字符串连接符 +
System.out.println(a+b); //30 10+20
System.out.println(""+a+b); // 1020 10与20拼接 如果前面有字符串，运算时会自动把后面的转化为字符串
System.out.println(a+b+""); // 30 10+20 再拼接
}
}
- 8.5 赋值运算的特点：
8.5.1 赋值运算的运算顺序为从右往左，即先计算 " = "右边的运算，然后再赋值给 " = "左边的变量。
8.5.2 赋值运算" = "的左边只能是变量，右边可以是变量、表达式、常量值。
8.5.3 复合赋值运算符会进行类型的转换，例：
public class AssignOperator {
public static void main(String[] args) {
byte b = 3;
//自动进行类型转换
b += 2;//等价于 b =(byte)(b+2);运算结果类型为byte。
b++; //等价于 b =(byte)(b+1);
//常规情况
b = b + 2;// 运行报错，2为int类型，b+2结果为int类型，无法自动转换为byte类型。
//字符串连接符 +
System.out.println(a+b); //30 10+20
System.out.println(""+a+b); // 1020 10与20拼接 如果前面有字符串，运算时会自动把后面的转化为字符串
System.out.println(a+b+""); // 30 10+20 再拼接
}
}
9 运算符优先级
- 9.1 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。
- 9.2 只有单目运算（一元）、赋值运算是从右向左运算的。
- 9.3 优先级排序（由上到下，由高到低）
| . （） {} ； ， | 备注 | |
|---|---|---|
| 自右向左 | ++、–、~、！（data type） | |
| 自左向右 | *、/、% | |
| 自左向右 | +、- | |
| 自左向右 | <<、>>、>>> 位移 | |
| 自左向右 | <、>、<=、>=、instance of | |
| 自左向右 | ==、!= | |
| 自左向右 | & | |
| 自左向右 | ^ | |
| 自左向右 | | | |
| 自左向右 | && | |
| 自左向右 | || | |
| 自左向右 | ? : ； | |
| 自左向右 | =、*=、/=、%= | |
| 自左向右 | +=、-=、<<=、>>= | |
| 自左向右 | >>>=、&=、^=、|= |
