目录
一.变量相关例题
例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) ;
}
}
//第一题
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) ;
}
}
运行结果
运算过程
二.运算符
(一)算术运算符
1.基本的算数运算符
1.基本的算数运算符
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
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
class OperatorTest{
public static void main(String[] args){
//定义变量x,求y的值
int x = 4;
int y = (x++)+(++x)+(x*10);
System.out.println("y="+y) ;
}
}
运行结果
运算过程
int y = (x++)+(++x)+(x*10); //int y = 4 + (++5) +(6*10) = 70
(二)赋值运算符
1.基本赋值运算符
等于=
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
class Test{
public static void main(String[] args){
short s = 1;
s=s+1;
System.out.println("s="+s);
}
}
运行结果
原因:
//Java默认类型提升(隐式类型转换)
解决办法:
class Test{
public static void main(String[] args){
short s = 1;
//s=s+1;
s = (short)(s+1);
System.out.println("s="+s);
}
}
运行结果
class Test{
public static void main(String[] args){
short s = 1;
s += 1;
System.out.println("s="+s);
}
}
运行结果
结论
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 ;
//直接输出结果
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.基本的逻辑运算符
1)逻辑单与&
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)逻辑单或|
运行结果
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)逻辑异或^
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)逻辑非!
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);
}
}
运行结果
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);
}
}
运行结果
(五)位运算符
1.位与&
class OperatorDemo{
public static void main(String[] args){
//3位与&4
System.out.println("3&4="+(3 & 4));
}
}
运行结果
运算过程
2.位或|
class OperatorDemo{
public static void main(String[] args){
//3位或|4
System.out.println("3|4="+(3 | 4));
}
}
运行结果
运算过程
3.位异或^
class OperatorDemo{
public static void main(String[] args){
//3位异或^4
System.out.println("3^4="+(3 ^ 4));
}
}
运行结果
运算过程
位异或^的特点
一个数据被另一个数据位异或两次,其值是它本身
例题
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);
}
}
运行结果
运算过程
4.反码~
class OperatorDemo{
public static void main(String[] args){
//反码3
System.out.println("~3="+(~ 3));
}
}
运行结果
运算过程
5.位移运算符
1)<<:左移
class OperatorDemo3{
public static void main(String[] args){
System.out.println("2<<2="+2<<2);
}
}
运行结果
运算过程
2)>>:右移
class OperatorDemo3{
public static void main(String[] args){
System.out.println("24>>2="+(24>>2));
}
}
运行结果
运算过程
3)>>>:无符号右移
class OperatorDemo3{
public static void main(String[] args){
System.out.println("-24>>>2="+(-24>>>2));
}
}
运行结果
(六)三元运算符(三目运算符)
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) ;
}
}
运行结果
