1 运算符
1.1 概述
运算符 用于连接 表达式 的 操作数，并对操作数执行运算。
例如，表达式num1+num2，其操作数是num1和num2，运算符是”+”。
在java语言中，运算符可分为5种类型：
算术运算符、赋值运算符、关系运算符、逻辑运算符、位运算符。
根据操作数的不同，运算符又分为单目运算符、双目运算符和三目运算符。
单目运算符只有一个操作数，双目运算符有两个操作数，三目运算符则有三个操作数。
位运算符涉及到二进制位的运算，在java 程序中运用不是很多。
1.2 运算符速查表
基本数据类型与 String 的运算
概念：
字符串类型：String
String 不是基本数据类型，属于引用数据类型
使用一对""来表示一个字符串，内部可以包含 0 个、1 个或多个字符。
声明方式与基本数据类型类似。例如：String str = “创炎教育”;
运算规则 1、任意八种基本数据类型的数据与 String 类型只能进行连接“+”运算，且结果 一定也是 String 类型
运算规则 1、任意八种基本数据类型的数据与 String 类型只能进行连接“+”运算，且结果
一定也是 String 类型
System.out.println("" + 1 + 2);//12
int num = 10;
boolean b1 = true;
String s1 = "abc";
String s2 = s1 + num + b1;
System.out.println(s2);//abc10true
//String s3 = num + b1 + s1;//编译不通过，因为 int 类型不能与 boolean 运算
String s4 = num + (b1 + s1);//编译通过
2、String 类型不能通过强制类型()转换，转为其他的类型
String str = "123";
int num = (int)str;//错误的
int num = Integer.parseInt(str);//正确的，后面才能讲到，借助包装类的方法才能转
举例 2：“+”号的两种用法
第一种：对于+两边都是数值的话，+就是加法的意思
第二种：对于+两边至少有一边是字符串的话，+就是拼接的意思
public class ArithmeticTest2 {
public static void main(String[] args) {
// 字符串类型的变量基本使用
// 数据类型 变量名称 = 数据值;
String str1 = "Hello";
System.out.println(str1); // Hello
System.out.println("Hello" + "World"); // HelloWorld
String str2 = "Java";
// String + int --> String
System.out.println(str2 + 520); // Java520
// String + int + int
// String + int
// String
System.out.println(str2 + 5 + 20); // Java520
}
}
2、String 类型不能通过强制类型()转换，转为其他的类型
String str = "123";
int num = (int)str;//错误的
int num = Integer.parseInt(str);//正确的，后面才能讲到，借助包装类的方法才能转
1.3 练习：测试自增自减
创建包: cn.tedu.basic
创建类: TestOperator.java
package cn.tedu.basic;
/**本类用于测试取余运算符*/
public class TestOperator {
//0.创建程序的入口函数main
public static void main(String[] args) {
//1.测试除法与取余数
System.out.println(25 / 10);//2
System.out.println(25 % 10);//5
/**
* 在使用%运算符的时候如果被除数小于除数。
* 那么，打印的结果就是被除数
* */
System.out.println(2%3);
System.out.println(5%6);
/*
* 在除数中如果，被除数小于除数。那么，打印的结果是0
* */
System.out.println(5/6);
//2.练习1：获取一个两位数59的十位与个位
int x = 59;
System.out.println(x/10);//打印十位,5
System.out.println(x%10);//打印个位,9
//3.练习2：获取一个三位数159的百位、十位与个位
int y = 159;
System.out.println(y / 100);//打印百位
System.out.println(y / 10 % 10);//打印十位
System.out.println(y % 10);//打印个位
//4.测试自增自减运算符
/** 前缀式：符号在前：++a --a ,先改变变量本身的值，再使用，比如打印
* 后缀式：符号在后: a++ a--，先使用，再改变变量本身的值
* ++: 相当于给变量本身的值+1
* --: 相当于给变量本身的值-1
* */
System.out.println("我是一个无情的分界线");
int a = 1;
System.out.println(++a);//2
System.out.println(a);//2
int b = 1;
System.out.println(b++);//1
System.out.println(b);//2
int c = 1;
System.out.println(--c);//0,符号在前，先自减，再打印
System.out.println(c);//0，上面已经自减过了
int d = 1;
System.out.println(d--);//1，符号在后，先打印，再自减
System.out.println(d);//0,打印过后，自减成0
//之前的代码会对后面的代码产生影响，c的值是0
System.out.println(c);//0
System.out.println(--c-c-c--);//1,-1-(-1)-(-1)=1
System.out.println(c);//-2,经历了两次自减，所以0-2=-2
}
}
+= -= *= /= %= 的使用
//举例说明+= -= *= /= %=
int m1 = 10;
m1 += 5; //类似于 m1 = m1 + 5 的操作，但不等同于。
System.out.println(m1);//15
//练习 1：开发中，如何实现一个变量+2 的操作呢？
// += 的操作不会改变变量本身的数据类型。其他拓展的运算符也如此。
//写法 1：推荐
short s1 = 10;
s1 += 2; //编译通过，因为在得到 int 类型的结果后，JVM 自动完成一步
强制类型转换，将 int 类型强转成 short
System.out.println(s1);//12
//写法 2：
short s2 = 10;
//s2 = s2 + 2;//编译报错，因为将 int 类型的结果赋值给 short 类型的
变量 s 时，可能损失精度
s2 = (short)(s2 + 2);
System.out.println(s2);
两种方式的区别：
s = s+2; //① 编译报错
s += 2; //② 正常执行
//①和②有什么区别？
s = s + 2和s += 2的作用都是增加2。
不过使用起来还是有区别的，如果s是int类型，这两者效果完全相同，但如果s是byte或short类型，第一种编译则会报错，因为byte类型或short类型的s和int类型的2相加，其结果是需要int类型来接收，所以byte s = s + 2或者short s = s + 2是不符合规则的，而第二种则不会报错，因为+=不会改变本身变量的数据类型。
关系运算符
比较运算符的结果都是 boolean 型，也就是要么是 true，要么是 false。
• > < >= <= ：只适用于基本数据类型（除 boolean 类型之外）
== != ：适用于基本数据类型和引用数据类型
• 比较运算符“==”不能误写成“=”
逻辑运算符
– & 和 &&：表示"且"关系，当符号左右两边布尔值都是 true 时，结果才能为 true。否则，为 false。
– | 和 || ：表示"或"关系，当符号两边布尔值有一边为 true 时，结果为true。当两边都为 false 时，结果为 false
– ! ：表示"非"关系，当变量布尔值为 true 时，结果为 false。当变量布尔值为 false 时，结果为 true。 – ^ ：当符号左右两边布尔值不同时，结果为 true。当两边布尔值相同时，结果为 false。
区分“&”和“&&”：
– 相同点：如果符号左边是 true，则二者都执行符号右边的操作
– 不同点：& ： 如果符号左边是 false,则继续执行符号右边的操作
&& ：如果符号左边是 false,则不再继续执行符号右边的操作
– 建议：开发中，推荐使用 &&
==区分“|”和“||”： ==
— 相同点：如果符号左边是 false，则二者都执行符号右边的操作
— 不同点：| ： 如果符号左边是 true，则继续执行符号右边的操作
|| ：如果符号左边是 true，则不再继续执行符号右边的操作
—建议：开发中，推荐使用 ||
1.4 练习：测试逻辑运算符
创建包: cn.tedu.basic
创建类: TestOperator2.java
package cn.tedu.basic;
/**本类用于测试逻辑运算符*/
public class TestOperator2 {
public static void main(String[] args) {
/**与：全真才真*/
System.out.println("测试单与：");
System.out.println(true & true);
System.out.println(true & false);
System.out.println(false & true);
System.out.println(false & false);
System.out.println("测试双与：");
System.out.println(true && true);
System.out.println(true && false);
System.out.println(false && true);
System.out.println(false && false);
/**或：全假才假*/
System.out.println("测试单或：");
System.out.println(true | true);
System.out.println(true | false);
System.out.println(false | true);
System.out.println(false | false);
System.out.println("测试双或：");
System.out.println(true || true);
System.out.println(true || false);
System.out.println(false || true);
System.out.println(false || false);
}
}
位运算符
左移：<<
运算规则：在一定范围内，数据每向左移动一位，相当于原数据*2。（正数、负数都适用）
3<<4 类似于 32 的 4 次幂 => 316 => 48
-3<<4 类似于 -32 的 4 次幂 => -316 => -48
（2）右移：>>
运算规则：在一定范围内，数据每向右移动一位，相当于原数据/2。（正数、
负数都适用）
【注意】如果不能整除，向下取整。
69>>4 类似于 69/2 的 4 次 = 69/16 =4
-69>>4 类似于 -69/2 的 4 次 = -69/16 = -5
（3）无符号右移：>>>
运算规则：往右移动后，左边空出来的位直接补 0。（正数、负数都适用）
69>>>4 类似于 69/2 的 4 次 = 69/16 =4
-69>>>4 结果：268435451
三目运算符
条件运算符格式：
(条件表达式)? 表达式 1:表达式 2
说明：条件表达式是 boolean 类型的结果，根据 boolean 的值选择表达式 1 或表达式 2
1.5 练习：求两数的最大值
创建包: cn.tedu.basic
创建类: TestMaxNum.java
package cn.tedu.basic;
import java.util.Scanner;
/**需求:接收用户输入的两个整数,并比较输出这两个数的最大值*/
public class TestMaxNum {
public static void main(String[] args) {
//1.提示用户输入
System.out.println("请输入您要比较的第一个整数:");
//2.接收用户输入的整数,并把这个值交给变量a来保存
int a = new Scanner(System.in).nextInt();
System.out.println("请输入您要比较的第二个整数:");
int b = new Scanner(System.in).nextInt();
//3.比较接收两个数,使用三元运算符
/**1 ? 2 : 3
* 1是表达式,若1的结果为true,结果取2位置,若1的结果为false,结果取3位置
* */
//4.定义变量max来保存比较的最大值
int max = a > b ? a : b;
//5.打印最大值
System.out.println("两个数的最大值是:"+max);
/**思考题:如何判断3个数的最大值? int max = a>b?(a>c?a:c):(b>c?b:c);*/
}
}
1.6 练习：求平年闰年
创建包: cn.tedu.basic
创建类: TestYear.java
//需求:接收用户输入的年份,判断是平年还是闰年
package cn.tedu.basic;
import java.util.Scanner;
/**
* 需求:接收用户输入的年份,判断是平年还是闰年
* 如果年份是闰年,需要满足下面两个条件之一:
* 条件1:能被4整除,并且不能被100整除
* 条件2:能被400整除
* */
public class Test3_Year {
public static void main(String[] args) {
//1.提示并接收用户输入的年份
System.out.println("请输入您要判断的年份:");
int year = new Scanner(System.in).nextInt();
//2.定义一个变量用来保存结果
String result = "平年";//默认值是平年,假设每年都是平年
//3.判断用户输入的年份是否满足闰年的条件
/**解决方案1*/
/**条件1:能被4整除,并且不能被100整除*/
// if(year % 4 == 0) {//能被4整除
// if(year %100 != 0) {//不能被100整除
// result = "闰年";//符合闰年的条件1,修改结果为闰年
// }
// }
// /**条件2:能被400整除*/
// if(year % 400 == 0) {//能被400整除
// result = "闰年";//符合闰年的条件2,修改结果为闰年
// }
/**解决方案2*/
/**判断结构 if(判断条件){满足判断条件以后执行的代码} */
//if(条件1 || 条件2){是闰年 }
//if((小条件1 && 小条件2) || 条件2){ 是闰年 }
//if((能被4整除 && 不能被100整除) || 能被400整除){ 是闰年 }
if((year % 4 == 0 && year %100 != 0) || year % 400 == 0){
result = "闰年";//符合闰年的条件,修改结果为闰年
}
System.out.println(year+"年是"+result);
}
}
2 拓展补充:
2.1 总结1:算术运算符之自增自减运算符
a是操作数，++是自增运算符，- -是自减运算符，自增和自减运算符即可以放在变量的前面，也可以放在变量的后面，例如：a++、++a、a- -、- -a等。
自增（++）：将变量的值加1
分前缀式（如++a）和后缀式（如a++）。前缀式是先加1再使用；后缀式是先使用再加1。
自减（- -）：将变量的值减1
分前缀式（如- -a）和后缀式（如a- -）。前缀式是先减1再使用；后缀式是先使用再减1。
2.2 总结2:逻辑运算符
逻辑运算符连接两个关系表达式或布尔变量，用于解决多个关系表达式的组合判断问题
注意逻辑运算符返回的运算结果为布尔类型
通常，我们用0表示false，用1表示true
与：表示并且的关系
&单与： 1 & 2 ，结果想要是true，要求1和2都必须是true
&&双与(短路与)：1 && 2 ，当1是false时，2会被短路，提高程序的效率
或：表示或者的关系
|单或： 1 | 2，结果想要是true，要求1和2只要有一个为true就可以
||双或(短路或)：1 || 2，当1是true时，2会被短路，提高程序效率
2.3 总结3:优先级控制
当一个表达式包含多个运算符时，就需要考虑运算符的优先级，优先级高的运算符先参与运算，优先级低的运算符后参与运算。在实际的开发中，不需要特别去记忆运算符的优先级别，也不要刻意的使用运算符的优先级别，对于不清楚优先级的地方使用小括号辅助进行优先级管理。
| 优先级 | 运算符说明 | Java 运算符 |
|---|---|---|
| 1 | 括号 | ()、[]、{} |
| 2 | 正负号 | +、- |
| 3 | 单元运算符 | ++、–、~、！ |
| 4 | 乘法、除法、求余 | *、/、% |
| 5 | 加法、减法 | +、- |
| 6 | 移位运算符 | <<、>>、>>> |
| 7 | 关系运算符 | <、<=、>=、>、instanceof |
| 8 | 等价运算符 | ==、!= |
| 9 | 按位与 | & |
| 10 | 按位异或 | ^ |
| 11 | 按位或 | / |
| 12 | 条件与 | && |
| 13 | 条件或 | // |
| 14 | 三元运算符 | ? : |
| 15 | 赋值运算符 | <、<=、>=、>、instanceof |
| 16 | 位赋值运算符 | &=、/=、<<=、>>=、>>>= |
- 不要过多的依赖运算的优先级来控制表达式的执行顺序，这样可读
性太差，尽量使用()来控制表达式的执行顺序。 - 不要把一个表达式写得过于复杂，如果一个表达式过于复杂，则把
它分成几步来完成。例如： (num1 + num2) * 2 > num3 &&
num2 > num3 ? num3 : num1 + num2;