运算符
运算符：
一、算术运算符
二、赋值运算符
三、比较运算符(关系运算符)
四、逻辑运算符
五、条件运算符
六、位运算符
表达式：操做数+运算符java
一、按照操做数个数的分类：c++
(1)一元运算符：操做数只有一个git
例如：正号(+)，负号(-)，自增(++)，自减(–)，逻辑非(！)，按位取反(~)程序员
(2)二元运算符：操做数有两个github
例如：加(+)，减(-)，乘(*)，除(/)，模(%)web
大于(>)，小于(=)，小于等于(<=)，等于(==)，不等于(!=)面试
赋值(=，+=，-=，*=，/=，%=，>>=，<<=。。。)svg
逻辑与(&)，逻辑或(|)，逻辑异或(^)，短路与(&&)，短路或(||)spa
左移(<>)，无符号右移(>>>)，按位与(&)，按位或(|)，按位异或(^)设计
(3)三元运算符：操做数三个
例如： ？ ：
二、Java基本数据类型的运算符：
(1)算术运算符
(2)赋值运算符
(3)比较运算符
(4)逻辑运算符
(5)条件运算符
(6)位运算符(难)
一、 算术运算符
加法：+
减法：-
乘法：*
除法：/
注意：整数与整数相除，只保留整数部分
取模：% 取余 被模数%模数
注意：取模结果的正负号只看被模数
特殊：模数的负号被忽略
正号：+
+：做为单目运算时表示正数 正号：+
与其余基本数据类型计算时当作加法用 a + b
在JAVA中：+ 还表示拼接
只要+两边有一个是字符串，那么就是拼接，结果仍然是字符串
a + “+”：a变量的值 拼接上 “+”符号 ,当与字符串String类型进行运算时表示链接，计算结果是字符串String类型 “菜”+“牛” “菜牛”
负号：-
-做为单目运算符时表示负数 -5
与其余基本数据类型计算时当作减法用 a-b
自增：++
自减：–
原则：自增与自减
++/–在前的，就先自增/自减，后取值
++/–在后的，就先取值，后自增/自减
整个表达式的扫描，是从左往右扫描，若是后面的先计算的，那么前面的就暂时先放到“操做数栈”中
对于自增变量自己来讲，++在前或在后都同样，自增变量都要加1
i++或++i，i就是自增变量
对于表达式来讲，i++和++i不同的，++在前，先自增，再进行其余运算，++在后，先进行其余运算，而后再自增
代码示例：
int i = 1;
i++;//i=2
int j = 1;
++j;//j=2
int a = 1;
int b = a++;//(1)先取a的值“1”放操做数栈(2)a再自增,a=2(3)再把操做数栈中的"1"赋值给b,b=1
int m = 1;
int n = ++m;//(1)m先自增,m=2(2)再取m的值“2”放操做数栈(3)再把操做数栈中的"2"赋值给n,n=1
int i = 1;
int j = i++ + ++i * i++;
/*
从左往右加载
(1)先算i++
①取i的值“1”放操做数栈
②i再自增 i=2
(2)再算++i
①i先自增 i=3
②再取i的值“3”放操做数栈
(3)再算i++
①取i的值“3”放操做数栈
②i再自增 i=4
(4)先算乘法
用操做数栈中3 * 3 = 9，并把9压会操做数栈
(5)再算求和
用操做数栈中的 1 + 9 = 10
(6)最后算赋值
j = 10
*/
二、 赋值运算符
基本赋值运算符：=
扩展赋值运算符：+=，-=，*=，/=，%=…
赋值：assign
最基本的赋值运算符：=
Java中赋值，永远是把等号=右边的赋值给左边的变量。
右边若是是常量值，那么就把常量的值直接赋值给左边的变量；
右边若是是变量，那么就把变量的值直接赋值给左边的变量；
右边若是是表达式，那么就把表达式的运算结果直接赋值给左边的变量；
扩展的赋值运算符：
+=，-=，*=，/=，%=
注意：
(1)+=等，中间是不能有空格的，即不能写成 + =
(2)若是结果的类型与左边的变量不在同样时，隐含了强制类型转换
注意：全部的赋值运算符的=左边必定是一个变量
扩展赋值运算符=右边的计算结果的类型若是比左边的大的话会强制类型转换，因此结果可能有风险。
扩展赋值运算符的计算：(1)赋值最后算(2)加载数据的顺序是把左边的变量的值先加载，再去与右边的表达式进行计算
int i = 1;
int j = 5;
j *= i++ + j++;//j = j *(i++ + j++);
/*
(1)先加载j的值“5”
(2)在计算i++
①先加载i的值“1”
②再i自增，i=2
(3)再计算j++
①先加载j的值"5"
②再j自增，j=6
(4)算 加法
i + 5 = 6
(5)算乘法
5 * 6 = 30
(6)赋值
j = 30
*/
三、 比较运算符
关系运算符，比较运算符：运算的结果只有true或false的布尔值
(1)> < >= <= !=
(2)== 判断是否相等，必定要与=赋值运算符区分开
(3)instanceof，引用数据类型的关系运算符.
大于：>
小于：<
大于等于：>=
小于等于：<=
等于：== 注意区分赋值运算符的=
不等于：!=
注意：比较表达式的运算结果必定只有true/false
比较表达式能够做为
(1)条件
(2)逻辑运算符的操做数
四、 逻辑运算符
逻辑运算符的操做数必须是布尔值，结果也是布尔值
逻辑与：&
运算规则：只有左右两边都为true，结果才为true。
例如：true & true 结果为true
false & true 结果为false
true & false 结果为false
false & false 结果为false
逻辑或：|
运算规则：只要左右两边有一个为true，结果就为true。
求的就是个性，不一样，两个操做数不一样时，结果为真，若是相同就为假
例如：true | true 结果为true
false | true 结果为true
true | false 结果为true
false | false 结果为false
逻辑异或：^
运算规则：只有左右两边不一样，结果才为true。
例如：true ^ true 结果为false
false ^ true 结果为true
true ^ false 结果为true
false ^ false 结果为false
逻辑非：!
运算规则：布尔值取反
例如：!true 为false
!false 为true
短路与：&&
运算规则：只有左右两边都为true，结果才为true。
例如：true & true 结果为true
true & false 结果为false
false & ? 结果就为false
它和逻辑与不一样的是当&&左边为false时，右边就不看了。
短路或：||
运算规则：只要左右两边有一个为true，结果就为true。
例如：true | ? 结果为treu
false | true 结果为true
false | false 结果为false
它和逻辑或不一样的是当||左边为true时，右边就不看了。
开发中通常用短路与和短路或比较多
面试题：&& 和 &的区别？
&&当左边为false，右边不计算
&无论左边是true仍是false，右边都要计算
五、 条件运算符
? :
语法格式：
条件表达式 ? 结果表达式1 : 结果表达式2
注意条件表达式结果必须是布尔类型
运算规则：
整个表达式的结果：当条件表达式为true时，就取结果表达式1的值，不然就取结果表达式2的值
代码示例：
(1)boolean类型
boolean marry = true;
System.out.println(marry? "已婚" : "未婚");
(2)求最值
int i = 3;
int j = 5;
int max = i>=j ? i : j;
//当i>=j时，max就赋值为i的值，不然就赋值为j的值
(3)求三个数的最大值
//找出三个整数中的最大值
int x = 3;
int y = 2;
int z = 5;
int max = x>=y ? x : y;
//运行到这里，max中存的是x,y中较大者
max = max >= z ? max : z;
System.out.println("max = " + max);
六、 位运算符
位运算符
效率很高，可是可读性很差
由于它是基于二进制补码直接运算的。
数轴来移动 比较好点来理解 不要这样理解右移除以2的几回方左移乘以2的几回方
用得好很高的效率 但可能不少程序员理解很差的
位运算符：操做数是整数
左移 << ：右边补0
右移 >> ：左边补0或1，原数最高位是1，就补1，原数最高位是0，就补0
无符号右移 >>>：左边补0
二进制位 变化 移动
/**
* 位运算符 - 移位
* 一、>> 向右移位，使用方法为 x >> n 表示 x 向右移动 n 位
* 对于正数来讲，向右移位时，高位补0，低位被挤掉
* 对于负数来讲，向右移位时，高位补1，低位被挤掉
*
* 二、<< 向左移位，使用方法为 x << n 表示 x 向左移动 n 位
* 不管是正数仍是负数，向左移位时，都是挤掉高位，低位补0
*
* 三、>>> 无符号右移
* 不管是正数仍是负数，向右移位时，高位一概补0，低位被挤掉
*
* 四、Java 中没有 <<< 运算符 【划重点】 有<
*/
eg:
public class BitOperator1 {
public static void main(String[] args) {
// 被 final 修饰的变量被称做【最终变量】，它是最终的、不可更改的变量 【不要当作"常量"对待】
final int x = 5 ; // 0b00000000_00000000_00000000_00000101
System.out.println( x );
// 尝试再次为 final 修饰的变量赋值
// x = 6 ; // 错误: 没法为最终变量x分配值
// 将 最终变量 x 中存储的数值向右移动1位后赋值给 y 变量
int y = x >> 1 ; // 0b0_00000000_00000000_00000000_0000010
System.out.println( y );
int z = x << 1 ; // 0b0000000_00000000_00000000_00000101_0
System.out.println( z );
System.out.println( "~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~" );
// -5【原码】: 1000_0000_0000_0000_0000_0000_0000_0101
// -5【反码】: 1111_1111_1111_1111_1111_1111_1111_1010
// -5【补码】: 1111_1111_1111_1111_1111_1111_1111_1011
final int m = -5 ; // 0b1111_1111_1111_1111_1111_1111_1111_1011
System.out.println( m );
int n = m >> 1 ; // // 0b1_1111_1111_1111_1111_1111_1111_1111_101
//【补码】1_1111_1111_1111_1111_1111_1111_1111_101
//【反码】1_1111_1111_1111_1111_1111_1111_1111_100
//【原码】1_0000_0000_0000_0000_0000_0000_0000_011
System.out.println( n );
System.out.println( "~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~" );
int p = m << 1 ; // 0b111_1111_1111_1111_1111_1111_1111_1011_0
//【补码】111_1111_1111_1111_1111_1111_1111_1011_0
//【反码】111_1111_1111_1111_1111_1111_1111_1010_1
//【原码】100_0000_0000_0000_0000_0000_0000_0101_0
System.out.println( p );
System.out.println( "~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~" );
int r = 0x7FFFFFFF ;
System.out.println( r );
int s = r << 1 ;
System.out.println( s );
}
}
public class BitOperator2 {
public static void main(String[] args) {
final int x = 5 ; // 0b00000000_00000000_00000000_00000101
final int y = -5 ; // 0b1111_1111_1111_1111_1111_1111_1111_1011
System.out.println( x >> 1 ); // 0b0_00000000_00000000_00000000_0000010
System.out.println( y >> 1 ); // 0b1_1111_1111_1111_1111_1111_1111_1111_101
System.out.println( "~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~" );
System.out.println( x >>> 1 ); // 0b0_00000000_00000000_00000000_0000010
System.out.println( y >>> 1 ); // 0b0_1111_1111_1111_1111_1111_1111_1111_101
}
}
<<
运算规则：左移几位感受就至关于乘以2的几回方
二进制补码左移n位，右边补0
右移：>>
运算规则：右移几位感受就至关于除以2的几回方
无符号右移：>>>
运算规则：往右移动后，左边空出来的位直接补0，不看符号位
/**
* 位运算符
* 一、| 按位或 ( 逐位或 )
* 二、& 按位与 ( 逐位与 )
* 三、^ 按位异或 (逐位异或 )
* 四、~ 按位取反 (逐位取反) 【注意连符号位也一块儿取反】
*/
eg:
public class BitOperator4 {
public static void main(String[] args) {
final int x = 5 ; // 0b00000000_00000000_00000000_00000101
final int y = 7 ; // 0b00000000_00000000_00000000_00000111
//【 5 】0b00000000_00000000_00000000_00000101
//【 7 】0b00000000_00000000_00000000_00000111
int a = x | y ; // 按位或: 0b00000000_00000000_00000000_00000111
System.out.println( a );
//【 5 】0b00000000_00000000_00000000_00000101
//【 7 】0b00000000_00000000_00000000_00000111
int b = x & y ; // 按位与: 0b00000000_00000000_00000000_00000101
System.out.println( b );
//【 5 】0b00000000_00000000_00000000_00000101
//【 7 】0b00000000_00000000_00000000_00000111
int c = x ^ y ; // 按位异或: 0b00000000_00000000_00000000_00000010
System.out.println( c );
System.out.println( "~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~" );
int r = 5 ; // 0b00000000_00000000_00000000_00000101
int s = 7 ; // 0b00000000_00000000_00000000_00000111
System.out.println( "r = " + r + " , s = " + s );
// int temp = s ; s = r ; r = temp ;
r = r ^ s ; // 0b00000000_00000000_00000000_00000010
s = r ^ s ; // 0b00000000_00000000_00000000_00000101
r = r ^ s ; // 0b00000000_00000000_00000000_00000111
System.out.println( "r = " + r + " , s = " + s );
System.out.println( "~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~" );
int j = 5 ; // 0b00000000_00000000_00000000_00000101
// 注意使用 ~ 按位取反时，会对整数的符号位也取反
int k = ~j ; //0b11111111_11111111_11111111_11111010
//【补码】 11111111_11111111_11111111_11111010
//【反码】 11111111_11111111_11111111_11111001
//【原码】 10000000_00000000_00000000_00000110
System.out.println( "j = " + j + " , k = " + k );
}
}
按位与：&
运算规则：
1 & 1 结果为1
1 & 0 结果为0
0 & 1 结果为0
0 & 0 结果为0
按位或：|
运算规则：
1 | 1 结果为1
1 | 0 结果为1
0 | 1 结果为1
0 & 0 结果为0
按位异或：^
运算规则：
1 ^ 1 结果为0
1 ^ 0 结果为1
0 ^ 1 结果为1
0 ^ 0 结果为0
按位取反：~
运算规则：~0就是1
~1就是0
如何区分&,|,^是逻辑运算符仍是位运算符？
若是操做数是boolean类型，就是逻辑运算符，若是操做数是整数，那么就位运算符。
总结
位运算符：操做数是整数
左移 << ：右边补0
右移 >> ：左边补0或1，原数最高位是1，就补1，原数最高位是0，就补0
无符号右移 >>>：左边补0
按位与 & ：二进制对应位置取与 ，同时为1才为1，不然为0
按位或 | ：二进制对应位置取或 ，有一个为1就为1
按位异或运算 ^ ：二进制对应位置取异或 ，二者不一样才为1
按位取反 ~ ：二进制对应位置取反 ，原来是1，变为0，原来是0变为1
说明：位运算符都是机器数直接运算的
七、 运算符优先级
算符优先级：
(1)赋值类运算符是最低的，即赋值最后算
(2)条件运算符
(3)||-> &&-> |-> ^-> & 短路 逻辑
(4)比较运算符
(5)左移右移的位运算符 << >> >>> 无符号右移：>>>
(6)算术运算符
乘、除、模高于加和减
(7)自增，自减，以及按位取反，非 ! ~
(8).(面向对象用)和()
咱们若是要准确的记忆每一种运算符的优先级是困难的。
咱们遵循一个原则：
(1)表达式不要写太复杂，能够分为多行
(2)若是非要混合运算，那么先算的用()括起来
关于&,|,^，看左右两边的操做数是boolean值，仍是整数，来决定是逻辑运算符仍是位运算符。
整数是位运算符 ^ 异或 运算符
提示说明：
(1)表达式不要太复杂
(2)先算的使用()
八、 运算符操做数类型说明
一、算术运算符
数字和单个字符可使用算术运算符。
其中+，当用于字符串时，表示拼接。
二、赋值运算符
右边的常量值、表达式的值、变量的值的类型必须与左边的变量一致或兼容(能够实现自动类型转换)或使用强制类型转换能够成功。
三、比较运算符
其余的比较运算符都是只能用于8种基本数据类型。
其中的==和!=能够用于引用数据类型的比较，用于比较对象的地址。(后面讲)
int i = 10;
int j = 10;
System.out.println(i==j);//true
char c1 = '帅';
char c2 = '帅';
System.out.println(c1 == c2);//true
四、逻辑运算符
逻辑运算符的操做数必须是boolean值
五、条件运算符
?前面必须是条件，必须是boolean值
结果表达式1和结果表达式2要保持类型一致或兼容
六、位运算符
通常用于整数系列
以上运算符都是针对基本数据类型设计的。
可以用于引用数据类型只有基本的赋值运算符=，和比较运算符中的==和!=。其余运算符都不能用于引用数据类型。
其中字符串类型还有一个+，表示拼接。
九、code
算术运算符
/*
运算符：
一、算术运算符
加：+
减：-
乘：*
除：/
特殊：整数/整数，结果只保留整数部分
取模(取余)：%
特殊：只看被模数的正负号
被模数%模数
什么是取模呢 取余呢
2%3=2
正号：+
负号：-
自增 本身加本身不是的 是本身增长1
自增：++
对于自增变量自己来讲，都会+1.
可是++在前仍是在后，对于整个表达式的计算来讲是不同的。
++在前，先自增，而后取自增后变量的值，
++在后，先取变量的值，而后变量自增。
可是无论怎么样，自增变量的取值与自增操做一前一后必定是一块儿完成的。
自减：--
类同自增
*/
class Test05_Arithmetic{
public static void main(String[] args){
int x = 10;
int y = 3;
//System.out.println("x + y = " + x + y);//变为拼接
System.out.println("x + y = " + (x + y));
System.out.println("x - y = " + (x - y));
System.out.println("x * y = " + (x * y));
System.out.println("x / y = " + (x / y));
System.out.println("x % y = " + (x % y));
System.out.println("----------------------------------");
//特殊：只看被模数的正负号
System.out.println("5%2 = " + 5%2);//1
System.out.println("-5%2 = " + -5%2);//-1
System.out.println("5%-2 = " + 5%-2);//1
System.out.println("-5%-2 = " + -5%-2);//-1
System.out.println("----------------------------------");
int a = -3;
System.out.println(-a);//3
System.out.println("----------------------------------");
int i = 2;
i++;
System.out.println("i = " + i);//3
int j = 2;
++j;
System.out.println("j = " + j);//3
System.out.println("----------------------------------");
int m = 1;
int n = ++m;//m先自增，而后把m的值取出来赋值给n
System.out.println("m = " + m);//2
System.out.println("n = " + n);//2
System.out.println("----------------------------------");
int p = 1;
int q = p++;//(1)先取出p的值"1"，先放到一个“操做数栈”，(2)而后p变量完成自增(3)把刚才放在“操做数栈”中的值赋值给q
System.out.println("p = " + p);//2
System.out.println("q = " + q);//1
System.out.println("q = " + (q = q++));//1
System.out.println("q = " + q);//1
System.out.println("----------------------------------");
int z = 1;
z = z++;//(1)先取出z的值"1"，先放到一个“操做数栈”，(2)而后z自增，变为2(3)把刚才放在“操做数栈”中的值赋值给z
System.out.println("z = " + z);//1
System.out.println("z = " + z++);//1
System.out.println("z = " + z);//2
System.out.println("z = " + ++z);//3
System.out.println("----------------------------------");
int b = 1;
int c = 2;
/*
第一个：b++
(1)先取b的值“1”，先放到一个“操做数栈”，
(2)紧接着b就自增了，b=2
操做数栈
第二步：++b
(1)先b自增，b=3
(2)紧接着再取b的值“3”，先放到一个“操做数栈”，
第三步：++b
(1)先b自增，b=4
(2)紧接着再取b的值“4”，先放到一个“操做数栈”，
第四步：c++
(1)先取c的值“2”，先放到一个“操做数栈”，
(2)紧接着c自增，c=3
第五步：算乘 ++b和c++的乘法部分
4*2 = 8 而后在压回“操做数栈”，
第六步：再算 b++ + ++b + 乘的结果
1 + 3 + 8 = 12
*/
int d = b++ + ++b + ++b * c++;
System.out.println("b = " + b);//4
System.out.println("c = " + c);//3
System.out.println("d = " + d);//12
}
}
练习
class Test06_Exer3{
public static void main(String[] args){
int i = 1;
int j = 2;
/*
第一步：++i
(1)先自增,i=2
(2)在取i的值“2”，放起来
第二步：j
(1)取j的值“2”，放起来
第三步：++i
(1)先自增，i=3
(2)在取i的值"3"，放起来
第四步：求乘积
2 * 3 = 6，结果放起来
第五步：求和
2 + 6 = 8
*/
System.out.println(++i + j * ++i);
}
}
/*
已知一个三位数，例如：483，如何用代码求出它的百位、十位、个位数
*/
class Test07_Exer4{
public static void main(String[] args){
int num = 483;
int bai = num / 100;// 483/100 4
//int shi = num/10%10;// 483/10 48 48%10 8
int shi = num%100/10;// 483%100 83 83/10 8
int ge = num % 10;// 483%10 3
System.out.println(num + "的百位：" + bai + "，十位：" + shi +"，个位：" + ge);
//483的百位：4，十位：8，个位：3
}
}
//字符串拼接
class Test08_Exer6{
public static void main(String[] args){
int no = 10;
String str = "abcdef";
String str1 = str + "xyz" + no;//abcdefxyz10
str1 = str1 + "123";//abcdefxyz10123
char c = '国';
double pi = 3.1416;
str1 = str1 + pi;//abcdefxyz101233.1416
boolean b = false;
boolean t = true;
System.out.println("" + b + t);//falsetrue
System.out.println(b + "" + t);//falsetrue
/*
System.out.println(b + t + "");
Error:(22, 30) java: 二元运算符 '+' 的操做数类型错误
第一个类型: boolean
第二个类型: boolean
* */
str1 = str1 + b;//abcdefxyz101233.1416false
str1 = str1 + c;//abcdefxyz101233.1416false国
String f = "false";
System.out.println(b + f);//falsefalse
System.out.println(f + b);//falsefalse
System.out.println("str1 = " + str1);
}
}
//什么是求和 什么是拼接
class Test08_Exer7{
public static void main(String[] args){
/*
String str1 = 4;
左边是String字符串类型，右边是4int类型，它们之间没法自动类型转换
*/
//String str1 = 4;
String str2 = 3.5f + "";
System.out.println(str2); //3.5
System.out .println(3+4+"Hello!"); //7Hello!
System.out.println("Hello!"+3+4); // Hello!34
System.out.println('a'+1+"Hello!"); // 98Hello!
System.out.println("Hello"+'a'+1); //Helloa1
}
}
class Test08_Exer8{
public static void main(String[] args){
short s = 5;
// s = s-2; //short - int，结果是int
// int赋值给short Error:(8, 14) java: 不兼容的类型: 从int转换到short可能会有损失
byte b = 3;
// b = b + 4; //byte + int，结果是int
//Error:(12, 17) java: 不兼容的类型: 从int转换到byte可能会有损失
b = (byte)(b+4); //能够
System.out.println(b);// 3+4 7
char c = 'a';
int i = 5;
float d = .314F;//非标准写法，若是整数部分是0，能够省略0，但不能省略小数点
double result = c+i+d; //char + int + float，结果是float，而后自动升级为double
byte byte1 = 5;
short short1 = 3;
// short t = short1 + byte1; //short + byte，结果是int
//Error:(24, 26) java: 不兼容的类型: 从int转换到short可能会有损失
int t = short1 + byte1; //short + byte，结果是int
System.out.println(t);//8
}
}
赋值运算符
/*
运算符：
二、赋值运算符
(1)基本的赋值运算符：=
赋值操做：永远是把=右边的常量值、变量中值、表达式计算的值赋值给=左边的变量，
即=左边只能是一个变量。
运算的顺序：把右边的整个表达式先算完，才会作最后的赋值操做。
(2)扩展的赋值运算符
例如：
+=
-=
*=
/=
%=
...
*/
class Test09_Assign{
public static void main(String[] args){
int x = 1;
int y = 2 ;
int z = 3;
// x + y = z;//=左边只能是一个变量
//Error:(31, 11) java: 意外的类型
// 须要: 变量
// 找到: 值
byte b1 = 1;
byte b2 = 2;
//b2 = b1 + b2;//右边byte + byte结果是int
b2 += b1;//等价于 b2 = (byte)(b2 + b1);
System.out.println("b1 = " + b1);//1
System.out.println("b2 = " + b2);//3
System.out.println("---------------------------");
//运算的顺序：把右边的整个表达式先算完，才会作最后的赋值操做。
int i = 1;
int j = 5;
/*
第一步 i++
(1)先取i的值 放起来
(2)i自增，i=2
第二步 求和
1 + 5 = 6
第三步 乘
j * (和) = 5 * 6 = 30
第四步 赋值 把乘积赋值给j
*/
j *= i++ + j;
System.out.println("i = " + i);//2
System.out.println("j = " + j);//30
}
}
比较运算符
*
运算符：
3、比较运算符
大于：>
小于：<
大于等于：>=
小于等于：<=
等于：==
注意，谨防与赋值的=混淆
不等于：!=
比较运算符，计算完后的结果只有两个：true,false
说明比较运算符的表达式，能够做为(1)判断的条件(2)逻辑运算符的操做数
比较运算符可以用于基本数据类型，不能用于引用数据类型。
除了==和!=，关于引用数据类型时它俩的意义后面再讲。
操做数几元
一元运算符：操做数只有一个
例如：a++ 其中a就是操做数
-a 其中a就是操做
二元运算符：须要两个操做数
例如：求和 a+b 其中a和b就是操做
比较大小 age>=18 其中的age和18都是操做数
三元运算符：须要三个操做数
...
*/
class Test10_Compare{
public static void main(String[] args){
/*
有一个变量age,表示年龄，判断是否成年(知足18岁)
*/
int age = 26;
System.out.println("是否成年：" + (age>=18));//是否成年：true
// System.out.println("是否成年：" + age>=18);//这是先字符串拼接的
/*
比较运算符做为条件
*/
if(age >= 18){
System.out.println("祝你玩得愉快！");
}else{
System.out.println("未成年不得进入！");
}
/*
有一个变量，存储的是boolean类型的值
*/
boolean flag = false;
if(flag == true){//不会修改flag里面的值
System.out.println("条件成立1");
}
//与上面的语句是等价的
if(flag){
System.out.println("条件成立2");
}
if(flag = true){//不是比较，而是赋值，结果仍然是布尔值，只要是布尔值就能够做为条件
System.out.println("条件成立3");
}
System.out.println("flag = " + flag);
/*
有一个变量，存储的是其余类型的值
*/
int num = 1;
if(num == 1){
System.out.println("num=1");
}
//true false 才是 最终的状况
//if(num = 1){//错误的，由于num=1是赋值表达式，结果仍是int，int值是不能做为条件的
//System.out.println("num=1");
//}
}
}
逻辑运算符
/*
运算符：
四、逻辑运算符
逻辑与：&
相似于：且
true & true 结果为true
true & false 结果为false
false & true 结果为false
false & false 结果为false
多个条件是否两个都成立 两个都知足的
逻辑或：|
相似于：或
true | true 结果为true
true | false 结果为true
false | true 结果为true
false | false 结果为false
知足一个 为true
逻辑非：!
相似于：取反
!true 结果为false
!false 结果为true
逻辑异或：^
相似于：求不一样
true ^ true 结果为false
true ^ false 结果为true
false ^ true 结果为true
false ^ false 结果为false
求不一样 不一样的为true 同样的为false
短路与：&&
结果：和&是同样的
运算规则：若是&&的左边已是false，右边就不看了
true & true 结果为true
true & false 结果为false
false & ? 结果为false
false & ? 结果为false
段路运算
短路或：||
结果：和|是同样的
运算规则：若是||左边已是true，右边就不看了
true | ？ 结果为true
true | ？ 结果为true
false | true 结果为true
false | false 结果为false
*/
class Test11_Logic{
public static void main(String[] args){
/*
判断成绩是否在70和80之间
数学：70<=score<=80
Java中：
*/
int score = -78;
/*
Test11_Logic.java:14: 错误: 二元运算符 '<=' 的操做数类型错误
if( 70<=score<=80){
^
第一个类型: boolean 70<=score的运算结果是true或false
第二个类型: int
1 个错误
false<=80 int
*/
//if( 70<=score<=80){
//System.out.println("良好");
//}
if(70<=score & score<=80){
System.out.println("良好");
}
/*
假设成绩合理范围[0,100]
判断成绩是否小于0 或 大于100，输出成绩有误
*/
if(score<0 | score>100){
System.out.println("成绩有误");
}
/*
假设成绩合理范围[0,100]
判断成绩是否在合理范围内
*/
if(score>=0 & score<=100){
}
//或下面这么写
if(!(score<0 | score>100)){
}
System.out.println(true ^ true);
System.out.println(true ^ false);
System.out.println(false ^ true);
System.out.println(false ^ false);
/*
短路与：&&
短路或：||
*/
int i = 1;
int j;
/*
第一步：i++
(1)先取i的值“1”，放起来
(2)在i自增,i=2
第二步：算比较
放起来的“1” == 1比较，成立
&&左边是true，不会短路
第三步：++i
(1)先自增i=3
(2)再取i的值“3”，放起来
第四步：比较
放起来的“3” == 2比较，结果是false，不成立
第五步：
左边的true && 右边的false运算，结果为false，总的if不成立，走else
*/
//if(i++ == 1 && ++i == 2){
//j = 1;
//}else{
//j = 2;
//}
/*
第一步：i++
(1)先取i的值“1”，放起来
(2)在i自增,i=2
第二步：算比较
放起来的“1” == 1比较，成立
||左边是true，会发生短路，右边不看了(++i == 2)没运算
第三步：
true || ?，结果为true,总的if成立
*/
if(i++ == 1 || ++i == 2){
j = 1;
}else{
j = 2;
}
System.out.println("i = " + i);
System.out.println("j = " + j);
}
}
练习
class Test12_Exer1{
public static void main(String[] args){
int x = 1;
int y = 1;
/*
第一步：x++
(1)先取x的值“1”
(2)再x自增x = 2
第二步：比较
用“1”与2比较， 1==2，不成立，false
由于&不是短路与，无论左边是怎么样，右边继续
第三步：++y
(1)自增 y = 2
(2)取y的值“2”
第四步：比较
用“2”与2比较 2 == 2,成立，true
第五步：逻辑
false & true，结果为false，总的if不成立
*/
if(x++ == 2 & ++y==2){
x = 7;
}
//& 两个都要处理的
System.out.println("x = " + x + ",y = " + y);//x = 2,y = 2
}
}
class Test12_Exer2{
public static void main(String[] args){
int x = 1;
int y = 1;
/*
第一步：x++
(1)先取x的值“1”
(2)再x自增x = 2
第二步：比较
用“1”与2比较， 1==2，不成立，false
由于&&是短路与，左边为false，右边就不看了
第三步：逻辑
false & ？，结果为false，总的if不成立
*/
//x=1 y=1
if(x++ == 2 && ++y==2){
x = 7;
}
System.out.println("x = " + x + ",y = " + y);//x = 2,y = 1
}
}
class Test12_Exer3{
public static void main(String[] args){
int x = 1;
int y = 1;
/*
第一步：x++
(1)先取x的值“1”
(2)再x自增x = 2
第二步：比较
用“1”与1比较， 1==1，成立，true
中间是|，不是短路或，右边要继续
第三步：++y
(1)y先自增，y=2
(2)再去y的值“2”
第四步：比较
用“2”与1比较 2==1，不成立，结果为false
第五步：逻辑
true & false，结果为true，总的if成立，要执行x = 7
*/
//
if(x++ == 1 | ++y==1){
x = 7;
}
System.out.println("x = " + x + ",y = " + y);//x = 7,y = 2
}
}
class Test12_Exer4{
public static void main(String[] args){
int x = 1;
int y = 1;
/*
第一步：x++
(1)先取x的值“1”
(2)再x自增x = 2
第二步：比较
用“1”与1比较， 1==1，成立，true
中间是||，是短路或，左边已经为true,会发生短路现象，右边不看了
第五步：逻辑
true & ？，结果为true，总的if成立，要执行x = 7
*/
// x = 1 ; y =1
if(x++ == 1 || ++y==1){
x = 7;
}
System.out.println("x = " + x + ",y = " + y);//x = 7,y = 1
}
class Test13_Exer{
public static void main(String[] args){
boolean x = true;
boolean y = false;
short z = 42;
/*
第一步：z++
(1)先取z的值“42”
(2)z自增 z=43
第二步：比较
用“42”与42比较，条件成立，true
中间是&&，短路与，可是没有知足短路现象。右边继续
第三步：
取y的值false
第四步：
比较，用"false"与true比较，条件不成立，false
第五步：
true && false，结果为false，if条件不成立，z++不执行
*/
if((z++==42) && (y==true))
z++;
/*
||左边：x=false，这是赋值运算，结果仍然是false
中间||，是短路或，可是没有知足短路现象，右边继续
右边：
++z：先自增z=44，而后取z的值“44”，而后与45进行比较，结果为false
左边的false || 右边的false，结果仍是false，if不成立，z++不执行
*/
if((x=false) || (++z==45))
z++;
System.out.println("z = " + z);//44
}
}
class Test13_Exer2{
public static void main(String[] args){
boolean x = true;
boolean y = false;
short z = 42;
/*
这里y=true是赋值，结果仍是true,表示条件成立，而且y的值已经变为true
*/
if(y=true)
/*
第一步：z++
(1)先取z的值“42”
(2)z自增 z=43
第二步：比较
用“42”与42比较，条件成立，true
中间是&&，短路与，可是没有知足短路现象。右边继续
第三步：
取y的值true
第四步：
比较，用"true"与true比较，条件成立，true
第五步：
true && true，结果为true，if条件成立，z++执行
z = 44
*/
if((z++==42) && (y==true))
z++;
/*
||左边：x=false，这是赋值运算，结果仍然是false
中间||，是短路或，可是没有知足短路现象，右边继续
右边：
++z：先自增z=45，而后取z的值“45”，而后与45进行比较，结果为true
左边的false || 右边的true，结果仍是true，if成立，z++执行，z=46
*/
if((x=false) || (++z==45))
z++;
System.out.println("z = " + z);//46
}
}
条件运算符
/*
运算符：
五、条件运算符，
由于它是惟一的三元运算符，因此也称为三元运算符
条件表达式 ？ 结果表达式1 ： 结果表达式2
整个表达式包含三个部分。
运算规则：若是条件表达式成立，就取结果表达式1的值，不然就取结果表达式2的值
*/
class Test14_Condition{
public static void main(String[] args){
boolean marry = false;
System.out.println(marry ? "已婚" : "未婚");
//找出x和y中的最大值
int x = 4;
int y = 4;
int max = x>=y ? x : y;
/*
等价于
if(x>=y){
max = x;
}else{
max = y;
}
*/
System.out.println(x + "，" + y + "中的最大值是：" + max);
int a = 4;
int b = 5;
int m;
if (a >= b){
m = a;
}else{
m = b;
}
System.out.println(a + ","+ + b + ","+"m:" + m);
int temp = a;
a = b;
b = temp;
m = a>=b ? a : b;
System.out.println();
System.out.println(a + ","+ + b + ","+"m:" + m);
}
}
位运算符
/*
运算符：(了解)
六、位运算符
效率很高，可是可读性很差
由于它是基于二进制补码直接运算的。
数轴来移动 比较好点来理解 不要这样理解右移除以2的几回方
用得好很高的效率 但可能不少程序员理解很差的
左移：<<
运算规则：<
二进制补码左移n位，右边补0
右移：>>
运算规则：>>几位，就除以2的几回方
二进制补码右移n位，左边补0仍是1，看最高位
无符号右移：>>>
运算规则：二进制补码右移n位，左边补0，对于负数来讲，移完后，变为正数
没有 <<< 由于就是<< 嗯嗯
按位与：&
1 & 1 结果1
1 & 0 结果0
0 & 1 结果0
0 & 0 结果0
按位或：|
1 | 1 结果1
1 | 0 结果1
0 | 1 结果1
0 | 0 结果0
按位异或：^
1 ^ 1 结果0
1 ^ 0 结果1
0 ^ 1 结果1
0 ^ 0 结果0
按位取反：~(一元运算符)
~1为0
~0为1
*/
class Test15_Bit{
public static void main(String[] args){
/*
4的二进制：0000 0100
4<<3：0 0100000
*/
System.out.println(4 << -3);//-2147483648 ？？？
System.out.println(4 << -32);//4
System.out.println(4 << 32);//4
System.out.println(4 << 35);//32
System.out.println(4 << 3);//等价于4乘以2的3次方，4*8=32
/*
32的二进制：0010 0000
32>>4：0000 0010
*/
System.out.println(32 >>4);//等价于32除以2的4次方，32/16 =2
/*
-32的二进制：
原码：1010 0000
反码：1101 1111
补码：1110 0000
-32>>4：1111 1110
补码：1111 1110
反码：1111 1101
原码：1000 0010
负的 右移 补1 少多少补多少
*/
System.out.println(-32 >>4);// -2
System.out.println(32 >>> 4);//和>>同样，左边补0 2
/*
-32的二进制：
原码：1000 0000 0000 0000 0000 0000 0010 0000
反码：1111 1111 1111 1111 1111 1111 1101 1111
补码：1111 1111 1111 1111 1111 1111 1110 0000
-32>>>4：0000 1111 1111 1111 1111 1111 1111 1110
最高位是0，是正数
*/
System.out.println(-32 >>> 4);//268435454
/*
32：0000 0000 0000 0000 0000 0000 0010 0000
25：0000 0000 0000 0000 0000 0000 0001 1001
32 & 25：0000 0000 0000 0000 0000 0000 0000 0000
*/
System.out.println(32 & 25);//0
/*
32：0000 0000 0000 0000 0000 0000 0010 0000
25：0000 0000 0000 0000 0000 0000 0001 1001
32 | 25：0000 0000 0000 0000 0000 0000 0011 1001
*/
System.out.println(32 | 25);//57
/*
32：0000 0000 0000 0000 0000 0000 0010 0000
25：0000 0000 0000 0000 0000 0000 0001 1001
32 | 25：0000 0000 0000 0000 0000 0000 0011 1001
*/
System.out.println(32 ^ 25);//57
/*
3：0000 0000 0000 0000 0000 0000 0000 0011
~3:1111 1111 1111 1111 1111 1111 1111 1100
补码：1111 1111 1111 1111 1111 1111 1111 1100
反码：1111 1111 1111 1111 1111 1111 1111 1011
原码：1000 0000 0000 0000 0000 0000 0000 0100 -4
*/
System.out.println(~3);//-4
}
}
运算符优先级
/*
运算符优先级：
(1)赋值类运算符是最低的，即赋值最后算
(2)条件运算符
(3)||-> &&-> |-> ^-> & 短路 逻辑
(4)比较运算符
(5)左移右移的位运算符 << >> >>> 无符号右移：>>>
(6)算术运算符
乘、除、模高于加和减
(7)自增，自减，以及按位取反，非 ! ~
(8).(面向对象用)和()
咱们若是要准确的记忆每一种运算符的优先级是困难的。
咱们遵循一个原则：
(1)表达式不要写太复杂，能够分为多行
(2)若是非要混合运算，那么先算的用()括起来
关于&,|,^，看左右两边的操做数是boolean值，仍是整数，来决定是逻辑运算符仍是位运算符。
整数是位运算符 ^ 异或 运算符
*/
class Test16_Priority{
}
练习交换两个变量的值、判断是否闰年、求最大值
交换两个变量的值
/*
交换两个变量的值
借助于第三个一样类型的变量
a b c
c = a;
a = b;
b = a;
*/
class Test17_Swap{
public static void main(String[] args){
int x = 1;
int y = 2;
/*
通用的方案：适用于任意的数据类型
借助于第三个通样类型的临时变量
*/
int temp = x;//x变量中值就赋值给了temp temp = 1
x = y;//再把y中的值放到x中，x = 2
y = temp;//再把temp中的值赋值给y y=1
System.out.println("x = " + x);
System.out.println("y = " + y);
temp = x;
x = y;
y = temp;
// x = 1;
// y = 2;
/*
方案二：只适用于int等整数类型 byte short int long
*/
x = x ^ y;
y = x ^ y;//(新的x) ^ 原来的y = (原来的x ^ 原来的y) ^ 原来的y = 原来的x (求不一样)
x = x ^ y;//(新的x) ^ 新的y = (原来的x ^ 原来的y) ^ 原来的x = 原来的y
System.out.println("x = " + x);
System.out.println("y = " + y);
// y = x ^ y ^ y; y = x; x = x ^ y ^ x;
x = 1;
y = 2;
/*
方案三：只适用于int等整数类型
有风险，可能会溢出
*/
x = x + y;//有风险，可能会溢出 大了 超了
y = x - y;//(新的x) - 原来的y = (原来的x + 原来的y)- 原来的y = 原来的x
x = x - y;//(新的x) - 新的y = (原来的x + 原来的y) - 原来的x = 原来的y
System.out.println("x = " + x);
System.out.println("y = " + y);
/*
如下不推荐
*/
x = 1;
y = 2;
x = x * y;//风险更大
y = x / y;
x = x / y;
}
}
判断是否闰年
/*
一、定义一个int类型变量，保存年份，判断这个年份是不是闰年
注：判断一年是不是闰年的标准：
1)能够被4整除，但不可被100整除
2)能够被400整除
*/
class Test18_Exer{
public static void main(String[] args){
int year = 2000;
boolean result = year%4==0 && year%100!=0 || year%400==0;
System.out.println(year + (result?"是闰年":"不是闰年"));
if ( year%4==0 && year%100!=0 || year%400==0){
System.out.println(year + "是闰年");
}
}
}
求最大值
//二、定义三个int类型的变量，x,y,z，随意赋值整数值，求最大值
class Test19_Exer{
public static void main(String[] args){
int x = 23;
int y = 34;
int z = 49;
//int max = x>=y ? x : y;//运行完这句max中存的是x与y中的最大值
//max = max >=z ? max : z;//用新的max与z比较
int max = (x>=y ? x : y) >= z ? (x>=y ? x : y) : z;
System.out.println("max = " + max);
//还不如两行的
// int min = (x<=y ? x:y) <= z ? (x<=y ? x:y) : z;
// System.out.println("min:" + min);
int min = x<=y ? x:y;//行完这句min中存的是x与y中的最小值
min = min<=z ? min :z;用新的min与z比较
System.out.println("min:" + min);
}
}
155
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
