疯狂Java笔记:3.7 运算符

3.7 运算符

1. 算术运算符
2. 赋值运算符
3. 比较运算符
4. 逻辑运算符
5. 位运算符
6. 类型相关运算符

3.7.1 算术运算符

用于表示数据的运算、赋值、比较。

+：加法运算，连接字符串
-：减法运算,求负运算eg:a=-a；
*：乘法运算
/：除法运算
    两个操作数都是整数，则计算结果是整数[截断取整]，且除数不能是 0
    如果两个操作数至少有一个浮点数，则结果为浮点数，允许除数为0[自动转换成 0.0]，得到非数或±无穷大
%：求余运算
    结果不一定总是整数。
    规则同除法。
    X%0 ->NaN
    0/0.0 对任何非0求余结果都是 0/0.0
++/--:自增/减运算：
    单目运算符，只能操作一个操作数
    只能操作单个数值型的变量，不能操作常量、表达式、数值直接量
    i++:先运算，后自增
    ++i:先自增，后运算

其他乘方、开方等运算可借助 java.lang.Math类的丰富的静态方法来完成。

/**
 * 算术运算符、Math类测试
 */
public class MathTest{
    public static void main(String[] args) {
    //除法运算
        //1、两个操作数都是浮点数，结果是浮点数，允许除数为0或者0.0得到正负无穷大
        double a = 5.2,b = 3.1;
        double div = a / b;
        System.out.println(div+"\t"+"±5除以0.0的结果是:" + 5.0 / 0+"\t"+- 5 / 0.0);
        //2、两个操作数都是整数，结果也是整数，且除数不能为0
        int c=4,d=3;
        short div1=(short)(c/d);//编译出错，类型不匹配
        System.out.println(div1+"\t"+"-5除以0的结果是:"/* + -5/0*/);//抛出算术异常

    //求余运算
        double mod = a % b;
        //1、运算结果不一定总是整数，限制同除法运算。
        System.out.println(mod);
        //2、第二个操作数0.0，结果是非数NaN。
        System.out.println("0、±5对0.0求余的结果是:" + +0 % 0.0+"\t"+5 % 0.0+"\t"+ -5%0.0);
        //3、0或0.0对任意非0数求余得到0或0.0
        System.out.println("0对5.0求余的结果是:" + 0 % 5.0); // 输出0.0
        //抛出算术异常：java.lang.ArithmeticException: / by zero
        // System.out.println("-5对0求余的结果是:" + -5 % 0);

    //Math类测试
        double a1=3.2;
        double b1=Math.pow(a1,5);//求a1的五次方
        double c1=Math.sqrt(a1);//求a1的平方根
        double d1=Math.random();//赋给d伪随机数0~1
        double e1=Math.sin(1.57);//求sin函数值
        System.out.println(b1+"\t\t"+c1+"\t"+d1+"\t\t"+e1);    
    }
}

3.7.2 赋值运算符

• 用于为变量指定变量值
• 赋值运算符=从右向左计算，因此左边只能是变量
• 表达式是有值的

/**
 * 赋值运算符
 */
public class AssignTest{
    public static void main(String[] args) {
        // 1、将直接量赋值给变量
        String str="Java";
        // 2、将一个变量赋值给另一个变量
        String str2=str;
        // 3、将表达式的值赋值给变量
        String str3=str2="String";
        System.out.println(str+"\t"+str2+"\t"+str3);

        // 4、赋值表达式是有值的，例如表达式c=7的值为7，因此可以连续赋值    
        int a,b,c;
        a=b=c=7;
        System.out.println(a+"\t"+b+"\t"+c);

        // 5、扩展运算符――――性能更好，程序更加健壮，推荐使用
        byte a1=5;
        // a=a1+5;//5是int，a+5提升为int,赋值给byte，编译出错
        byte b1=5;
        b1+=5;//不会出错
        b1=2;
        System.out.println(a1+"\t"+b1);
        b1=a1;//证明b仍然是byte类型
    }
}

3.7.3 位运算符

/**
 * 位运算符
 */
public class BitTest{
    public static void main(String[] args) {
        // System.out.println(2.5&3.0);
        System.out.println(5&9);//按位与：两位同时为1返回1
        System.out.println(5|9);//按位或：只要有一位为1即可返回1
        System.out.println(~-5);//按位非：单目运算符，将操作数每个位取反，包括符号位
        System.out.println(5^9);//按位异或：两位相同时返回0，不同返回1
        System.out.println(5<<2);//左移运算符：左边截断，右边空出的位补0
        System.out.println(-5<<2);
        System.out.println(-5 >> 2);//右移运算符：左边补充符号位的值，右边截断
        System.out.println(-5 >>> 2);//无符号右移运算符：左边总是以0补充
    }
}

