运算符
运算符是用来计算数据的符号。数据可以是常量,也可以是变量。被运算符操作的数我们称为操作数。Java中常见的运算符有下面几类
- 算术运算符
- 赋值运算符
- 比较运算符又称之为关系运算符
- 逻辑运算符
- 三元运算符
算术运算符
我们在使用算术运算符时,记得要注意下列事项:
- 加法运算符在连接字符串时要注意,只有直接与字符串相加才会转成字符串。
- 除法“/”当两边为整数时,取整数部分,舍余数。当其中一边为浮点型时,按正常规则相除。
- “%”为整除取余符号,小数取余没有意义。如果对负数取模,可以把模数负号忽略不记,如:5%-2=1。 但被模数是负数则不可忽略。结果符号与被被模数相同。如:5%-2=1。5是被模数,-2是模数。
- 整数做被除数,0不能做除数,否则报错。
代码演示
/* 运算符:进行特定操作的符号。例如:+ 表达式:用运算符连起来的式子叫做表达式。例如:20 + 5。又例如:a + b 四则运算: 加:+ 减:- 乘:* 除:/ 取模(取余数):% 首先计算得到表达式的结果,然后再打印输出这个结果。 除法公式: 被除数 / 除数 = 商 ... 余数 对于一个整数的表达式来说,除法用的是整除,整数除以整数,结果仍然是整数。只看商,不看余数。 只有对于整数的除法来说,取模运算符才有余数的意义。 注意事项: 1. 一旦运算当中有不同类型的数据,那么结果将会是数据类型范围大的那种。 */ public class Demo04Operator { public static void main(String[] args) { // 两个常量之间可以进行数学运算 System.out.println(20 + 30);//50 // 两个变量之间也可以进行数学运算 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 z = 63; int result1 = x % y; System.out.println(result1); // 余数,模,-1 int result2 = z % x; System.out.println(result2);//3 // int + double --> double + double --> double double result3 = x + 2.5; System.out.println(result3); // -7.5 //除号:/ int num1 = 12; int num2 = 5; int number = num1 / num2; System.out.println(number);//2 int number1 = num1 / num2 * num2; System.out.println(number1);//10 double number2 = num1 / num2; System.out.println(number2);//2.0 } }
四则运算当中的加号“+”有常见的三种用法:
- 对于数值来说,那就是加法。
- 对于字符char类型来说,在计算之前,char会被提升成为int,然后再计算。char类型字符,和int类型数字,之间的对照关系表:ASCII、Unicode
- 对于字符串String(首字母大写,并不是关键字)来说,加号代表字符串连接操作。任何数据类型和字符串进行连接的时候,结果都会变成字符串
public class Demo05Plus { public static void main(String[] args) { // 数据类型 变量名称 = 数据值; String str1 = "Hello"; System.out.println(str1); // Hello //对于字符串String来说,加号代表字符串连接操作。 System.out.println("Hello" + "World"); // HelloWorld String str2 = "Java"; // String + int --> String System.out.println(str2 + 20); // Java20 // 优先级问题,如果希望哪段代码先执行可以使用小括号 System.out.println(str2 + (20 + 30)); // Java50 } }
自增自减运算符(属于算术运算符)
详解自增自减运算符
- 基本含义:让一个变量涨一个数字1,或者让一个变量降一个数字1
- 使用格式:写在变量名称之前,或者写在变量名称之后。例如:++i,也可以i++
使用方式:
- 单独使用:不和其他任何操作混合,自己独立成为一个步骤。
- 混合使用:和其他操作混合,例如与赋值混合,或者与打印操作混合,等。
使用区别:
- 在单独使用的时候,前++和后++没有任何区别。也就是:++i;和i++;是完全一样的。
- 前++和后++不会改变本身变量的数据类型
在混合的时候,有重大区别
- 如果是【前++】,那么变量【立刻马上+1】,然后拿着结果进行使用。 【先加后用】
- 如果是【后++】,那么首先使用变量本来的数值,【然后再让变量+1】。 【先用后加】
代码演示
public class Demo02Operator { 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 // 与打印操作混合的时候 int num2 = 20; // 混合使用,先++,变量立刻马上变成21,然后打印结果21 System.out.println(++num2); // 21 System.out.println(num2); // 21 int num3 = 30; // 混合使用,后++,首先使用变量本来的30,然后再让变量+1得到31 System.out.println(num3++); // 30 System.out.println(num3); // 31 int num4 = 40; // 和赋值操作混合 int result1 = --num4; // 混合使用,前--,变量立刻马上-1变成39,然后将结果39交给result1变量 System.out.println(result1); // 39 System.out.println(num4); // 39 int num5 = 50; // 混合使用,后--,首先把本来的数字50交给result2,然后我自己再-1变成49 int result2 = num5--; System.out.println(result2); // 50 System.out.println(num5); // 49 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++; // 错误写法!常量不可以使用++或者-- byte i = 127; i ++; System.out.println(i);//-128 } }
注意事项:
- 只有变量才能使用自增、自减运算符。常量不可发生改变,所以不能用。
赋值运算符
- 基本赋值运算符:就是一个等号“=”,代表将右侧的数据交给左侧的变量。当“=”两侧数据类型不一致时,可以使用自动类型转换或使用强制类型转换原则进行处理。支持连续赋值。
- 复合赋值运算符:+=, -=, *=, /=, %=
注意事项:
- 只有变量才能使用赋值运算符,常量不能进行赋值。
- 扩展赋值运算符: +=, -=, *=, /=, %=,扩展的赋值运算符隐含了强制类型转换。不改变原来的数据类型也就是说 byte b=100; b +=1000;b 变量最初是 byte 类型,最后的运算结果还是一个 byte类型。这是一条固定的语法规则,大家记住就行了,以后在使用扩展类赋值运算符的时候要谨慎,不小心就会精度损失的
- 不建议使用连续赋值,阅读性不好。
代码演示
/* 赋值运算符分为: 基本赋值运算符:就是一个等号“=”,代表将右侧的数据交给左侧的变量。 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 注意事项: 1. 只有变量才能使用赋值运算符,常量不能进行赋值。 2. 复合赋值运算符其中隐含了一个强制类型转换。 */ public class Demo07Operator { 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; System.out.println(num); // 35 } }
比较运算符
比较运算符,又叫关系运算符,它是用来判断两个操作数的大小关系及是否相等关系的,结果是布尔值true或者false。
注意事项:
- 比较运算符的结果一定是一个boolean值,成立就是true,不成立就是false。如果进行多次判断,不能连着写。
- 数学当中的写法,例如:1 < x < 3程序当中【不允许】这种写法。
- 比较运算符“==”不能误写成“=” 。
代码演示
/* 运算符之三:比较运算符 == != > < >= <= instanceof 结论: 1.比较运算符的结果是boolean类型 2.区分 == 和 = */ public class Demo08Operator { public static void main(String[] args) { int i = 10; int j = 20; System.out.println(i == j);//false System.out.println(i = j);//20 boolean b1 = true; boolean b2 = false; System.out.println(b2 == b1);//false System.out.println(b2 = b1);//true int x = 2; // System.out.println(1 < x < 3); // 错误写法!编译报错!不能连着写。 } }
逻辑运算符
逻辑运算符主要包括逻辑与(&),逻辑或(|),逻辑异或(^),短路与(&&),短路或(||)。所有逻辑运算符的特点是操作数都是布尔类型,并且最终的运算结果也是布尔类型。逻辑运算符的基本运算规则如下表所示:
注意事项:
- 逻辑运算符两边要求都是布尔类型,并且最终的运算结果也是布尔类型。
- 逻 辑运算符用于连接布尔型表达式,在Java中不可以写成3<x<6,应该写 成x>3 & x<6 。如果有多个条件,可以连续写。两个条件:条件A && 条件B 丶多个条件:条件A && 条件B && 条件C
- 异或( ^ )与或 ( | )的不同之处是:当左右都为true时,结果为false。
“&”和“&&”的区别:
- 单&时,左边无论真假,右边都进行运算;
- 双&时,如果左边为真,右边参与运算,如果左边为假,那么右边不参与运算。(效率较高)
- 相同点1:& 与 && 的运算结果相同
- 相同点2:当符号左边是true时,二者都会执行符号右边的运算
“|”和“||”的区别:
- 逻辑或|,无论左边真假,右边都要执行。
- 短路或||,如果左边为假,右边执行;如果左边为真,右边不执行。(效率较高)
- 相同点1:| 与 || 的运算结果相同
- 相同点2:当符号左边是false时,二者都会执行符号右边的运算
异或( ^ )与或( | )的不同之处是:
- 当左右都为相同时,结果为true。 理解:异或,追求的是“异”!
代码演示
public class Demo05Operator { public static void main(String[] args) { System.out.println(5 > 3 & 5 > 4); //true System.out.println(5 > 100 | 5 > 4); //true System.out.println(!(5 > 3)); //false System.out.println(!(5 < 3)); //true System.out.println(true & true); //true System.out.println(true & false); //false System.out.println(true | false); //true //取反 System.out.println(!false); //true System.out.println(!true); //false //2边相同则结果是false System.out.println(true ^ false); //true System.out.println(true ^ true); //false System.out.println(false ^ false); //false //重点研究逻辑与(&)和短路与(&&)的区别 int x = 100; int y = 98; int z = 99; System.out.println(x > y & x > z); //true System.out.println(x > y && x > z); //true /* * 通过测试得出,逻辑与(&)和短路与(&&)最终运行 * 结果相同那么它们有什么区别呢?请看以下代码。 */ int m = 99; int n = 100; System.out.println(m > n & m > n++); //false /* * 逻辑与(&)运算符只有当两边的操作数都是 true 的时候,* 结果才是 true,只要有一个是 false,结果必然是 false。 * 以上程序逻辑左边的表达式(m > n)显然结果是 false, * 通过左边的表达式已经可以得出结果是false 了,右边的 * 表达式没有执行的必要,那我们来看一下右边的表达式 * 有没有执行,只要输出 n 就可以了断定。 */ System.out.println("n = " + n); //101 /* * 以上程序的运行结果是 101,足以说明 n++已经执行了。 * 也说明了逻辑与运算符无论左边表达式结果是true 还 * 是 false,右边表达式一定会执行。 */ //那我们来看一下短路与(&&)是怎样的? int k = 99; int f = 100; System.out.println(k > f && k > f++); //false System.out.println("f = " + f); //100 /* * 通过以上测试得出 f++并没有执行,因为左边表达式(k > f) * 为 false,右边的表达式就不再执行了,这种现象被称为短路 * 现象。也就是说对于短路与来说,左边的表达式只要为 false, * 就会发生短路,右边表达式不再执行了。 */ } }
位运算符
位运算符的基本运算规则如下表所示:
代码举例:
/* 运算符之六:三元运算符 1.结构:(条件表达式)? 表达式1 : 表达式2 2. 说明 ① 条件表达式的结果为boolean类型 ② 根据条件表达式真或假,决定执行表达式1,还是表达式2. 如果表达式为true,则执行表达式1。 如果表达式为false,则执行表达式2。 ③ 表达式1 和表达式2要求是一致的。 ④ 三元运算符可以嵌套使用 3. 凡是可以使用三元运算符的地方,都可以改写为if-else 反之,不成立。 4. 如果程序既可以使用三元运算符,又可以使用if-else结构,那么优先选择三元运算符。原因:简洁、执行效率高。 */ public class Demo10Operator { 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);// 20 // a > b ? a : b; // 错误写法! //获取三个数的最大值 int n1 = 12; int n2 = 30; int n3 = -43; int max1 = (n1 > n2)? n1 : n2; int max2 = (max1 > n3)? max1 : n3; System.out.println("三个数中的最大值为:" + max2);//三个数中的最大值为:30 //三元运算符可以嵌套,不建议这么做。不利于阅读, int max3 = (((n1 > n2)? n1 : n2) > n3)? ((n1 > n2)? n1 : n2) : n3; System.out.println("三个数中的最大值为:" + max3);//三个数中的最大值为:30 } }
注意事项:
- 必须同时保证表达式A和表达式B都符合左侧数据类型的要求。
- 三元运算符的结果必须被使用。
运算符优先级
下图是每种运算符的优先级,按照运算先后顺序排序(优先级相同的情况下,按照从左到右的顺序依次运算)
进制
所有数字在计算机底层都以二进制形式存在。
对于整数,有四种表示方式:
- 二进制(binary):0,1 ,满2进1.以0b或0B开头。
- 十进制(decimal):0-9 ,满10进1。
- 八进制(octal):0-7 ,满8进1. 以数字0开头表示。
- 十六进制(hex):0-9及A-F,满16进1. 以0x或0X开头表示。此处的A-F不区分大小写。 如:0x21AF +1= 0X21B0
代码演示,进制的基本使用:
class BinaryTest { public static void main(String[] args) { //二进制(binary):0,1 ,满2进1.以0b或0B开头。 int num1 = 0b110; //十进制(decimal):0-9 ,满10进1。 int num2 = 110; //八进制(octal):0-7 ,满8进1. 以数字0开头表示。 int num3 = 0127; //十六进制(hex):0-9及A-F,满16进1. 以0x或0X开头表示。此处的A-F不区分大小写。 int num4 = 0x110A; System.out.println("num1 = " + num1);//num1 = 6 System.out.println("num2 = " + num2);//num2 = 110 System.out.println("num3 = " + num3);//num3 = 87 System.out.println("num4 = " + num4);//num4 = 4362 } }
二进制
- Java整数常量默认是int类型,当用二进制定义整数时,其第32位是符号位; 当是long类型时,二进制默认占64位,第64位是符号位
二进制的整数有如下三种形式:
- 原码:直接将一个数值换成二进制数。最高位是符号位
- 负数的反码:是对原码按位取反,只是最高位(符号位)确定为1。
- 负数的补码:其反码加1。
计算机以二进制补码的形式保存所有的整数。
- 正数的原码、反码、补码都相同
- 负数的补码是其反码+1
为什么要使用原码、反码、补码表示形式呢?
- 计算机辨别“符号位”显然会让计算机的基础电路设计变得十分复杂! 于是 人们想出了将符号位也参与运算的方法. 我们知道, 根据运算法则减去一个正 数等于加上一个负数, 即: 1-1 = 1 + (-1) = 0 , 所以机器可以只有加法而没有 减法, 这样计算机运算的设计就更简单了。