day04_java中的运算符

public class Demo {
    public static void main(String[] args) {
        //  + - * : 跟小学数学的运算方式一样
        System.out.println(10 + 20); // 30
        System.out.println(10 - 20); //-10
        System.out.println(10 * 20); // 200
		/*
			/ : 整数相除,结果只能得到整数,如果想要得到带有小数的结果,必须加入小数(浮点类型)的运算
		*/
        System.out.println(10 / 2);    // 5
        System.out.println(10 / 3);    // 3
        System.out.println(10 / 3.0);  // 3.3333333333333335

		/*
			%(取模) : 取余数 5 / 2 = 商2, 余数为1
		*/
        System.out.println(5 % 2);    // 1
    }

}

public class Demo {
    public static void main(String[] args) {
        // char类型参与算术运算，使用的是计算机底层对应的十进制数值。
        char c = 'a';
        System.out.println(c+ 1);//98

        // 两边都是数值
        System.out.println(1+2);// 3
        System.out.println(1+1.2); //2.2
        
    }
}

public class Demo {
    public static void main(String[] args) {
        int a = 5;
        //能算则算，不能算就拼接在一起。
        System.out.println("abc" + 'a'); // abca
        System.out.println("abc" + a); // abc5
        System.out.println(5 + a); // 10
        System.out.println("abc" + 5 + 'a'); //abc5a
        System.out.println(15 + "abc" + 15); //15abc15
        System.out.println(a + 'a');//102
        System.out.println(a + "" + 'a');//5a
        System.out.println(a + 'a' + "it ");//102it
        System.out.println("it" + a + 'a');//it5a
        System.out.println("it" + (a + 'a'));//102it
    }
}

• /?和?%?的区别：两个数据做除法，/取结果的商，%取结果的余数。
• 整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。

public class Demo04Test {
    public static void main(String[] args) {
        /*
			单独使用的时候， ++和-- 无论是放在变量的前边还是后边，结果是一样的
	    */
        int a = 10;
        ++a;   //等价于 a = a +1;
        System.out.println(a);        // 11

        int b = 10;
        --b;   //等价于 b = b -1;
        System.out.println(b);        // 9
    }

}

/*
		参与操作:
			++在前: 先对该变量做自增(++)或者自减(--)，然后再拿变量参与操作。
			++在后:	先将该变量原本的值，取出来参与操作，随后再进行自增(++)，自减(--)。
	*/
public class Demo05Test {
    public static void main(String[] args) {
        // ++在前: 先对该变量做自增(++)或者自减(--)，然后再拿变量参与操作。
        int a = 10;
        int b = ++a;
        System.out.println(a);		// 11
        System.out.println(b);		// 11


        // ++在后:	先将该变量原本的值，取出来参与操作，随后再进行自增(++)，自减(--)。
        a = 10;
        b = a++;

        System.out.println(a);	// 11
        System.out.println(b);  // 10
    }
}

基本赋值运算符?

/*
基本赋值运算符:	
		= : 将符号右侧的数据, 赋值给左边
*/
int a = 10; // 先看“=”右边，把数据10赋值给左边的变量a存储

扩展赋值运算符

实例

public class Demo06 {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;
        b += a;// 相当于 b = b + a ;
        System.out.println(a); // 3
        System.out.println(b); // 7

        short s = 3;
        // s = s + 4; 代码编译报错，因为将int类型的结果赋值给short类型的变量s时，可能损失精度
        s += 4; //  此行代码没有问题，隐含了强制类型转换，相当于 s = (short) (s + 3);
        System.out.println(s); // 7
    }
}

注意：扩展的赋值运算符隐含了强制类型转换

关系运算符

关系运算符是对数据进行条件判断的符号，最终会返回一个比较的布尔结果（false,true）

?实例

