day05_Java中的运算符
在Java中提供了丰富的运算符[*]其按照功能分：算术运算符、赋值运算符、比较运算符、逻辑运算、条件运算符
[*]按照操作数个数分：一元运算符（单目运算符）、二元运算符（双目运算符）、三元运算符 （三目运算符）
我们又称用运算符连接起来的式子就是表达式。下面我们来具体学习一下每个运算符的作用吧。
算数运算符
https://img-blog.csdnimg.cn/148802533df74713b3b0cd96f2e8c333.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAamF2YV9wZWRlc3RyaWFu,size_17,color_FFFFFF,t_70,g_se,x_16代码示例
/*
被除数 ÷ 除数 = 商 ...... 余数
*/
public class Demo01Operator {
public static void main(String[] args) {
int a = 10;
int b = 4;
// + - * 和我们小学的规则一样
System.out.println(a + b); //14
System.out.println(a - b);//6
System.out.println(a * b);//40
//2个整数相除，结果就是商，整数相除 不保留小数，如果想要显示小数 使用浮点类型计算
System.out.println(a / b);//2
//int * double / int ==> double / int ==> double / double ==> double
System.out.println((a * 1.0) / b);// 2.5
/*
%运算符: 取余数(模)运算符
作用:
1.判断数字的奇偶性:
数字%2 结果是0 说明数字是偶数
数字%2 结果不是0 说明数字是奇数
2.判断一个数字是否能够被另外一个数字整除
结果为0: 说明可以整除
结果不为0: 说明不可以整除
*/
//结果是0 说明10是偶数，结果是 1 说明11是奇数
System.out.println(10 % 2);//0
System.out.println(11 % 2);//1
//结果是0 说明100可以被25整除，否则说明100不可以被26整除
System.out.println(100 % 25);//0
System.out.println(100 % 26);//22
}
}注意事项:
[*]Java中，整数使用以上运算符，无论怎么计算，也不会得到小数。
[*]整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。
[*]/ 和%的区别：两个整数做除法，/取结果的商，%取结果的余数。取模的结果只和被除数的正负号相同。
案例：键盘录入一个三位数，将其拆分为个位、十位、百位后，打印在控制台
import java.util.Scanner;
public class Demo04Operator {
public static void main(String[] args) {
// 1：使用Scanner键盘录入一个三位数
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个三位数");
int num = sc.nextInt();
// 2：个位的计算：数值 % 10
int ge = num % 10; // 123 % 10 = 3
// 3：十位的计算：数值 / 10 % 10
int shi = num / 10 % 10; // 123 / 10 = 12 12 % 10 = 2
// 4：百位的计算：数值 / 100
int bai = num / 100; // 123 / 100 = 1
// 5：将个位, 十位, 百位拼接上正确的字符串, 打印即可
System.out.println("整数:"+num+" 个位为:" + ge);
System.out.println("整数:"+num+" 十位为:" + shi);
System.out.println("整数:"+num+" 百位为:" + bai);
}
}“+”号的两种用法
[*]第一种：对于+两边都是数值的话，+就是加法的意思。char类型参与算术运算，使用的是计算机底层对应的十进制数值。
[*]第二种：对于+两边至少有一边是字符串得话，+就是拼接的意思。字符串可以使用 +号, 跟任意数据类型拼接，结果就是字符串。当连续进行“+”操作时，从左到右逐个执行。
代码示例
public class Demo02Operator {
public static void main(String[] args) {
//数学中的加法运算(数字相加,字符相加)
System.out.println(5 + 5);// 10
/*
int + char ==> int + int ==> int
需要:
char ==> int 查看ASCII码表 'A'对应65
*/
System.out.println(5 + 'A');// 70
/*
自动类型转换中:
byte/short/char类型,只要参加运算,会自动转换为int类型
char + char ==> int + int ==> int
需要:
char ==> int 查看ASCII码表 'A'对应65
char ==> int 查看ASCII码表 'B'对应66
*/
System.out.println('A' + 'B');// 131
//字符串的拼接(把两个字符串连在一起),从左向右计算
System.out.println("Hello" + "World"); //HelloWorld
//先计算"5+5="+5: 此处+号代表字符串的连接 结果是"5+5=5"
//然后"5+5=5"+5: 此处+号代表字符串的连接 结果是"5+5=55"
System.out.println("5+5=" + 5 + 5);//5+5=55
//()的优先级是比较高的,所以先计算5+5 结果10
//然后"5+5="+10: 此处+号代表字符串的连接 结果是"5+5=10"
System.out.println("5+5=" + (5 + 5));//5+5=10
}
}自增自减运算符
++ 运算，变量自己的值加1。反之，-- 运算，变量自己的值减少1，用法与++ 一致。只能操作变量，不能操作常量
https://img-blog.csdnimg.cn/975c0bb39e534d9583c1a8ec12e3963d.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAamF2YV9wZWRlc3RyaWFu,size_17,color_FFFFFF,t_70,g_se,x_16https://img2022.cnblogs.com/blog/1401526/202206/1401526-20220625091618495-1562777381.gif
单独使用（推荐使用）
变量在单独运算的时候，变量前++和变量后++，是没有任何区别的；
[*]变量前++ ：例如 ++a
[*]变量后++ ：例如 a++
代码示例
public static void main(String[] args) {
// 定义一个int类型的变量a
int a = 3;
//++a;
a++;
// 无论是变量前++还是变量后++，结果都是4
System.out.println(a);
}复合使用
和其他变量放在一起使用或者和输出语句放在一起使用，前++和后++就产生了不同。
[*]变量前++ ：变量先自身加1，然后再取值。
[*]变量后++ ：变量先取值，然后再自身加1。
public class Demo04Operator {
public static void main(String[] args) {
// 其他变量放在一起使用
int x = 3;
//int y = ++x;y的值是4，x的值是4，
// y的值是3，x的值是4
int y = x++;
System.out.println(x);//4
System.out.println(y); //3
// 和输出语句一起
int z = 5;
System.out.println(++z);//6
System.out.println(z++);// 6
System.out.println(z);//7
int a = 1;
//(1)先取a的值“1”放操作数栈(2)a再自增,a=2(3)再把操作数栈中的"1"赋值给a,a=1
a = a++;
System.out.println(a);//1
}
}实际开发中强烈建议不要写这样的代码
public static void main(String[] args) {
int x = 4;
/*
表达式(x++)+(++x)+(x*10)是从左到右计算的
先计算(x++): 因为++在后面,先使用x的值4,然后x的值增加,变成5
4 + (++x)+(x*10)
接着计算(++x): 因为++在前面,先把x的值增加1,x变成6,然后再使用6
4 + 6+(x*10)
接着计算x*10 -->6*10 结果: 60
4 + 6 + 10 结果: 70
*/
int y = (x++) + (++x) + (x * 10);
System.out.println(x);//6
System.out.println(y);//70
}赋值运算符
[*]赋值运算符，就是将符号右边的值，赋给左边的变量。 所有的赋值运算符的左边一定是一个变量，不能是常量。
https://img-blog.csdnimg.cn/5b1d69d1f67a4789b239b1feb43b8146.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAamF2YV9wZWRlc3RyaWFu,size_19,color_FFFFFF,t_70,g_se,x_16代码示例
/*
基本赋值运算符: =
复合赋值运算符:
+= a+=b a=a+b
-= a-=b a=a-b
*= a*=b a=a*b
/= a/=b a=a/b
%= a%=b a=a%b
*/
public class Demo03Operator {
public static void main(String[] args) {
//基本赋值运算符
int a = 10, b = 20;
//复合赋值运算符:
a += b;//a = a + b
System.out.println(a);//30
System.out.println(b);//20
int c = 30, d = 20;
c %= d;//c = c % d
System.out.println(c);//10
System.out.println(d);//20
short s = 1;
/*
+=,-=,/=,*=,%= 运算结果的数据类型和左侧变量的数据类型不一致,隐藏强制类型转换
*/
s += 1;//s = (short)(s + 1);
System.out.println(s);//2
}
}注意事项：
[*]扩展赋值运算符在将最后的结果赋值给左边的变量前，都做了一步强制类型转换。
[*]整数常量只要不超出所赋值的整数变量的取值范围,可以直接赋值,内部隐藏强制类型转换
[*]运算的顺序：把右边的整个表达式先算完，才会做最后的赋值操作。
例如：
int j = 1;
j += ++j * j++;//相当于j = j + (++j * j++);
System.out.println(j);//5关系运算符
[*]关系运算符又可以叫比较运算符，是两个数据之间进行比较的运算，运算结果一定是boolean值true或者false
https://img-blog.csdnimg.cn/6652959debb84a2a89558620bc13f81d.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAamF2YV9wZWRlc3RyaWFu,size_19,color_FFFFFF,t_70,g_se,x_16代码示例
public class Demo05Operator {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println(a == b); // false
System.out.println(a != b); // true
System.out.println(a > b); // false
System.out.println(a >= b); // false
System.out.println(a < b); // true
System.out.println(a <= b); // true
// 关系运算的结果肯定是boolean类型，所以也可以将运算结果赋值给boolean类型的变量
boolean flag = a > b;
System.out.println(flag);// 输出false
}
}
注意事项：
[*]其中>,=, b) & (a > c));//false System.out.println((a > b) & (a < c));//false System.out.println((a < b) & (a > c)); //false System.out.println((a < b) & (a < c)); //true // | “或”，或者的关系，只要表达式中有一个值为true，结果即为true System.out.println((a > b) | (a > c)); //false System.out.println((a > b) | (a < c)); //true System.out.println((a < b) | (a > c)); //true System.out.println((a < b) | (a < c)); //true // ^ 异或；相同为false，不同为true System.out.println((a > b) ^ (a > c)); //false System.out.println((a > b) ^ (a < c));//true System.out.println((a < b) ^ (a > c));//true System.out.println((a < b) ^ (a < c));//false // ! 非；非false则true，非true则false System.out.println(!false); //true System.out.println(!true); //false }}短路逻辑运算符
在逻辑与运算中，只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值 都计算出来，短路与操作就有这样的效果，可以提高效率。同理在逻辑或运算中，一旦发现值为true，右边的表达式将不再参与运算。
https://img-blog.csdnimg.cn/b1652f923afc439fa536daab65ea4f3a.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAamF2YV9wZWRlc3RyaWFu,size_20,color_FFFFFF,t_70,g_se,x_16
&& 和& 区别：
[*]&&和&结果一样，&&有短路效果，左边为false，右边不执行；&左边无论是什么，右边都会执行。
|| 和 | 区别：
[*]||和|结果一样，||有短路效果，左边为true，右边不执行；|左边无论是什么，右边都会执行。
代码示例
public class Demo6Operator {
public static void main(String[] args) {
int a = 3;
int b = 4;
int c = 5;
////& “与”，并且的关系，只要表达式中有一个值为false，结果即为false
System.out.println((a > b) & (a > c));//false
System.out.println((a > b) & (a < c));//false
System.out.println((a < b) & (a > c)); //false
System.out.println((a < b) & (a < c)); //true
// | “或”，或者的关系，只要表达式中有一个值为true，结果即为true
System.out.println((a > b) | (a > c)); //false
System.out.println((a > b) | (a < c)); //true
System.out.println((a < b) | (a > c)); //true
System.out.println((a < b) | (a < c)); //true
// ^ 异或；相同为false，不同为true
System.out.println((a > b) ^ (a > c)); //false
System.out.println((a > b) ^ (a < c));//true
System.out.println((a < b) ^ (a > c));//true
System.out.println((a < b) ^ (a < c));//false
// ! 非；非false则true，非true则false
System.out.println(!false); //true
System.out.println(!true); //false
}
}三元运算符
语法格式：
[*]数据类型 变量名称 = 布尔表达式1 ? 表达式2 : 表达式3;
执行流程:
[*]计算布尔表达式1的结果,看是true还是false
[*]如果布尔表达式1的结果为true,就把表达式2的结果赋值给左侧的变量
[*]如果布尔表达式1的结果为false,就把表达式3的结果赋值给左侧的变量
执行流程图解:
https://img-blog.csdnimg.cn/4d1c198506b04310acea945a50a62eba.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAamF2YV9wZWRlc3RyaWFu,size_15,color_FFFFFF,t_70,g_se,x_16代码示例
/*
逻辑运算符的短路效果
1.短路的逻辑运算符
(1)短路逻辑与&&: 左侧为false,右边不计算
(2)短路逻辑或||: 左侧为true,右侧不计算
2.特点:
(1)短路逻辑与&&: 和&结果是相同的,但是&&可以提高效率
(2)短路逻辑与||: 和|结果是相同的,但是||可以提高效率
*/
public class Demo08Operator {
public static void main(String[] args) {
int a = 2;
/*
整个表达式(3>5)&&(++a>2)从左向右计算
先计算表达式3>5结果为false
因为两个表达式使用&&连接,左侧为false,已经决定了最终的结果为false,
不管右侧表达式(++a>2)的结果是true还是false,都无法改变&&的最终结果,
所以右侧表达式(++a>2)不进行计算
*/
System.out.println((3 > 5) && (++a > 2));//false
System.out.println(a);//2: 说明++a没有计算,&&右侧的表达式没有执行
int b = 2;
/*
整个表达式(3>5)&(++b>2)从左向右计算
先计算表达式3>5结果为false
因为两个表达式使用&连接,左侧为false,虽然已经决定了最终的结果为false,
但是右侧表达式(++b>2)仍然要进行计算,所以b的值最终是3
*/
System.out.println((3 > 5) & (++b > 2));//false
System.out.println(b);//3: 说明++b进行计算,&右侧的表达式执行了
System.out.println("-------------------");
int c = 2;
/*
整个表达式(3<5)||(++c>2)从左向右计算
先计算表达式3<5结果为true
因为两个表达式使用||连接,左侧为true,已经决定了最终的结果为true,
不管右侧表达式(++c>2)的结果是true还是false,都无法改变||的最终结果,
所以右侧表达式(++c>2)不进行计算
*/
System.out.println((3 < 5) || (++c > 2));//true
System.out.println(c);//2: 说明++c没有计算,||右侧的表达式没有执行
int d = 2;
/*
整个表达式(3<5)|(++d>2)从左向右计算
先计算表达式3<5结果为true
因为两个表达式使用|连接,左侧为true,虽然已经决定了最终的结果为true,
但是右侧表达式(++d>2)仍然要进行计算,所以d的值最终是3
*/
System.out.println((3 < 5) | (++d > 2));//true
System.out.println(d);//3: 说明++d进行计算,|右侧的表达式执行了
}
}位运算（了解）
效率很高，但是可读性不好。因为它是基于二进制补码直接运算的。关于&,|,^，看左右两边的操作数是boolean值，还是整数，来决定是逻辑运算符还是位运算符。常见的有以下几种位运算符
<strong>左移：几位，就除以2的几次方
[*]二进制补码右移n位，左边补0还是1，看最高位
无符号右移：>>>
[*]运算规则：二进制补码右移n位，左边补0，对于负数来说，移完后，变为正数
运算符优先级
https://img-blog.csdnimg.cn/8d3f01b18a994f0084df8f9b1da4d5ae.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAamF2YV9wZWRlc3RyaWFu,size_8,color_FFFFFF,t_70,g_se,x_16
我们遵循一个原则：
[*]表达式不要写太复杂，可以分为多行
[*]实际开发中都是使用小括号来调整运算优先级
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！
页:
[1]