java运算符

1.1 赋值运算符（=）

规则与要求

• 赋值运算符的左边只能写变量，不能写值、不能写表达式等。

• 赋值运算符右边的值的类型 必须 <= 左边变量的类型，否则就得强制类型转换

• 赋值运算符，只会把=右边的值给左边的变量，即为左边的变量赋值

public class AssignOperator1{//Assign赋值，委派，Operator运算符
    public static void main(String[] args){
        int a;
        a = 1; //左边a是int，右边1是int  int=int 可以
        //a = 1.0;//左边a是int，右边1.0是double  double>int 错误
        
        double d;
        d = 1;  //左边d是double，右边1是int  int<double OK
        
        byte b = 1;
        //如果=右边是常量值，那么只要常量值在byte范围内，这个常量值就是byte类型  byte=byte正确
        //byte b2 = 200; 
        //当=右边是常量值，如果常量值超过byte范围，那么整数常量值就是int类型  int>byte 错误
        
        int num = 1;
        //byte b3 = num;//num明确是int类型，int>byte  错误
        
        int x = 1;
        int y = 2;
        x = y;//把y的值放到x中，为x重新赋值
        System.out.println(x);//2
        System.out.println(y);//2
    }
}

练习题：交换两个变量的值

public class AssignOperator2{//Assign赋值，委派，Operator运算符
    public static void main(String[] args){
        int a = 1;
        int b = 2;
        
        //解决方法：通用方法
        //借助第三个同类型的变量
        int temp = a;
        a = b;
        b = temp;
        
        System.out.println("a=" + a);//a=2
        System.out.println("b=" + b);//b=1
    }
}

1.2 比较运算符

比较运算符又称为关系运算符，用于判断两个值的大小关系。

大于：>
小于：<
大于等于：>=
小于等于：<=
等于：==       注意区分单=与双==的差别
不等于：!=

所有比较运算符的计算==结果都是true 或 false==。通常比较表达式都是作为条件判断用的。

public class CompareOperator{//Compare比较，Operator运算符
    public static void main(String[] args){
        System.out.println(5 > 3);//true
        
        int a = 1;
        int b = 2;
        System.out.println(a + b == 3);//判断a+b的结果与3是否相等
        //System.out.println(a + b = 3);//报错，=表示赋值，左边必须是1个变量，不能是表达式
        System.out.println(a);//1
        System.out.println(b);//2
        
        System.out.println(a + b != 3);//false
        System.out.println(a + b >= 3);//true  a+b的结果满足大于或等于3吗
        
        boolean result = a + b == 3;
        /*
        先计算（1）a+b（2）用a+b的结果与3做比较（3）把比较的结果放到result中
        从这里也能看出 +（算术运算符）的优先级 > 比较运算符 > 赋值运算符
        */
        System.out.println(result);//true
    }
}

1.3 算术运算符

1.3.1 规则说明

加：+
    （1）如果+左右两边都是基本数据类型（boolean除外），是求和运算
    （2）如果+左右两边有一个是字符串（String，"xxx"），就是拼接，结果也是字符串
减：-
乘：*
除：/
    被除数/除数
    整数/整数，结果仍然是整数
    整数/整数时，除数为0会报错
    小数/小数，除数为0结果是Infinity，无穷
取模或取余：%
    被除数 % 除数 得到余数，余数的正负号与被除数相同
    整数 % 整数，除数为0会报错
    小数 % 小数，除数为0结果是NaN，非数字
​

自增：++
    自增变量自己+1
自减：--
    自增变量自己-1
    
    要求：++和--必须是变量才能使用，不能是常量值，或表达式自增或自减。
    以自增为例，
    （1）当自增表达式是独立的语句时，++在前在后都一样
    （2）当自增表达式不是独立的语句，和其他运算符一起，
        ++在前，表示先自增1，再取自增变量的值做运算
        ++在后，先取自增变量的值放一边，然后自增变量加1，然后用之前取出来的值做其他运算

1.3.2 运算演示

案例一

public class ArithmeticOperator1{//Arithmetic算术，计算，Operator运算符
    public static void main(String[] args){
        int x = 1;
        int y = 2;
        int result = x / y;
        System.out.println(result);//0   int/int结果仍然是int
        
        y = 0;
        //result = x / y;
        //编译正常，符号Java语法，但是不符合计算的逻辑
        //运行时发生了java.lang.ArithmeticException: / by zero
        
        double a = 1.0;
        double b = 0.0;
        double c = a/b;//Infinity，无穷，无限
        System.out.println(c);
    }
}

