JAVA第二章学习完毕

7.2 赋值运算符

7.2.1 基本语法

符号：=

• • 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
  • 支持连续赋值。

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

	左边的值和右边的值进行相加操作，最后将结果赋值给左边的变量
	左边的值和右边的值进行相减操作，最后将结果赋值给左边的变量
	左边的值和右边的值进行相乘操作，最后将结果赋值给左边的变量
	左边的值和右边的值进行相除操作，最后将结果赋值给左边的变量
	左边的值和右边的值进行取余操作，最后将结果赋值给左边的变量

public class SetValueTest1 {
public static void main(String[] args) {
int i1 = 10;
long l1 = i1; //自动类型转换

byte bb1 = (byte)i1; //强制类型转换

int i2 = i1;

//连续赋值的测试
//以前的写法
int a1 = 10;
int b1 = 10;

//连续赋值的写法
int a2,b2;
a2 = b2 = 10;

int a3 = 10,b3 = 20;

//举例说明+=  -=  *=  /=   %=  
int m1 = 10;
m1 += 5; //类似于 m1 = m1 + 5的操作，但不等同于。
System.out.println(m1);//15

//练习1：开发中，如何实现一个变量+2的操作呢？
// += 的操作不会改变变量本身的数据类型。其他拓展的运算符也如此。
//写法1：推荐
short s1 = 10;
s1 += 2; //编译通过，因为在得到int类型的结果后，JVM自动完成一步强制类型转换，将int类型强转成short
System.out.println(s1);//12
//写法2：
short s2 = 10;
//s2 = s2 + 2;//编译报错，因为将int类型的结果赋值给short类型的变量s时，可能损失精度
s2 = (short)(s2 + 2);
System.out.println(s2);


//练习2：开发中，如何实现一个变量+1的操作呢？
//写法1：推荐
int num1 = 10;
num1++;
System.out.println(num1);

//写法2：
int num2 = 10;
num2 += 1;
System.out.println(num2);

//写法3：
int num3 = 10;
num3 = num3 + 1;
System.out.println(num3);

}
}

7.2.2 练习

练习1：

short s = 3; 
s = s+2;  //① 编译报错
s += 2;   //② 正常执行

//①和②有什么区别？

练习2：

int i = 1;
i *= 0.1;
System.out.println(i);//0
i++;
System.out.println(i);//1

练习3：

int m = 2;
int n = 3;
n *= m++;  //n = n * m++;
System.out.println("m=" + m);//3
System.out.println("n=" + n);//6

练习4：

int n = 10;
n += (n++) + (++n);  //n = n + (n++) + (++n)
System.out.println(n);//32

练习5：你有几种办法实现变量值减1？变量值减2呢？

/**
 * @author 尚硅谷-宋红康
 * @create 16:55
 */
public class MinusTest {
    public static void main(String[] args) {
        //练习①：变量值减1
        short s = 10;
        //方式1：
        //s = (short)(s - 1);
        //方式2：推荐
        s--; //或者 --s
        //方式3：
        s -= 1;

        //练习②：变量值减2
        short s1 = 10;
        //方式1：
        //s1 = (short)(s1 - 2);
        //方式2：推荐
        s1 -= 2;
    }
}

7.3 比较(关系)运算符

• 比较运算符的结果都是boolean型，也就是要么是true，要么是false。
• > < >= <= ：只适用于基本数据类型（除boolean类型之外）

• != ：适用于基本数据类型和引用数据类型

• 比较运算符“==”不能误写成“=”

举例：

class CompareTest {
public static void main(String[] args) {
int i1 = 10;
int i2 = 20;

System.out.println(i1 == i2);//false
System.out.println(i1 != i2);//true
System.out.println(i1 >= i2);//false


int m = 10;
int n = 20;
System.out.println(m == n);//false
System.out.println(m = n);//20

boolean b1 = false;
boolean b2 = true;
System.out.println(b1 == b2);//false
System.out.println(b1 = b2);//true
}
}

思考：

boolean b1 = false;
//区分好==和=的区别。
if(b1 == true)  //if(b1 = true)
System.out.println("结果为真");
else
System.out.println("结果为假");

