5.1 算术运算符

算术运算符的概念

算术运算符用于执行基本的算术运算，如加、减、乘、除等。Java 提供了多种算术运算符，用于处理数值类型的数据。

算术运算符列表

运算符	名称	描述	示例
+	加法	两个数相加	a + b
-	减法	从第一个数中减去第二个数	a - b
*	乘法	两个数相乘	a * b
/	除法	第一个数除以第二个数	a / b
%	取模	第一个数除以第二个数的余数	a % b
++	自增	变量的值加 1	a++ 或 ++a
--	自减	变量的值减 1	a-- 或 --a

算术运算符的使用

基本算术运算符

public class ArithmeticOperatorsExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 3;
        
        // 加法
        int sum = a + b;
        System.out.println("a + b = " + sum); // 输出 13
        
        // 减法
        int difference = a - b;
        System.out.println("a - b = " + difference); // 输出 7
        
        // 乘法
        int product = a * b;
        System.out.println("a * b = " + product); // 输出 30
        
        // 除法
        int quotient = a / b;
        System.out.println("a / b = " + quotient); // 输出 3（整数除法，小数部分被截断）
        
        // 取模
        int remainder = a % b;
        System.out.println("a % b = " + remainder); // 输出 1
        
        // 浮点数除法
        double c = 10.0;
        double d = 3.0;
        double floatQuotient = c / d;
        System.out.println("c / d = " + floatQuotient); // 输出 3.3333333333333335
    }
}

自增和自减运算符

自增和自减运算符有两种形式：前缀形式和后缀形式。

前缀形式

• ++a：先增加变量的值，然后使用增加后的值
• --a：先减少变量的值，然后使用减少后的值

后缀形式

• a++：先使用变量的当前值，然后增加变量的值
• a--：先使用变量的当前值，然后减少变量的值

public class IncrementDecrementExample {
    public static void main(String[] args) {
        int a = 5;
        int b = 5;
        
        // 前缀自增
        System.out.println("Prefix increment: " + ++a); // 输出 6，先增加后使用
        System.out.println("a after prefix increment: " + a); // 输出 6
        
        // 后缀自增
        System.out.println("Postfix increment: " + b++); // 输出 5，先使用后增加
        System.out.println("b after postfix increment: " + b); // 输出 6
        
        int c = 5;
        int d = 5;
        
        // 前缀自减
        System.out.println("Prefix decrement: " + --c); // 输出 4，先减少后使用
        System.out.println("c after prefix decrement: " + c); // 输出 4
        
        // 后缀自减
        System.out.println("Postfix decrement: " + d--); // 输出 5，先使用后减少
        System.out.println("d after postfix decrement: " + d); // 输出 4
    }
}

算术运算符的优先级

算术运算符的优先级从高到低依次为：

1. 括号 ()
2. 自增 ++、自减 --（作为前缀）
3. 乘法 *、除法 /、取模 %
4. 加法 +、减法 -
5. 自增 ++、自减 --（作为后缀）

示例

public class OperatorPrecedenceExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;
        int c = 3;
        
        // 乘法优先于加法
        int result1 = a + b * c; // 先计算 b * c，再加上 a
        System.out.println("a + b * c = " + result1); // 输出 25
        
        // 使用括号改变优先级
        int result2 = (a + b) * c; // 先计算 a + b，再乘以 c
        System.out.println("(a + b) * c = " + result2); // 输出 45
        
        // 混合运算
        int result3 = a * b + c / 2; // 先计算 a * b 和 c / 2，再相加
        System.out.println("a * b + c / 2 = " + result3); // 输出 51
    }
}

算术运算的注意事项

1. 整数除法

• 两个整数相除，结果仍然是整数，小数部分会被截断
• 例如：5 / 2 = 2，而不是 2.5

2. 浮点数精度

• 浮点数运算可能会有精度误差
• 例如：0.1 + 0.2 的结果可能不是 0.3，而是 0.30000000000000004

3. 除数不能为零

• 除数为零会导致运行时错误：ArithmeticException
• 例如：int a = 10 / 0; 会抛出异常

4. 自增自减运算符的使用

• 自增自减运算符只能用于变量，不能用于常量
• 例如：5++ 是错误的

示例：算术运算符的应用

public class ArithmeticApplication {
    public static void main(String[] args) {
        // 计算圆的面积
        double radius = 5.0;
        double pi = 3.14159;
        double area = pi * radius * radius;
        System.out.println("Area of circle: " + area);
        
        // 计算矩形的周长
        int length = 10;
        int width = 5;
        int perimeter = 2 * (length + width);
        System.out.println("Perimeter of rectangle: " + perimeter);
        
        // 计算平均数
        int num1 = 85;
        int num2 = 90;
        int num3 = 95;
        double average = (num1 + num2 + num3) / 3.0;
        System.out.println("Average: " + average);
        
        // 使用自增运算符
        int count = 0;
        System.out.println("Initial count: " + count);
        count++;
        System.out.println("After increment: " + count);
        ++count;
        System.out.println("After another increment: " + count);
    }
}

常见问题

1. 整数除法的小数部分被截断

症状：5 / 2 的结果是 2，而不是 2.5

解决方案：将其中一个操作数转换为浮点数，例如 5.0 / 2 或 5 / 2.0

2. 除数为零

症状：运行时错误：ArithmeticException: / by zero

解决方案：在进行除法运算前，检查除数是否为零

3. 浮点数精度误差

症状：0.1 + 0.2 的结果不是 0.3

解决方案：对于需要精确计算的场景，使用 BigDecimal 类

4. 自增自减运算符的优先级

症状：表达式 a++ + ++a 的结果可能不是预期的

解决方案：理解前缀和后缀形式的区别，避免在复杂表达式中使用自增自减运算符

总结

算术运算符是 Java 中用于执行基本算术运算的工具，包括：

• 基本算术运算符：+、-、*、/、%
• 自增自减运算符：++、--（前缀和后缀形式）

理解算术运算符的使用方法和优先级，对于编写正确的 Java 程序非常重要。在使用算术运算符时，需要注意整数除法、浮点数精度、除数为零等问题。