(1)算术运算符

A:+,-,*,/,%,++,--

B:+的用法

a:加法

b:正号

c:字符串连接符

C:/和%的区别

数据做除法操作的时候，/取得是商，%取得是余数

D:++和--的用法

a:他们的作用是自增或者自减

b:使用**单独使用

放在操作数据的前面和后面效果一样。

a++或者++a效果一样。**参与操作使用

放在操作数的前面：先自增或者自减，再参与操作int a = 10;int b = ++a;

放在操作数的后面：先参与操作，再自增或者自减int a = 10;int b = a++;

/和%的区别：

/*注意事项：

A:整数相除只能得到整数。如果想得到小数，必须把数据变化为浮点数类型

B:/获取的是除法操作的商，%获取的是除法操作的余数*/class OperatorDemo {

public staticvoidmain(String[] args) {//定义变量

int x = 3; //把3赋值给int类型的变量x

int y = 4;

System.out.println(x+y);

System.out.println(x-y);

System.out.println(x*y);

System.out.println(x/y); //得到0，整数相除只能得到整数

//我就想得到小数，该肿么办呢?

//只需要把操作的数据中任意的一个数据变为浮点数

System.out.println(x*1.0/y);

//%的应用

System.out.println(x%y); //得到的是余数

}

}

++,--运算符的使用;

/*++,--运算符的使用：

单独使用：

放在操作数的前面和后面效果一样。(这种用法是我们比较常见的)

参与运算使用：

放在操作数的前面，先自增或者自减，然后再参与运算。

放在操作数的后面，先参与运算，再自增或者自减。

作用：就是对变量进行自增1或者自减1。*/class OperatorDemo2 {

public staticvoidmain(String[] args) {//定义两个变量

int x = 3;int y = 4;//字符串的拼接，字符串在前面

//System.out.println("x:"+x);

//System.out.println("y:"+y);

System.out.println("x:"+x+",y:"+y);//单独使用

//x++;

//y--;

++x;--y;//System.out.println(x);

System.out.println("x:"+x+",y:"+y);//意外的类型,常量是不可以这样做的

//System.out.println(10++);

System.out.println("-------------------");//参与运算使用

int a = 3;int b = 4;//int c = a++;

//int d = b--;

int c = ++a; //++放在操作数前面，先自增或者自减，然后再赋值

int d = --b;

System.out.println("a:"+a); //4, 4

System.out.println("b:"+b); //3, 3

System.out.println("c:"+c); //3, 4

System.out.println("d:"+d); //4, 3

}

}

运算符的优先级：

+的用法：

/*+的用法：

A:加法

B:正号

C:字符串连接符*/class OperatorDemo3 {

public staticvoidmain(String[] args) {//加法

System.out.println(3+4);//正号

System.out.println(+4);

System.out.println('a');//直接输出字符a

System.out.println('a'+1); //字符a和1的加法，这里是加法输出98

//字符串连接符，注意是字符串而不是字符

System.out.println("hello"+'a'+1);//helloa1，字符串hello和字符a链接，得到字符串helloa，再和链接

System.out.println('a'+1+"hello");//98hello，先进行字符a和1的加法运算，再和字符串hello链接

}

}

(2)赋值运算符

(2)赋值运算符

A:=,+=,-=,*=,/=,%=等

B:=叫做赋值运算符，也是最基本的赋值运算符int x = 10; 把10赋值给int类型的变量x。

C:扩展的赋值运算符的特点

隐含了自动强制转换。

例子：short s = 1;

s= s + 1;short s = 1;

s+= 1;

请问上面的代码哪个有问题?

赋值运算符：

/*赋值运算符：

基本的赋值运算符：=

把=右边的数据赋值给左边。

扩展的赋值运算符：+=,-=,*=,/=,%=

+= 把左边和右边做加法，然后赋值给左边。*/class OperatorDemo {

public staticvoidmain(String[] args) {//定义一个变量

int x = 10;//其他用法

inta,b;

a= b = 10;//把10赋给b,再把b赋值给a。这种写法不建议

System.out.println(a);

System.out.println(b);

System.out.println("-----------");//定义一个变量

int y = 10;

y+= 20;//y = y + 20

System.out.println(y);

}

}