案例二

public class ArithmeticOperator2{//Arithmetic算术，计算，Operator运算符
    public static void main(String[] args){
        System.out.println(5 % 2);//5模2，或者5除以2的余数，结果是1
        System.out.println(-5 % 2);//-1  
        System.out.println(-5 % -2);//-1
        System.out.println(5 % -2);//1
        //余数的正负号与被除数相同
        //被除数 ÷ 除数 = 商 ... 余数
        //被除数 = 除数 * 商 + 余数
        
        System.out.println("===========");
        //System.out.println(5 % 0);//报错java.lang.ArithmeticException: / by zero
        System.out.println(5.0 % 0.0);//NaN，Not a Number，不是一个数字
    }
}

案例三

public class ArithmeticOperator3{//Arithmetic算术，计算，Operator运算符
    public static void main(String[] args){
        System.out.println(1 + 'a' + 5.6);//求和  103.6
        System.out.println(1 + "a" + 5.6);//拼接  1a5.6
        
        System.out.println("==================");
        System.out.println('a' + 'b' + "c");//195c
        /*
        从左往右算
        'a' + 'b'  char+char，编码值相加  97+98=195
        195 + "c"  int + String字符串，拼接  195c
        */
        System.out.println("a" + 'b' + 'c');//abc
        /*
        从左往右算
        "a" + 'b'  String+char，拼接  "ab"
        "ab" + 'c'  String + char  拼接  "abc"
        */
        System.out.println('a' + "b" + 'c');//abc
        /*
        从左往右算
        'a' + "b"  char+String  拼接"ab"
        "ab" + 'c'  String + char  拼接  "abc"
        */
    }
}

案例四

public class ArithmeticOperator4{//Arithmetic算术，计算，Operator运算符
    public static void main(String[] args){
        int a = 1;
        a++;
        //1++;//错误
        int b = 2;
        //(a + b)++;//错误
    }
}

案例五

public class ArithmeticOperator5{//Arithmetic算术，计算，Operator运算符
    public static void main(String[] args){
        int a = 1;
        a++;//a变量自增1
        System.out.println(a);//2
        ++a;//a变量再次自增1
        System.out.println(a);//3
    }
}

案例六

public class ArithmeticOperator6{//Arithmetic算术，计算，Operator运算符
    public static void main(String[] args){
        int a = 1;
        System.out.println(a++);//输出结果是1
        /*
        (1)先取a的值放一边，取出来的是1
        (2)紧接着a自增1，a=2
        (3)输出刚刚取出来的值1
        */
        System.out.println(a);//a=2
        
        System.out.println("===========");
        int x = 1;
        int y = x++;
        /*
        (1)先取x的值放一边，取出来的是1
        (2)紧接着x自增1，x=2
        (3)把刚刚取出来的值1赋值给y
        */
        System.out.println(x);//x=2
        System.out.println(y);//y=1
        
        System.out.println("===========");
        int i = 1;
        i = i++;
        /*
        (1)先取i的值放一边，取出来的是1
        (2)紧接着i自增1，i=2
        (3)把刚刚取出来的值1赋值给i，刚刚的2被覆盖了
        */
        System.out.println(i);
        
    }
}

案例七

public class ArithmeticOperator7{//Arithmetic算术，计算，Operator运算符
    public static void main(String[] args){
        int a = 1;
        System.out.println(++a);//输出结果是2
        /*
        (1)a先自增，a=2
        (2)然后取a的值，2
        (3)输出刚刚取出来的值2
        */
        System.out.println(a);//a=2
        
        System.out.println("===========");
        int x = 1;
        int y = ++x;
        /*
        (1)先对x自增，x=2
        (2)取x的值2
        (3)把刚刚取出来的值2赋值给y
        */
        System.out.println(x);//x=2
        System.out.println(y);//y=2
        
        System.out.println("===========");
        int i = 1;
        i = ++i;
        /*
        (1)先对i自增，i=2
        (2)取i的值2,
        (3)把刚刚取出来的值2赋值给i
        */
        System.out.println(i);//2
        
    }
}