7.4 逻辑运算符

7.4.1 基本语法

逻辑运算符，操作的都是boolean类型的变量或常量，而且运算得结果也是boolean类型的值。

运算符说明：

• • & 和 &&：表示"且"关系，当符号左右两边布尔值都是true时，结果才能为true。否则，为false。
  • | 和 || ：表示"或"关系，当符号两边布尔值有一边为true时，结果为true。当两边都为false时，结果为false
  • ! ：表示"非"关系，当变量布尔值为true时，结果为false。当变量布尔值为false时，结果为true。
  • ^ ：当符号左右两边布尔值不同时，结果为true。当两边布尔值相同时，结果为false。
    • 理解：异或，追求的是“异”！

逻辑运算符用于连接布尔型表达式，在Java中不可以写成 3 < x < 6，应该写成x > 3 & x < 6 。

区分“&”和“&&”：

• • 相同点：如果符号左边是true，则二者都执行符号右边的操作
  • 不同点：& ： 如果符号左边是false,则继续执行符号右边的操作
•  && ：如果符号左边是false,则不再继续执行符号右边的操作
  • 建议：开发中，推荐使用 &&

区分“|”和“||”：

—   相同点：如果符号左边是false，则二者都执行符号右边的操作

—   不同点：| ： 如果符号左边是true，则继续执行符号右边的操作

•     || ：如果符号左边是true，则不再继续执行符号右边的操作

建议：开发中，推荐使用 ||

 代码举例：

public class LoginTest {
public static void main(String[] args) {
int a = 3;
int b = 4;
int c = 5;

// & 与，且；有false则false
System.out.println((a > b) & (a > c)); 
System.out.println((a > b) & (a < c)); 
System.out.println((a < b) & (a > c)); 
System.out.println((a < b) & (a < c)); 
System.out.println("===============");
// | 或；有true则true
System.out.println((a > b) | (a > c)); 
System.out.println((a > b) | (a < c)); 
System.out.println((a < b) | (a > c));
System.out.println((a < b) | (a < c));
System.out.println("===============");
// ^ 异或；相同为false，不同为true
System.out.println((a > b) ^ (a > c));
System.out.println((a > b) ^ (a < c)); 
System.out.println((a < b) ^ (a > c)); 
System.out.println((a < b) ^ (a < c)); 
System.out.println("===============");
// ! 非；非false则true，非true则false
System.out.println(!false);
System.out.println(!true);
        
        //&和&&的区别
        System.out.println((a > b) & (a++ > c)); 
        System.out.println("a = " + a);
        System.out.println((a > b) && (a++ > c)); 
        System.out.println("a = " + a);
        System.out.println((a == b) && (a++ > c)); 
        System.out.println("a = " + a);
        
        //|和||的区别
        System.out.println((a > b) | (a++ > c)); 
        System.out.println("a = " + a);
        System.out.println((a > b) || (a++ > c)); 
        System.out.println("a = " + a);
        System.out.println((a == b) || (a++ > c)); 
        System.out.println("a = " + a);
}
}

7.4.2 案例与练习

案例：

1. 定义类 CompareLogicExer
2. 定义 main方法
3. 定义一个int类型变量a,变量b,都赋值为20
4. 定义boolean类型变量bo1 , 判断++a 是否被3整除,并且a++ 是否被7整除,将结果赋值给bo1
5. 输出a的值,bo1的值
6. 定义boolean类型变量bo2 , 判断b++ 是否被3整除,并且++b 是否被7整除,将结果赋值给bo2
7. 输出b的值,bo2的值

public class CompareLogicExer {
    public static void main(String[] args){
        int a = 20;
        int b = 20;
        boolean bo1 = ((++a % 3) == 0) && ((a++ % 7) == 0);
        System.out.println("bo1的值：" + bo1);
        System.out.println("a的值：" + a);
        System.out.println("----------------------------");
        
        boolean bo2 = ((b++ % 3) == 0) && ((++b % 7) == 0); 
        System.out.println("bo2的值：" + bo2);
        System.out.println("b的值：" + b);
    }
}

练习1：区分 & 和 &&

int x = 1;
int y = 1;