扩展的赋值运算符其实隐含了一个强制类型转换：

/*short s=1;s = s+1;

short s=1;s+=1;

上面两个代码有没有问题，如果有，那里有问题。

为什么第二个木有问题呢?

扩展的赋值运算符其实隐含了一个强制类型转换。

s += 1;

不是等价于 s = s + 1;

而是等价于 s = (s的数据类型)(s + 1);*/class OperatorTest {

public staticvoidmain(String[] args) {//short s = 1;

//s = s + 1;

//System.out.println(s);

//s = s + 1;//short类型，先转成int,和1相加，再赋值给short类型，报错

short s = 1;

s+= 1; //好像是 s = s + 1;

System.out.println(s);

}

}

(3)比较运算符

/*比较运算符：

==,!=,>,>=,

特点：

无论你的操作是简单还是复杂，结果是boolean类型。

注意事项：

"=="不能写成"="。*/class OperatorDemo {

public staticvoidmain(String[] args) {int x = 3;int y = 4;int z = 3;

System.out.println(x==y);

System.out.println(x==z);

System.out.println((x+y) == (x+z));

System.out.println("------------");

System.out.println(x!=y);

System.out.println(x>y);

System.out.println(x>=y);

System.out.println(x

System.out.println(x<=y);

System.out.println("------------");int a = 10;int b = 20;//boolean flag = (a == b);

//boolean flag = (a = b); //这个是有问题的，不兼容的类型。

//把b赋值给a，然后把a留下来，而a是int类型，赋值给flag的布尔类型，报错

//System.out.println(flag);

int c = (a = b); //把b赋值给a，然后把a留下来，而a是int类型，赋值给flag的布尔类型，出错

System.out.println(c);

(4)逻辑运算符

A:&,|,^,!,&&,||B:逻辑运算符用于连接boolean类型的式子

C:结论&:有false则false|:有true则true^:相同则false，不同则true。

情侣关系。!:非true则false，非false则true&&:结果和&是一样的，只不过有短路效果。左边是false，右边不执行。||:结果和|是一样的，只不过有短路效果。左边是true，右边不执行。

/*逻辑运算符：

&,|,^,!

&&,||

特点：

逻辑运算符一般用于连接boolean类型的表达式或者值。

表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。

算术表达式：a + b

比较表达式：a == b

结论：

&逻辑与:有false则false。

|逻辑或:有true则true。

^逻辑异或:相同为false，不同为true。

举例：情侣关系。男男,男女,女男,女女

!逻辑非:非false则true，非true则false。

特点：偶数个不改变本身。*/class OperatorDemo {

public staticvoidmain(String[] args) {int a = 3;int b = 4;int c = 5;//&逻辑与

System.out.println((a > b) & (a > c)); //false & false = false

System.out.println((a > b) & (a < c)); //false & true = false

System.out.println((a < b) & (a > c)); //true & false = false

System.out.println((a < b) & (a < c)); //true & true = true

System.out.println("---------------");//|逻辑或

System.out.println((a > b) | (a > c)); //false | false = false

System.out.println((a > b) | (a < c)); //false | true = true

System.out.println((a < b) | (a > c)); //true | false = true

System.out.println((a < b) | (a < c)); //true | true = true

System.out.println("---------------");//^逻辑异或

System.out.println((a > b) ^ (a > c)); //false ^ false = false

System.out.println((a > b) ^ (a < c)); //false ^ true = true

System.out.println((a < b) ^ (a > c)); //true ^ false = true

System.out.println((a < b) ^ (a < c)); //true ^ true = false

System.out.println("---------------");//!逻辑非

System.out.println(!(a > b)); //!false = true

System.out.println(!(a < b)); //!true = false

System.out.println(!!(a > b)); //!!false = false

System.out.println(!!!(a > b)); //!!false = true

}

}

&&和&的区别? 同理||和|的区别?

/*&&和&的区别? 同理||和|的区别?

A:最终结果一样。

B:&&具有短路效果。左边是false，右边不执行。

开发中常用的逻辑运算符：

&&,||,!*/class OperatorDemo2 {

public staticvoidmain(String[] args) {int a = 3;int b = 4;int c = 5;//&&双与

System.out.println((a > b) && (a > c)); //false && false = false

System.out.println((a > b) && (a < c)); //false && true = false

System.out.println((a < b) && (a > c)); //true && false = false

System.out.println((a < b) && (a < c)); //true && true = true

System.out.println("----------------");int x = 3;int y = 4;//boolean b1 = ((x++ == 3) & (y++ == 4));

//boolean b1 = ((x++ == 3) && (y++ == 4));

//boolean b1 = ((++x == 3) & (y++ == 4));

boolean b1 = ((++x == 3) && (y++ == 4));

System.out.println("x:"+x);

System.out.println("y:"+y);

System.out.println(b1);

}

}

位运算

(5)位运算符(了解)

A:^的特殊用法

一个数据针对另一个数据位异或两次，该数不变

B:实例

a:请实现两个变量的交换**采用第三方变量**用位异或运算符

左边a,b,a

右边a^b

b:请用最有效率的方式计算出2乘以8的结果2<<3

位运算符：&,|,^,~ 解释

/*位运算符：

&,|,^,~

<>,>>>

注意：

要做位运算，首先要把数据转换为二进制。*/

classOperatorDemo {public static voidmain(String[] args) {//&,|,^,~

int a = 3;int b = 4;

System.out.println(3 & 4);//当&两边是数据，做的是位运算；当&两边是布尔值，做的是逻辑运算

System.out.println(3 | 4);

System.out.println(3 ^ 4);

System.out.println(~3);

}

}/*分析：因为是位运算，所以我们必须先把数据换算成二进制。

3的二进制：11

00000000 00000000 00000000 00000011

4的二进制：100

00000000 00000000 00000000 00000100

&位与运算：有0则0。

00000000 00000000 00000000 00000011

&00000000 00000000 00000000 00000100

-----------------------------------

00000000 00000000 00000000 00000000

结果是：0

|位或运算：有1则1。

00000000 00000000 00000000 00000011

|00000000 00000000 00000000 00000100

-----------------------------------

00000000 00000000 00000000 00000111

结果是：7

^位异或运算：相同则0，不同则1。

00000000 00000000 00000000 00000011

&00000000 00000000 00000000 00000100

-----------------------------------

00000000 00000000 00000000 00000111

结果是：7

~按位取反运算符：0变1，1变0，针对补码

在计算机内，有符号数有3种表示法：原码、反码和补码。所有数据的运算都是采用补码进行的。

原码：就是二进制定点表示法，即最高位为符号位，“0”表示正，“1”表示负，其余位表示数值的大小。

反码：

正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。

补码

正数的补码与其原码相同；负数的补码是在其反码的末位加1。

00000000 00000000 00000000 00000011 //正数的原码、反码、补码相同，这里代表3的补码

~11111111 11111111 11111111 11111100 (补码) ~3 按位对3的补码取反得到的

//下面通过补码，求得原码

补码：11111111 11111111 11111111 11111100

反码：11111111 11111111 11111111 11111011

原码：10000000 00000000 00000000 00000100

结果是：-4*/

^异或的特点：一个数据对另一个数据位异或两次，该数本身不变。

/*^的特点：一个数据对另一个数据位异或两次，该数本身不变。

比如b对a异或两次，a数本身不变。

可以用来简单加密*/

classOperatorDemo2 {public static voidmain(String[] args) {int a = 10;int b = 20;

System.out.println(a^ b ^ b); //10

System.out.println(a ^ b ^ a); //20

}

}

实现两个整数变量的交换：

/*实例：

实现两个整数变量的交换*/

classOperatorTest {public static voidmain(String[] args) {int a = 10;int b = 20;

System.out.println("a:"+a+",b:"+b);//方式1：使用第三方变量(开发中用的)

/*int c = a;

a = b;

b = c;

System.out.println("a:"+a+",b:"+b);

System.out.println("------------");*/

//方式2：用位异或实现(面试用)//左边：a,b,a//右边：a ^ b

/*a = a ^ b;

b = a ^ b; //a ^ b ^ b = a

a = a ^ b; //a ^ b ^ a = b

System.out.println("a:"+a+",b:"+b);*/

//方式3：用变量相加的做法

/*a = a + b; //a=30，先把和保存

b = a - b; //b=10，

a = a - b; //a=20

System.out.println("a:"+a+",b:"+b);*/

//方式4：一句话搞定

b = (a+b) - (a=b); //b=30-20=10,a=20//先把b赋值给a，然后用和减去a得到b

System.out.println("a:"+a+",b:"+b);

}

}

位移运算

/*<<:>

>>:右移 最高位是0，左边补齐0；最高为是1，左边补齐1

>>>:无符号右移 无论最高位是0还是1，左边补齐0

请用最有效率的方式写出计算2乘以8的结果?

2 * 8

2 << 3*/

classOperatorDemo3 {public static voidmain(String[] args) {//<< 把<

System.out.println(3 << 2); //3*2^2 = 3*4 = 12;//>> 把>>左边的数据除以2的移动次幂

System.out.println(24 >> 2); //24 / 2^2 = 24 / 4 = 6

System.out.println(24 >>> 2);

System.out.println(-24 >> 2);

System.out.println(-24 >>> 2);

}

}/*计算出3的二进制：11

00000000 00000000 00000000 00000011

(00)000000 00000000 00000000 0000001100

>>的移动：

计算出24的二进制：11000

-24原码：10000000 00000000 00000000 00011000

反码：11111111 11111111 11111111 11100111

补码：11111111 11111111 11111111 11101000

//>>:右移 最高位是0，左边补齐0；最高为是1，左边补齐1

11111111 11111111 11111111 11101000

1111111111 11111111 11111111 111010(00) 补码

//将补码转成原码

补码：1111111111 11111111 11111111 111010

反码：1111111111 11111111 11111111 111001

原码：1000000000 00000000 00000000 000110

结果：-6

>>>的移动：

计算出24的二进制：11000

原码：10000000 00000000 00000000 00011000

反码：11111111 11111111 11111111 11100111

补码：11111111 11111111 11111111 11101000

11111111 11111111 11111111 11101000

0011111111 11111111 11111111 111010(00)//这里原、反、补都相同

结果：*/

三目运算

/*单目运算符：~3

双目运算符：3 + 4

三目运算符：

格式：比较表达式?表达式1:表达式2;

比较表达式:结果是一个boolean类型。

执行流程：

根据比较表达式的计算返回一个true或者false。

如果是true，就把表达式1作为结果。

如果是false，就把表达式2作为结果。*/

classOperatorDemo {public static voidmain(String[] args) {int x = 100;int y = 200;int z = ((x > y)?x: y);//int z = ((x < y)? x: y);//int z = ((x == y)? x: y);//报错//int z = ((x = y)? x : y);//表达式是布尔类型，才能判断。这里把y赋值给x，而x是int类型

System.out.println("z:"+z);

}

}

获取最大值，判断值是否相等

/*练习：

获取两个整数中的最大值

获取三个整数中的最大值

比较两个整数是否相同*/

classOperatorTest {public static voidmain(String[] args) {//获取两个整数中的最大值

int x = 100;int y = 200;int max = (x > y?x: y);

System.out.println("max:"+max);

System.out.println("--------");//获取三个整数中的最大值

int a = 10;int b = 30;int c = 20;//分两步：//A:先比较a,b的最大值//B:拿a,b的最大值在和c进行比较

int temp = ((a > b)?a: b);//System.out.println(temp);

int max1 = (temp > c?temp: c);

System.out.println("max1:"+max1);//一步搞定//int max2 = (a > b)?((a > c)? a: c):((b > c)? b: c);//这种做法不推荐。//int max2 = a > b?a > c? a: c:b > c? b: c;//System.out.println("max2:"+max2);

System.out.println("--------");//比较两个整数是否相同

int m = 100;int n = 200;//boolean flag = (m == n)? true: false;

boolean flag = (m ==n);

System.out.println(flag);

}

}