目录
算术运算符
| + | - | * | / | % | ++ | – | |
|---|---|---|---|---|---|---|---|
| 求和 | 相减 | 乘积 | 商 | 求余数（取模） | 自加1 | 自减1 |
注意：一个表达式当中有多个运算符，运算符有优先级，不确定的加小括号，优先级得到提升。没必要去专门记忆运算符的优先级。
-
+ - * / %
public class OperatorText01 { public static void main(String[] args){ int i= 10; int j= 3; System.out.println(i+j);//13 System.out.println(i-j);//7 System.out.println(i*j);//30 System.out.println(i/j);//3 System.out.println(i%j);//1 } } -
K++运算符【自加1】、K–运算符【自减1】
-
++运算符可以出现在变量前，也可以出现在变量后，无论是变量前还是变量后。只要++运算结束，该变量中的值一定会自加1
++出现在变量后,规则：先做赋值运算。再对变量中保存的值进行自加1
++出现在变量前,规则：先进行自加1运算。再进行赋值操作
-
//println()原理 ln(int x=‘mm’)
-
–运算符可以出现在变量前，也可以出现在变量后，无论是变量前还是变量后。只要–运算结束，该变量中的值一定会自减1
–出现在变量后,规则：先做赋值运算。再对变量中保存的值进行自减1
–出现在变量前,规则：先进行自减1运算。再进行赋值操作
public class OperatorText01 { public static void main(String[] args){ int k= 10; k++;//++运算符可以出现在变量后面【单目运算符】 System.out.println(k);//11 int y= 10; ++ y;//++运算符可以出现在变量前面【单目运算符】 System.out.println(y);//11 //++运算符可以出现在变量前，也可以出现在变量后，无论是变量前还是变量后 //只要++运算结束，该变量中的值一定会自加1 //++出现在变量后,规则：先做赋值运算。再对变量中保存的值进行自加1 int a= 100; int b= a++; System.out.println(a);//101 System.out.println(b);//100 //++出现在变量前,规则：先进行自加1运算。再进行赋值操作 int m= 100; int n= ++m; System.out.println(m);//101 System.out.println(n);//101 //println()原理 ln(int x='mm') int mm= 500; System.out.println(mm);//500 int e=100; System.out.println(e ++);//100 e是100，但++在变量后，先赋值 System.out.println(e);//101 上面的e运算之后是101，再输出就是101 int s= 200; System.out.println(++s);//201 ++在变量前，先运算后赋值 System.out.println(s);//201 上面有++运算了，所以直接取运算后的值 System.out.println(--s);//200 --在变量前，取201-1就是200 System.out.println(s++);//200 //++在变量后，先赋值取上面语句运算后的值200 System.out.println(s--);//201 --在变量后，先赋值取去上面运算后的值201 System.out.println(s--);//200 --在变量后，先赋值取上面运算后的值200 System.out.println(s--);//199 --在变量后，先赋值取上面运算后的值199 System.out.println(s);//198 输出上面语句运算后s的值 int t=20; t--; System.out.println(t);//19 int u=30; --u; System.out.println(u);//29 int tt=40; int w= tt--; System.out.println(tt);//39 tt赋值40，但是下面有个tt--，所以是39 System.out.println(w);//40 //因为--在tt后面，所以先赋值再运算，w输出tt的值 int r=--tt; System.out.println(r);//38 // r之前已经有一个tt--,运算后是39，又因为赋值r时 //--在变量前，所以先运算，再赋值是38 } }
-
关系运算符
| > | >= | < | <= | == | != |
|---|---|---|---|---|---|
| 大于 | 大于等于 | 小于 | 小于等于 | 等于 | 不等于 |
-
=是赋值运算符 ==是关系运算符
-
关系运算符的运算结果一定是布尔类型：true/false
-
关系运算符的运算原理：
int a= 10; int b= 10;
a > b 比较的时候，比较的是a中保存的10这个值和b中保存的10这个值之间的大小比较。
a == b 也是如此
public class OperatorText02 { public static void main(String[] args){ int a= 10; int b= 10; System.out.println(a>b);//false System.out.println(a>=b);//true System.out.println(a<b);//false System.out.println(a<=b);//true System.out.println(a==b);//true System.out.println(a!=b);//false } }
逻辑运算符
| & | 逻辑与【并且】（两边的算子都是true，结果才是true） 全真为真 |
|---|---|
| | | 逻辑或【或者】（两边的算子只要有一个是true，结果就是true） 有真为真 |
| ! | 逻辑非（取反， !false就是true， !true就是false，这是一个单目运算符） |
| ^ | 逻辑异或（两边的算子只要不一样，结果就是真） |
| && | 短路与 |
| || | 短路或 |
-
逻辑运算符要求两边的算子都是布尔类型，并且逻辑运算符最终的运算结果也是一个布尔类型。
-
短路与 和 逻辑与 最终的运算结果都是相同的，只不过 短路与 存在短路现象。
短路或 和 逻辑或 最终的运算结果都是相同的，只不过 短路或 存在短路现象。
public class OperatorText03 { public static void main(String[] args){ //运算符优先级不确定，加小括号 System.out.println(5>3 & 5>2);//true System.out.println(5>3 & 5>6);//false System.out.println(5>3 | 5>6);//true System.out.println(true & true);//true System.out.println(true & false);//false System.out.println(false & true);//false System.out.println(false & false);//false System.out.println(true | false);//true System.out.println(false | true);//true System.out.println(false | false);//false System.out.println(true | true);//true System.out.println(!false);//true System.out.println(!true);//false System.out.println(true ^ false);//true System.out.println(false ^ true);//true System.out.println(true ^ true);//false System.out.println(false ^ false);//false } } -
逻辑与 和 短路与
-
逻辑与：全部执行 短路与：如果运算符左边算子false，右边的算子不执行。
-
从某个角度看，短路与更智能。由于后面的表达式可能不执行，所以执行效率更高。在实际开发中，短路与比逻辑与使用多。短路与更实用。
但是，在某些特殊的业务逻辑当中，要求运算符两边的算子必须全部执行，此时必须使用逻辑与。使用短路与可能导致右边的表达式不执行
public class OperatorText03 { public static void main(String[] args){ /*逻辑与 int x= 10; int y= 8; System.out.println(x<y & ++x<y); System.out.println(x);//11 */ //短路与 int x= 10; int y= 8; System.out.println(x<y && ++x<y); System.out.println(x);//10 /* x<y 结果是false，整个表达式结果已经确定是false。 所有后面的表达式不再执行，这种现象称为短路现象 短路与才会有短路现象，逻辑与是不会存在短路现象的 */ } } -
-
发生短路与的情况：运算符左边的算子执行结果false
发生短路或的情况：运算符左边的算子执行结果是true
赋值类运算符
| 基本的赋值运算符 | 扩展的赋值运算符 |
|---|---|
| = | += |
| -= | |
| *= | |
| /= | |
| %= |
-
赋值类运算符的优先级：先执行=右边的表达式，将执行结果赋值给左边的变量。
-
结论：扩展类的赋值运算符不改变运算结果类型。假设变量最初是byte类型，无论如何追加或追减，最终变量的数据类型还是byte类型。
-
byte b= 10; b +=5;//等同于：b=(byte)(b+5); int i= 10; i +=5;//等同于：i=(int)(i+5); long l= 10L; int y=20 y +=l;//等同于：y=(int)(y+l)public class OperatorText04 { public static void main(String[] args){ int i= 10; i =i + 5; System.out.println(i);//15 //扩展的赋值运算符【+=运算符可以翻译为“追加/累加”】 i += 5; //等同于 i= i + 5; System.out.println(i);//20 i -= 5; //等同于i = i -5； System.out.println(i);//15 i *= 2; //等同于i = i * 2; System.out.println(i);//30 i /= 4; //等同于i = i / 4; System.out.println(i); // 7.5取整数位是7 i %= 2; //等同于i = i % 2; System.out.println(i); // ----------------------------------------- byte b= 10;//10没有超出byte取值范围，可以直接赋值 //b= 15; 编译通过，15没有超出byte取值范围 //b= b+5; 编译报错 大容量——>小容量需要加强制类型转换符 //编译器只检查语法，不运行程序，编译器发现b+5是int类型，b类型的数据类型是byte //纠错 b =(byte)(b+5); System.out.println(b);//15 byte x= 10; x += 5;//等同于 x=（byte）（x+5）; 实际上并不同于x=x+5; System.out.println(x);//15 byte z= 0; z +=128;//-128 等同于z=(byte)(z+128); System.out.println(z); z +=10000;// 等同于：z= (byte)(z+10000); System.out.println(z);//-112 } }
字符串连接运算符
java中的“+”运算符
-
“+” 在java中的两个作用
- 加法运算，求和
- 字符串的连接运算
-
“+”两边的数据都是数字时，一定是进行加法运算。
-
“+”两边的数据只要有一个数据是字符串，一定会进行字符串连接运算。并且，连接运算之后的结果还是一个字符串类型。
数字 + 数字 ———>数字【求和】
数字 + 字符串———>字符串【字符串连接】
-
在一个表达式中可以出现多个“+”，如果没有添加小括号，遵循自左向右的顺序依次运算。
public class OperatorText05 {
public static void main(String[] args){
System.out.println(10+20);// 30 这里的+是求和
System.out.println(10+20+30);// 60 这里的+也是求和
System.out.println(10+20+"30");// 3030 第一个+是求和，第二个是字符连接
System.out.println(10+(20+"30"));// 102030
//优先括号里字符连接：2030，是一个字符串，再括号外字符连接
//要求在控制台上 以动态形式 输出 “ 10+20=30 ”
int a= 10;
int b= 20;
System.out.println("10+20=30");//固态的
System.out.println("10+20="+(a+b));
System.out.println(a+"+20="+(a+b));
System.out.println(a+"+b="+(a+b));//10+b=30
a=100; b=200;
System.out.println(a+"+"+b+"="+(a+b));//动态
/*
引用类型String
String是SUN在JAVASE中提供的字符串类型
String.class字节码文件
*/
int i= 10;
// int 是基本数据类型，i是变量名，10是int类型的字面值
String s="abc";
//String 是引用数据类型，s是变量名，"abc"是String类型的字面值
//定义一个String类型的变量，起名username，赋值"zhangsan"
String username="zhangsan";
System.out.println("登陆成功，欢迎username回来");//登陆成功，欢迎username回来
System.out.println("登陆成功，欢迎"+"回来");//登陆成功，欢迎回来
System.out.println("登陆成功，欢迎"+username+"回来");//登陆成功，欢迎zhangsan回来
username="jack";
System.out.println("登陆成功，欢迎"+username+"回来")//登陆成功，欢迎jack回来
}
}
三元运算符 / 三目运算符 / 条件运算符
-
语法规则：布尔表达式？表达式1：表达式2
-
三元运算符的执行原理：
当布尔表达式的结果是true时，选择表达式1作为整个表达式的执行结果。
当布尔表达式的结果是false时，选择表达式2作为整个表达式的执行结果。
public class OperatorText06 {
public static void main(String[] args){
//编译错误，不是一个完整的java语句
//10;
//编译错误：不是一个完整的java语句。
//'男';
//布尔型变量
boolean sex= false;
//编译报错：不是一个完整的java语句
// sex ? '男':'女'
char c= sex ? '男':'女';
System.out.println(c);//女
sex =true;
c =(sex?'男':'女');
System.out.println(c);//男
//语法错误，编译报错。类型不兼容
// 结果可能是String也可能是char，但是前边不能用char来接收数据
//char c1=sex ?"男":'女';
System.out.println(sex ? "男":'女');// 可使用，输出：男
String s=sex?"男的":"女的";
System.out.println(s);//男的
}
}