if(x++ == 2 & ++y == 2){
x = 7;
}
System.out.println("x=" + x + ",y=" + y);

int x = 1,y = 1;

if(x++ == 2 && ++y == 2){
x =7;
}
System.out.println("x="+x+",y="+y);

练习2：区分 | 和 ||

int x = 1,y = 1;
if(x++==1 | ++y==1){
x =7;
}
System.out.println("x="+x+",y="+y);

int x = 1,y = 1;
if(x++==1 || ++y==1){
x =7;
}
System.out.println("x="+x+",y="+y);

练习3：程序输出

class  Test  {
public static void main (String []  args)  {
boolean x = true;
        boolean y = false;
        short z = 42;
        
        if ((z++ == 42) && (y = true)) {
            z++;
        }
        if ((x = false) || (++z == 45)) {
            z++;
        }
        System.out.println("z=" + z);
}
}

//结果为：//z= 46

7.5 位运算符（难点、非重点）

7.5.1 基本语法

位运算符的运算过程都是基于二进制的补码运算

（1）左移：<<

运算规则：在一定范围内，数据每向左移动一位，相当于原数据*2。（正数、负数都适用）

【注意】当左移的位数n超过该数据类型的总位数时，相当于左移（n-总位数）位

3<<4  类似于  3*2的4次幂 => 3*16 => 48

-3<<4  类似于  -3*2的4次幂 => -3*16 => -48

（2）右移：>>

运算规则：在一定范围内，数据每向右移动一位，相当于原数据/2。（正数、负数都适用）

【注意】如果不能整除，向下取整。

69>>4  类似于  69/2的4次 = 69/16 =4

-69>>4  类似于  -69/2的4次 = -69/16 = -5

（3）无符号右移：>>>

运算规则：往右移动后，左边空出来的位直接补0。（正数、负数都适用）

69>>>4  类似于  69/2的4次 = 69/16 =4

-69>>>4   结果：268435451

（4）按位与：&

运算规则：对应位都是1才为1，否则为0。

• 1 & 1 结果为1
• 1 & 0 结果为0
• 0 & 1 结果为0
• 0 & 0 结果为0

9 & 7 = 1

-9 & 7 = 7

（5）按位或：|

运算规则：对应位只要有1即为1，否则为0。

• 1 | 1 结果为1
• 1 | 0 结果为1
• 0 | 1 结果为1
• 0 & 0 结果为0

9 | 7  //结果： 15

-9 | 7 //结果： -9

（6）按位异或：^

运算规则：对应位一个为1一个为0，才为1，否则为0。

• 1 ^ 1 结果为0
• 1 ^ 0 结果为1
• 0 ^ 1 结果为1
• 0 ^ 0 结果为0

9 ^ 7  //结果为14

-9 ^ 7 //结果为-16

（7）按位取反：~

运算规则：对应位为1，则结果为0；对应位为0，则结果为1。

• ~0就是1
• ~1就是0

~9  //结果：-10

~-9  //结果：8

7.5.2 举例

举例1：

举例2：体会 m = k ^ n = (m ^ n) ^ n

7.5.3 案例

案例1：高效的方式计算2 * 8的值（经典面试题）

答案：2 << 3 、  8  << 1

案例2：如何交换两个int型变量的值？String呢？

/**
 * @author 尚硅谷-宋红康
 * @create 16:58
 */
public class BitExer {
    public static void main(String[] args) {
        int m = 10;
int n = 5;

System.out.println("m = " + m + ", n = " + n);

//（推荐）实现方式1：优点：容易理解，适用于不同数据类型    缺点：需要额外定义变量
//int temp = m;
//m = n;
//n = temp;

//实现方式2：优点：没有额外定义变量    缺点：可能超出int的范围；只能适用于数值类型
//m = m + n; //15 = 10 + 5
//n = m - n;//10 = 15 - 5
//m = m - n;//5 = 15 - 10

//实现方式3：优点：没有额外定义变量    缺点：不易理解；只能适用于数值类型
m = m ^ n; 
n = m ^ n; //(m ^ n) ^ n
m = m ^ n;

System.out.println("m = " + m + ", n = " + n);
    }
}