目录
一.变量相关例题
例1.
二.运算符
(一)算术运算符
1.基本的算数运算符
2.扩展的算术运算符
(二)赋值运算符
1.基本赋值运算符
2.扩展的赋值运算符
(三)关系运算符
比较运算符
(四)逻辑运算符
1.基本的逻辑运算符
2.扩展的逻辑运算符
(五)位运算符
1.位与&
2.位或|
3.位异或^
4.反码~
5.位移运算符
(六)三元运算符(三目运算符)
一.变量相关例题 例1.
//第一题
byte b1=10,b2=20,b;
b=b1+b2;
b=10+20;
//哪一句是编译失败的呢?为什么呢>如何改正class DataTypeDemo{
public static void main(String[] args){
//定义三个变量
byte b1 = 10,b2 = 20,b ;
//第一句话
b=b1+b2 ;
System.out.println("b的结果是:"+b) ;
}
}运行结果
原因:
变量相加:要考虑这个两个变量的数据类型,
b =b1 +b2 ; b1和b2都是byte类型,当参与运算时,b1和b2先提升为int,结果应该int类型
而b是byte类型,无法接收int类型的结果,必须强制类型转换
解决办法:
强制类型转换
//强制类型转换:目标数据类型 变量名 = (目标数据类型)(初始化值/表达式);
b = (byte)(b1+b2);运行结果:
class DataTypeDemo{
public static void main(String[] args){
//定义三个变量
byte b1 = 10,b2 = 20,b ;
//第二句话
b = 10 + 20;
System.out.println("b的结果是:"+b) ;
}
}运行结果:
常量相加:先相加,然后看计算结果是否在固定的类型范围内,在范围内就直接赋值
例2
byte x = 129;
//是否编译通过,结果是多少,并写出计算过程;byte类型的取值范围:-128~127
class DataTypeDemo{
public static void main(String[] args){
//定义一个变量
byte x = 129;
//输出x的结果
System.out.println("x的结果是:"+x) ;
}
}
运行结果:
由于129已经超出了byte的取值范围,整数类型默认是int类型,jvm在编译的时候会认为是int类型,因此129应该是int类型接收,但是左边的x是byte类型,无法接收int类型的数据,所以必须进行强制类型转换
class DataTypeDemo{
public static void main(String[] args){
//byte x = 129;错误: 不兼容的类型: 从int转换到byte可能会有损失
//强制类型转换
//目标数据类型 = (目标数据类型)(初始化值/表达式);
byte x = (byte)129;
System.out.println("x的结果是:"+x) ;
}
}运行结果
运算过程
/*129十进制----->二进制10000001
已经超出了byte类型的取值范围,jvm编译默认为int类型,8个字节
原码:00000000 00000000 00000000 10000001
计算机底层计算-----使用补码进行计算
129是正数,所以原码,反码,补码相同
补码:00000000 00000000 00000000 10000001
进行强制类型转换:byte x = (byte)129;
对129补码00000000 00000000 00000000 10000001进行截取,
截取之后----->10000001,1个字节的byte类型
最高符号位 数值位
补码: 1 0000001
- 1
-------------------------------
反码: 1 0000000 在补码的基础上,最高符号位不变,数值位末尾减1
原码: 1 1111111 在反码的基础上,最高符号位不变,数值位按位取反
=- (64+32+16+8+4+2+1)
=-127
*/1)加+
class OperatorDemo{
public static void main(String[] args){
//定义两个变量
int a = 10;
int b = 20;
//输出a+b
System.out.println("a+b="+(a+b));
}
}运行结果:
2)减-
class OperatorDemo{
public static void main(String[] args){
//定义两个变量
int a = 10;
int b = 20;
//输出a-b
System.out.println("a-b="+(a-b));
}
}运行结果:
3)乘*
class OperatorDemo{
public static void main(String[] args){
//定义两个变量
int a = 10;
int b = 20;
//输出a*b
System.out.println("a×b="+(a*b));
}
}运行结果
4)取整/
class OperatorDemo{
public static void main(String[] args){
//定义两个变量
int a = 40;
int b = 20;
//输出a/b
System.out.println("a÷b="+(a/b));
}
}运行结果
5)模余(取余)%
class OperatorDemo{
public static void main(String[] args){
//定义两个变量
int a = 4;
int b = 3;
//输出a%b
System.out.println("a%b="+(a%b));
}
}运行结果
2.扩展的算术运算符++/--
1)单独使用
a.++/--在数据的前面
class OperatorDemo2{
public static void main(String[] args){
//定义两个变量
int a = 4 ;
int b = 5 ;
//分别输出a,b的值
System.out.println("a="+a) ;
System.out.println("b="+b) ;
//情况1:单独使用
//++或者--在数据的前面
++a;
--b;
//分别输出a,b的值
System.out.println("a="+a) ;
System.out.println("b="+b) ;
}
}运行结果
b.++/--在数据的后面
class OperatorDemo2{
public static void main(String[] args){
//定义两个变量
int a = 4 ;
int b = 5 ;
//分别输出a,b的值
System.out.println("a="+a) ;
System.out.println("b="+b) ;
//情况1:单独使用
//++或者--在数据的前面
a++;
b--;
//分别输出a,b的值
System.out.println("a="+a) ;
System.out.println("b="+b) ;
}
}运行结果
结论:
无论在数据的前面还是后面,都是对当前变量的值进行自增1或者自减1
2)参与运算使用
a.++/--在数据的前面
class OperatorDemo2{
public static void main(String[] args){
//定义两个变量
int a = 4 ;
int b = 5 ;
//情况2:参与运算使用
//++或者--在数据的前面
int m = ++a;
int n = --b;
//分别输出a,b,m,n的值
System.out.println("a="+a) ;
System.out.println("b="+b) ;
System.out.println("m="+m) ;
System.out.println("n="+n) ;
}
}运行结果
结论:
++或者--在数据的前面: 先进行自增1或者自减1,然后参与运算
b.++/--在数据的后面
class OperatorDemo2{
public static void main(String[] args){
//定义两个变量
int a = 4 ;
int b = 5 ;
//情况2:参与运算使用
//++或者--在数据的后面
int m = a++;
int n = b--;
//分别输出a,b,m,n的值
System.out.println("a="+a) ;
System.out.println("b="+b) ;
System.out.println("m="+m) ;
System.out.println("n="+n) ;
}
}运行结果
结论:
++或者--在数据的后面: 先进行运算,然后在自增1或者自减1
例题
例1
/*
1)
int a = 10;
int b = 10;
int c = 10;
a = b++; //a=10,b=11 ,c=10
c = --a; //a=9, b=11,c=9
b = ++a; //a=10,b=10 c = 9
a = c--; //a=9, b=10,c=8
请分别计算出a,b,c的值
*/class OperatorTest{
public static void main(String[] args){
//定义三个变量
int a = 10;
int b = 10;
int c = 10;
a = b++;
c = --a;
b = ++a;
a = c--;
//输出a,b,c
System.out.println("a="+a+",b="+b+",c="+c);
}
}运行结果
例2
/*
2)
int x = 4;
int y = (x++)+(++x)+(x*10);
y的值是多少
*/class OperatorTest{
public static void main(String[] args){
//定义变量x,求y的值
int x = 4;
int y = (x++)+(++x)+(x*10);
System.out.println("y="+y) ;
}
}运行结果
运算过程
/*
(x++)
x=4,将()看成一个整体,将4先给(),然后x再自增1,x=5
(++x)
x=5,x先自增1,x=6,然后将()看成一个整体,将6给()
*/
int y = (x++)+(++x)+(x*10);
//int y = 4 + (++5) +(6*10) = 70 等于=
class OperatorDemo{
public static void main(String[] args){
//基本赋值运算符=
int a = 10 ;
//输出a
System.out.println("a的值是:"+a) ;
}
}运行结果
注意
等号不能写成==,==属于比较运算符,比较的是两个数据值是否相同
2.扩展的赋值运算符1)+=
class OperatorDemo{
public static void main(String[] args){
//定义一个变量m
int m = 150 ;
m += 200 ;
System.out.println("m="+m) ;
}
}运行结果
int m = 150 ;
m += 200 ; //都是int类型 等价于 int m = m+200 ;2)-=
class OperatorDemo{
public static void main(String[] args){
//定义一个变量m
int m = 150 ;
m -= 200 ;
System.out.println("m="+m) ;
}
}运行结果
int m = 150 ;
m -= 200 ; //都是int类型 等价于 int m = m-200 ;3)*=
class OperatorDemo{
public static void main(String[] args){
//定义一个变量m
int m = 15 ;
m *= 20 ; //都是int类型 等价于 int m = m*20 ;
System.out.println("m="+m) ;
}
}运行结果
int m = 15 ;
m *= 20 ; //都是int类型 等价于 int m = m*20 ;4)/=
class OperatorDemo{
public static void main(String[] args){
//定义一个变量m
int m = 20 ;
m /= 3 ; //都是int类型 等价于 int m = m/3 ;
System.out.println("m="+m) ;
}
}运行结果
int m = 20 ;
m /= 3 ; //都是int类型 等价于 int m = m/3 ;5)%=
class OperatorDemo{
public static void main(String[] args){
//定义一个变量m
int m = 20 ;
m %= 3 ; //都是int类型 等价于 int m = m%3 ;
System.out.println("m="+m) ;
}
}运行结果
int m = 20 ;
m %= 3 ; //都是int类型 等价于 int m = m%3 ;例题
例1
/*
1)
short s = 1 ;
s = s +1 ;
s的值?
有没问题,有问题,如何改正
*/class Test{
public static void main(String[] args){
short s = 1;
s=s+1;
System.out.println("s="+s);
}
}运行结果
原因:
//Java默认类型提升(隐式类型转换)
/*当byte,short,char三者不转换,一旦参与运算,优先提升int
= 右边是int类型的结果,=左边short接收,无法接收大类型必须强转类型转换
*/解决办法:
class Test{
public static void main(String[] args){
short s = 1;
//s=s+1;
s = (short)(s+1);
System.out.println("s="+s);
}
}运行结果
/*
2)
short s = 1;
s +=1;
s的值?
有没问题,有问题,如何改正
*/class Test{
public static void main(String[] args){
short s = 1;
s += 1;
System.out.println("s="+s);
}
}运行结果
结论
s += 1 ;
/*
s是short类型,扩展的赋值运算符在这种场景下,隐藏了强制类型转换
等价于short s = (short)(s+1);
*//*
关系运算符--比较运算符
< , <= , > , >= , == , !=
*/class OperatorDemo{
public static void main(String[] args){
//定义两个变量
int a = 3 ;
int b = 5 ;
int c = 4 ;
//直接输出结果
System.out.println((b+c)<(a+c)) ;
System.out.println((b+c)<=(a+c)) ;
System.out.println((b+c)>(a+c)) ;
System.out.println((a+b)>=(a+c)) ;
System.out.println((a+b)==(a+c)) ;
System.out.println(a!=b) ;
}
} 运行结果
可以看到比较运算符的结果是用布尔类型输出的
可以使用布尔类型接收
class OperatorDemo{
public static void main(String[] args){
//定义两个变量
int a = 3 ;
int b = 5 ;
int c = 4 ;
//可以使用boolean类型变量接收
boolean flag = ((a+b)>=(a+c)) ;
System.out.println(flag) ;
}
} 运行结果
/*注意:
==不能写成=,==比较,=是赋值
*/1)逻辑单与&
/*
逻辑单与&
特点:并列关系(交集)
有false,则false
*/class OperatorDemo{
public static void main(String[] args){
//定义三个变量
int a = 3 ;
int b = 4 ;
int c = 5 ;
//逻辑单与&:并列条件
System.out.println((a>b) & (a>c)) ;
System.out.println((a>b) & (ac)) ;
System.out.println((a 运行结果
运算过程
//逻辑单与&
System.out.println((a>b) & (a>c)) ; //false & false = false
System.out.println((a>b) & (ac)) ; //true & false = false
System.out.println((a 2)逻辑单或|
/*
逻辑单或|:
特点: 或的关系(并集)
有true,则true
*/运行结果
class OperatorDemo{
public static void main(String[] args){
//定义三个变量
int a = 3 ;
int b = 4 ;
int c = 5 ;
//逻辑单或|:或的关系
System.out.println((a>b) | (a>c)) ;
System.out.println((a>b) | (ac)) ;
System.out.println((a 运算过程
//逻辑单或|
System.out.println((a>b) | (a>c)) ; //false | false =false
System.out.println((a>b) | (ac)) ; // true | false = true
System.out.println((a 3)逻辑异或^
/*
逻辑异或^:
特点: 相同则为false,不同则为true
*/class OperatorDemo{
public static void main(String[] args){
//定义三个变量
int a = 3 ;
int b = 4 ;
int c = 5 ;
//逻辑异或^
System.out.println((a>b) ^ (a>c)) ;
System.out.println((a>b) ^ (ac)) ;
System.out.println((a 运行结果
//逻辑异或^
System.out.println((a>b) ^ (a>c)) ; //false ^ false = false
System.out.println((a>b) ^ (ac)) ; // true ^ false = true
System.out.println((a 4)逻辑非!
/*
逻辑非!:
特点:
非true,则false;非false,则true; 偶数个非是它本身
*/class OperatorDemo{
public static void main(String[] args){
//定义三个变量
int a = 3 ;
int b = 4 ;
int c = 5 ;
//逻辑非!
System.out.println(!(a>b)) ;
System.out.println(!!(a>b)) ;
}
}运行结果
2.扩展的逻辑运算符1)逻辑双与&&
class OperatorDemo2{
public static void main(String[] args){
//定义两个变量
int x = 3;
int y = 4;
System.out.println("x="+x+",y="+y);
System.out.println("-------------------");
//逻辑双与&&
System.out.println(((++x)==4) && ((--y)==5));
System.out.println("x="+x+",y="+y);
System.out.println(((++x)==3) && ((--y)==5));
System.out.println("x="+x+",y="+y);
}
}运行结果
/*
逻辑双与&&:具有短路效果
若左边表达式为false则右边不执行,结果为false
若左边表达式为true,则判断右边的表达式
若右边表达式为true,则结果为true
若右边表达式为false,则结果为false
*/2)逻辑双或||
class OperatorDemo2{
public static void main(String[] args){
//定义两个变量
int x = 3;
int y = 4;
System.out.println("x="+x+",y="+y);
System.out.println("-------------------");
//逻辑双与||
System.out.println(((++x)==4) || ((--y)==5));
System.out.println("x="+x+",y="+y);
System.out.println(((++x)==3) || ((--y)==5));
System.out.println("x="+x+",y="+y);
}
}运行结果
/*
逻辑双或(短路或): ||
若左边表达式为true则右边不执行,结果为true
若左边表达式为false,则判断右边的表达式
若右边表达式为true,则结果为true
若右边表达式为false,则结果为false
*//*
开发中,(前端:JavaScript)/(后端:Java语言)
只要有逻辑并列关系判断,优先采取逻辑双与&&
或者关系判断,优先采取逻辑双或||
执行效率高
*/class OperatorDemo{
public static void main(String[] args){
//3位与&4
System.out.println("3&4="+(3 & 4));
}
}运行结果
运算过程
/*
3----->二进制00000011
原码:00000000 00000000 00000000 00000011
反码:00000000 00000000 00000000 00000011
补码;00000000 00000000 00000000 00000011
4----->二进制00000100
原码:00000000 00000000 00000000 00000100
反码:00000000 00000000 00000000 00000100
补码:00000000 00000000 00000000 00000100
计算机底层用补码进行计算
00000000 00000000 00000000 00000011
位与&(有0则0)
00000000 00000000 00000000 00000100
-----------------------------------------
00000000 00000000 00000000 00000000
= 0
*/class OperatorDemo{
public static void main(String[] args){
//3位或|4
System.out.println("3|4="+(3 | 4));
}
}运行结果
运算过程
/*
3----->二进制00000011
原码:00000000 00000000 00000000 00000011
反码:00000000 00000000 00000000 00000011
补码;00000000 00000000 00000000 00000011
4----->二进制00000100
原码:00000000 00000000 00000000 00000100
反码:00000000 00000000 00000000 00000100
补码:00000000 00000000 00000000 00000100
计算机底层用补码进行计算
00000000 00000000 00000000 00000011
位或|(有1则1)
00000000 00000000 00000000 00000100
-----------------------------------------
00000000 00000000 00000000 00000111
= 4+2+1
= 7
*/class OperatorDemo{
public static void main(String[] args){
//3位异或^4
System.out.println("3^4="+(3 ^ 4));
}
}运行结果
运算过程
/*
3----->二进制00000011
原码:00000000 00000000 00000000 00000011
反码:00000000 00000000 00000000 00000011
补码;00000000 00000000 00000000 00000011
4----->二进制00000100
原码:00000000 00000000 00000000 00000100
反码:00000000 00000000 00000000 00000100
补码:00000000 00000000 00000000 00000100
计算机底层用补码进行计算
00000000 00000000 00000000 00000011
位异或^(相同为0,不同为1)
00000000 00000000 00000000 00000100
-----------------------------------------
00000000 00000000 00000000 00000111
= 4+2+1
= 7
*/位异或^的特点
一个数据被另一个数据位异或两次,其值是它本身
例题
class OperatorDemo2{
public static void main(String[] args){
//定义两个变量
int a = 10;
int b = 20;
System.out.println(a ^ b ^ b);
System.out.println(a ^ b ^ a);
}
}运行结果
运算过程
/*
10----->二进制00001010
原码:00000000 00000000 00000000 00001010
反码:00000000 00000000 00000000 00001010
补码:00000000 00000000 00000000 00001010
20----->二进制00010100
原码:00000000 00000000 00000000 00010100
反码:00000000 00000000 00000000 00010100
补码:00000000 00000000 00000000 00010100
补码:00000000 00000000 00000000 00001010
a位异或^b
补码:00000000 00000000 00000000 00010100
---------------------------------------------
补码:00000000 00000000 00000000 00011110
位异或^b
补码:00000000 00000000 00000000 00010100
---------------------------------------------
补码:00000000 00000000 00000000 00001010
反码:00000000 00000000 00000000 00001010
原码:00000000 00000000 00000000 00001010
=10
=a
*//*
10----->二进制00001010
原码:00000000 00000000 00000000 00001010
反码:00000000 00000000 00000000 00001010
补码:00000000 00000000 00000000 00001010
20----->二进制00010100
原码:00000000 00000000 00000000 00010100
反码:00000000 00000000 00000000 00010100
补码:00000000 00000000 00000000 00010100
补码:00000000 00000000 00000000 00001010
a位异或^b
补码:00000000 00000000 00000000 00010100
---------------------------------------------
补码:00000000 00000000 00000000 00011110
位异或^a
补码:00000000 00000000 00000000 00001010
---------------------------------------------
补码:00000000 00000000 00000000 00010100
反码:00000000 00000000 00000000 00010100
原码:00000000 00000000 00000000 00010100
=20
=b
*/class OperatorDemo{
public static void main(String[] args){
//反码3
System.out.println("~3="+(~ 3));
}
}运行结果
运算过程
/*
3----->二进制00000011
原码:00000000 00000000 00000000 00000011
反码:00000000 00000000 00000000 00000011
补码;00000000 00000000 00000000 00000011
计算机底层用补码进行计算
00000000 00000000 00000000 00000011
反码~(0变1,1变0)
-----------------------------------------
最高符号位 数值位
1 1111111 11111111 11111111 11111100 补码
- 1
-----------------------------------------
1 1111111 11111111 11111111 11111011 反码
1 0000000 00000000 00000000 00000100 原码
=- 4
=-4
*/1)<<:左移
/*
<<:左移
将数据的补码进行左移动,右边不够的补0,将最高符号位丢弃
格式:操作数<<位移数
算法:操作数乘以2的位移数次幂
*/class OperatorDemo3{
public static void main(String[] args){
System.out.println("2<<2="+2<<2);
}
}运行结果
运算过程
/*
计算出2十进制对应的二进制
2
00000000 00000000 00000000 00000010
<<2
00000000 00000000 00000000 00001000
=8
*/2)>>:右移
/*
>>:右移
将数据的补码进行右移动,
如果最高符号位为1,则左边补1
如果最高符号位为0,则左边补0
格式: *** 作数>>位移数
算法: *** 作数除以位移数的2次幂
*/class OperatorDemo3{
public static void main(String[] args){
System.out.println("24>>2="+(24>>2));
}
}运行结果
运算过程
/*
24
00000000 00000000 00000000 00011000
>>2
00000000 00000000 00000000 00000110
=4+2
=6
*/3)>>>:无符号右移
/*
>>>:无符号右移
无论最高符号位是1还是0,左边始终补零
*/class OperatorDemo3{
public static void main(String[] args){
System.out.println("-24>>>2="+(-24>>>2));
}
}运行结果
(六)三元运算符(三目运算符)/*
三元(三目)运算符
格式:
(表达式)?执行true的结果:执行false的结果;
执行流程:
1)首先表达式是否成立,成立,则执行true的结构,
2)不成立,执行 false 的结果
*/class OperatorDemo{
public static void main(String[] args){
//需求:有两个变量a,b,分别初始化,比较两个数据的最大值;
int a = 10 ;
int b = 5 ;
//定义结果变量
//(表达式)?执行true的结果:执行false的结果;
int max = (a>b)?a:b;
System.out.println("max="+max) ;
}
}运行结果
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）