/*
   关系运算符(比较运算符) 都有哪些呢？
            >	>=   <   <=   ==    !=
*/
public class Demo{
    public static void main(String[] args) {
        int a = 3;
        int b = 4;

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

注意事项：

• 比较运算符，是两个数据之间进行比较的运算，运算结果一定是boolean值true或者false?
• 其中>,<,>=,<=不支持boolean，String类型，==和!=支持boolean和String。

逻辑运算符

实例

/*
    逻辑运算符作用: 用于[整合]多个比较表达式的条件

        1. 连接多个比较表达式
        2. 连接true或false
    最终得到的结果都是boolean类型的true或false.
*/
public class Demo {
    /*
      逻辑运算符分类 :
          &(与) : 并且, 遇false则false, 只有符号左右两边同时为true, 结果才为true.
          |(或) : 或者, 遇true则true,   只有符号左边两边同时为false, 结果才为false
          !(非) : 取反
          ^(异或) : 相同为false, 不同为true.
  */
    public static void main(String[] args) {
        // &(与) : 并且
        System.out.println(true & true);        // true
        System.out.println(false & false);        // false
        System.out.println(true & false);        // false
        System.out.println(false & true);        // false
        System.out.println("------------------");
        // |(或) : 或者
        System.out.println(true | true);        // true
        System.out.println(false | false);        // false
        System.out.println(true | false);        // true
        System.out.println(false | true);        // true
        System.out.println("------------------");
        // !(非) : 取反
        System.out.println(!true);                // false
        System.out.println(!!true);                // true
        System.out.println("------------------");
        // ^(异或) :
        System.out.println(true ^ true);        // false
        System.out.println(false ^ false);        // false
        System.out.println(true ^ false);        // true
        System.out.println(false ^ true);        // true
    }
}

短路逻辑运算符?

&&和&区别：

• &&和&结果一样，&&有短路效果，左边为false，右边不执行；&左边无论是什么，右边都会执行。

||和|区别：

• ||和|结果一样，||有短路效果，左边为true，右边不执行；|左边无论是什么，右边都会执行。?

实例

/*
在逻辑与运算中，只要有一个表达式的值为false，那么结果就可以判定为false了，
没有必要将所有表达式的值都计算出来，短路与操作就有这样的效果，可以提高效率。
同理在逻辑或运算中，一旦发现值为true，右边的表达式将不再参与运算。
*/
public class Demo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a > 100 && ++b > 10); // false
        System.out.println(b); // 20

        int i = 10;
        int j = 20;
        System.out.println(i > 2 || ++j > 10); // true

        System.out.println(j); // 20
    }
}

三元运算符

语法格式：

执行流程：

1. 首先计算关系表达式的值
2. 如果值为true， 取表达式1的值
3. 如果值为false，取表达式2的值?

实例

public class Demo {
    /*
	声明三个整型的变量,a,b,c,要求找出最大值
	*/
    public static void main(String[] args) {
        // 1. 定义三个变量用于保存和尚的身高
        int a = 150;
        int b = 210;
        int c = 165;

        // 2. 用三元运算符 , 比较前两个变量，获取较大值。
        int tempMax = a > b ? a : b;

        // 3. 用三元运算符 , 让较大值和第三个变量比较，获取最大值。
        int max = tempMax > c ? tempMax : c;

        // 4. 输出结果
        System.out.println(max); // 210

    }
}

位运算符（了解）

• 位运算符的运算过程都是基于补码运算，但是看结果，我们得换成原码，再换成十进制看结果
• 从二进制到十进制都是基于原码
• 正数的原码反码补码都一样，负数原码反码补码不一样
• byte,short,char在计算时按照int类型处理
• 如何区分&,|,^是逻辑运算符还是位运算符？ 如果操作数是boolean类型，就是逻辑运算符，如果操作数是整数，那么就位运算符

详解:

• 左移：<<? 左移几位就相当于乘以2的几次方
• 右移：>> 类似于除以2的n次，如果不能整除，向下取整
• 无符号右移：>>> 往右移动后，左边空出来的位直接补0，不看符号位
• 按位与：& 对应位都是1才为1
• 按位或：| 对应位只要有1即为1
• 按位异或：^ 对应位一个为1一个为0，才为1
• 按位取反：~0就是1 ~1就是0

运算符优先级

在表达式中，哪个运算符先执行后执行是要看优先级的，例如 “*、/” 的优先级高于”+、-” 。

实例

public class Demo {
    public static void main(String[] args) {
        // 目标：看看Java是否存在优先级，大家以后需要注意优先级问题
        System.out.println(10 > 3 || 10 > 3 && 10 < 3);  //true
        System.out.println( (10 > 3 || 10 > 3 ) && 10 < 3); // false
    }
}

tips?

• 表达式不要太复杂，如果不能确定优先级先算的使用小括号