1. 低于int类型，自动转换为int类型后再移位
2. int类型，a>>b，当b>32时，系统用b对32求余后得到的结果为移位位数
3. long类型，同int，对64求余。eg:a>>1和a>>65是相同效果的
4. 左移相当于乘以2的n次方，右移相当于除以2的n次方
5. 移位运算不改变操作数本身，只是得到一个新的运算结果。

3.7.4 扩展后的赋值运算符

赋值运算符可与算术运算符、移位运算符结合。

示例：

i=i+j;-->i+=j;  
i=i%j;-->i%=j;

3.7.5 比较运算符

比较运算的结果是布尔值true|false
1. 基本类型变量、值不能和引用类型变量、值比较，
2. boolean变量、值不能和其他任意类型变量、值比较，
3. 两个引用类型之间没有父子继承关系，也不能比较
4. >、>=、<、<=：只支持左右两边操作数是数值类型
5. ==/!=：

• 两边都是数值类型，即使数据类型不同，值相等即返回true 例如：97==’a’
• 如果都是引用类型，只有当两个引用变量的类型相同或具有父子关系时才可以比较，且必须指向同一个对象才返回true。
• 支持boolean类型值的比较

/**
 * 比较运算符
 */
public class CompareTest{
    public static void main(String[] args) {
        System.out.println("5大于 4.0：" + (5 > 4.0));
        System.out.println("5和5.0相等：" + (5 == 5.0));
        System.out.println("97和'a'相等：" + (97 == 'a'));
        System.out.println("true和false相等：" + (true == false));
        CompareTest m1=new CompareTest();
        CompareTest m2=new CompareTest();
        CompareTest m3=m1;
        //同一个类三个实例的引用，可以比较
        System.out.println("m1和m2相等：" + (m1==m2));//引用对象不同false
        System.out.println("m1和m3相等：" + (m1==m3));//引用对象相同true
    }
}

3.7.6 逻辑运算符

用于操作两个布尔型的变量或常量

&&：短路与，前后操作数都是ture才返回true
&：不短路与，作用同&&，但不会短路[无论左边是否为false,右边仍然会执行]
||：短路或，前后操作数有一个true，就返回true
|：不短路或，作用与||相同，不会短路
!：非单目运算符,取相反值
^：异或，两个操作数不同时返回true，否则返回false

/**
 * 逻辑运算符
 */
public classs LogicTest{
    public static void main(String[] args) {
        // 直接对false求非运算，将返回true
        System.out.println(!false);
        // 5>3返回true，'6'转换为整数54，'6'>10返回true，求与后返回true
        System.out.println(5 > 3 && '6' > 10);
        // 4>=5返回false，'c'>'a'返回true。求或后返回true
        System.out.println(4 >= 5 || 'c' > 'a');
        // 4>=5返回false，'c'>'a'返回true。两个不同的操作数求异或返回true
        System.out.println(4 >= 5 ^ 'c' > 'a');

        // 定义变量a,b，并为两个变量赋值
        int a = 5;
        int b = 10;
        // 对a > 4和b++ > 10求或运算
        if (a > 4 | b++ > 10){
            // 输出a的值是5，b的值是11。
            System.out.println("a的值是:" + a + "，b的值是:" + b);
        }

        // 定义变量c,d，并为两个变量赋值
        int c = 5;
        int d = 10;
        // c > 4 || d++ > 10求或运算
        if (c > 4 || d++ > 10){
            // 输出c的值是5，d的值是10。
            System.out.println("c的值是:" + c + "，d的值是:" + d);
        }
    }
}

3.7.7 三目运算符

(isTrue)?true:false

不支持多个语句，可以嵌套[降低可读性，一般不超过两层]

/**
 * 三目运算符
 */
public class ThreeTest{
    public static void main(String[] args) {
        // 三目运算符
        // d=c？a：b       
        // c为true时d=a，反之d=b;
        // 示例：
        String str= 5>3 ? "5大于3" : "5不大于3";
        System.out.println(str);
        //三目运算符支持嵌套
        int a=11,b=12;
        System.out.println(
            a>b ? 
                "a大于b" : (a<b ? "a小于b" : "a等于b")
        );
    }
}

3.7.8 运算符的结合性和优先级

• 从左向右结合[单目运算符、赋值运算符、三目运算符相反]
• 乘法和加法的操作数可以互换位置不影响结果[具有结合性]
• 注意：
  
  • 一个表达式不能过于复杂，可分步完成
  • 不要过多依赖运算符的优先级来控制表达式执行顺序，造成代码可读性差，应使用()

运算符优先级从高到低：