疯狂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 运算符的结合性和优先级

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

运算符优先级从高到低：