java代码如何实现简单的加减乘除运算 java代码基础运算的编写教程-java教程-PHP中文网

java中整数和浮点数运算的异同点是：相同点为加、减、乘运算符在两类数据上行为一致，均遵循常规算术规则；不同点主要体现在除法和精度处理上，1. 整数除法会截断小数部分，结果为整数，而浮点数除法保留小数；2. 浮点数运算可能存在精度丢失，需用bigdecimal保证精确计算；3. 混合类型运算时整数会自动提升为浮点数，结果为浮点类型；4. 整数除以零抛出arithmeticexception，而浮点数除以零返回infinity或nan；5. 运算符优先级遵循乘除高于加减，括号可改变执行顺序，提升代码可读性与正确性。

java代码如何实现简单的加减乘除运算 java代码基础运算的编写教程

在Java中实现基础的加减乘除运算，核心在于使用其内置的算术运算符：加号（+）、减号（-）、乘号（*）和除号（/）。它们的工作方式直观，与我们日常数学习惯高度一致，只需掌握数据类型的一些小细节便能轻松驾驭，从而快速进行各种数值计算。

public class BasicOperations {

    public static void main(String[] args) {
        // 整数（int）运算示例
        int num1 = 20;
        int num2 = 7;

        int sum = num1 + num2;      // 加法
        int difference = num1 - num2; // 减法
        int product = num1 * num2;    // 乘法
        int quotient = num1 / num2;   // 除法 (注意：整数除法会截断小数部分)
        int remainder = num1 % num2;  // 取模 (获取除法的余数)

        System.out.println("--- 整数运算 ---");
        System.out.println(num1 + " + " + num2 + " = " + sum);          // 输出：20 + 7 = 27
        System.out.println(num1 + " - " + num2 + " = " + difference);   // 输出：20 - 7 = 13
        System.out.println(num1 + " * " + num2 + " = " + product);      // 输出：20 * 7 = 140
        System.out.println(num1 + " / " + num2 + " = " + quotient);     // 输出：20 / 7 = 2 (不是2.857...)
        System.out.println(num1 + " % " + num2 + " = " + remainder);    // 输出：20 % 7 = 6

        System.out.println("\n--- 浮点数（double）运算示例 ---");
        // 浮点数（double）运算示例
        double dNum1 = 20.0;
        double dNum2 = 7.0;

        double dSum = dNum1 + dNum2;
        double dDifference = dNum1 - dNum2;
        double dProduct = dNum1 * dNum2;
        double dQuotient = dNum1 / dNum2; // 浮点数除法会保留小数部分

        System.out.println(dNum1 + " + " + dNum2 + " = " + dSum);          // 输出：20.0 + 7.0 = 27.0
        System.out.println(dNum1 + " - " + dNum2 + " = " + dDifference);   // 输出：20.0 - 7.0 = 13.0
        System.out.println(dNum1 + " * " + dNum2 + " = " + dProduct);      // 输出：20.0 * 7.0 = 140.0
        System.out.println(dNum1 + " / " + dNum2 + " = " + dQuotient);     // 输出：20.0 / 7.0 = 2.857142857142857

        System.out.println("\n--- 混合类型运算示例 ---");
        // 混合类型运算：int 和 double 运算时，int 会自动提升为 double
        int mixedInt = 15;
        double mixedDouble = 4.0;
        double mixedResult = mixedInt / mixedDouble; // 15会被提升为15.0，结果为double
        System.out.println(mixedInt + " / " + mixedDouble + " = " + mixedResult); // 输出：15 / 4.0 = 3.75
    }
}

登录后复制

Java中整数和浮点数运算的异同点是什么？

说起Java里的数字运算，初学者往往容易踩坑，尤其是那个整数除法，它可不像我们想象中那样会给你个小数结果，而是直接“砍掉”小数部分。我记得我刚学那会儿，就因为这个愣是找了好久Bug，结果发现只是个数据类型的小把戏。

相同点： 基础的加（+）、减（-）、乘（*）运算符在整数（

int

登录后复制

long

登录后复制

short

登录后复制

byte

登录后复制

）和浮点数（

float

登录后复制

double

登录后复制

）上行为是基本一致的，它们都执行我们日常认知中的算术运算。比如

5 + 3

登录后复制

无论是整数还是浮点数，结果都是

登录后复制

或

8.0

登录后复制

。

不同点： 最大的差异体现在除法（/）上。

整数除法： 当两个整数相除时，Java会执行整数除法，结果依然是整数，小数部分会被直接截断（不是四舍五入）。例如，
```
10 / 3
```
登录后复制
的结果是
```
3
```
登录后复制
，而不是
```
3.33...
```
登录后复制
。如果你需要获取余数，可以使用取模运算符（%），例如
```
10 % 3
```
登录后复制
的结果是
```
1
```
登录后复制
。
浮点数除法： 当至少有一个操作数是浮点数时，Java会执行浮点数除法，结果会保留小数部分。例如，
```
10.0 / 3.0
```
登录后复制
或
```
10 / 3.0
```
登录后复制
的结果是
```
3.333...
```
登录后复制
。
精度问题： 浮点数运算（特别是
```
float
```
登录后复制
和
```
double
```
登录后复制
）可能会存在精度丢失问题。这是因为计算机内部表示浮点数的方式决定了它们无法精确表示所有的十进制小数，比如
```
0.1 + 0.2
```
登录后复制
可能不会精确等于
```
0.3
```
登录后复制
。对于需要高精度计算的场景，比如金融计算，通常会推荐使用
```
BigDecimal
```
登录后复制
类来避免这类问题。
类型提升： 当一个整数类型和一个浮点数类型进行运算时，Java会自动将整数类型“提升”为浮点数类型，然后再进行运算，最终结果是浮点数。比如
```
int result = 5 / 2.0;
```
登录后复制
会报错，因为
```
5 / 2.0
```
登录后复制
的结果是
```
2.5
```
登录后复制
（
```
double
```
登录后复制
类型），不能直接赋值给
```
int
```
登录后复制
。正确的做法是
```
double result = 5 / 2.0;
```
登录后复制
。这种隐式类型转换机制，很多时候能省去我们手动转换的麻烦，但也需要留意最终结果的数据类型。

运算优先级和括号在Java中如何影响计算结果？

编程这事儿，就像是给计算机的计算过程设定了“规矩”，谁先算谁后算，都有个说法。这也就是我们常说的“运算符优先级”。Java的算术运算符优先级和我们中学学的数学规则基本一致：乘法和除法的优先级高于加法和减法。

立即学习“Java免费学习笔记（深入）”；

运算符优先级：

高优先级： 乘法（
```
*
```
登录后复制
）、除法（
```
/
```
登录后复制
）、取模（
```
%
```
登录后复制
）
低优先级： 加法（
```
+
```
登录后复制
）、减法（
```
-
```
登录后复制
）

当表达式中包含多个不同优先级的运算符时，Java会先执行高优先级的运算，再执行低优先级的运算。如果优先级相同，则通常从左到右依次计算。

示例：

Fireflies.ai

自动化会议记录和笔记工具，可以帮助你的团队记录、转录、搜索和分析语音对话。

145

查看详情

```
int result = 10 + 2 * 3;
```
登录后复制
- 首先计算
```
2 * 3
```
  登录后复制
  得到
```
6
```
  登录后复制
  。
- 然后计算
```
10 + 6
```
  登录后复制
  得到
```
16
```
  登录后复制
  。

括号的作用： 括号

()

登录后复制

是改变运算优先级的“万能钥匙”。任何被括号括起来的表达式都会被优先计算，无论其中包含的运算符优先级高低。这就像是给计算任务划重点，告诉Java“这部分你得先搞定”。

示例：

```
int result = (10 + 2) * 3;
```
登录后复制
- 首先计算
```
(10 + 2)
```
  登录后复制
  得到
```
12
```
  登录后复制
  。
- 然后计算
```
12 * 3
```
  登录后复制
  得到
```
36
```
  登录后复制
  。

对比上面两个例子，你会发现结果截然不同，这充分说明了括号的重要性。说实话，最保险的办法，还是多用括号。虽然代码可能看起来多了几个字符，但可读性一下子就上去了，而且能有效避免很多潜在的逻辑错误，何乐而不为呢？尤其是在复杂的数学表达式中，括号能让你的意图一目了然，减少误解和错误。

如何处理Java运算中的常见错误和异常？

编程这事儿，出错是常态，尤其是涉及到数学运算，总有些意想不到的“坑”。比如那个除以零，整数世界里它会直接“爆炸”（抛异常），但在浮点数世界里，它就变得“佛系”多了，给你个无穷大或者“不是数”。这两种不同的处理方式，刚开始接触时确实挺让人费解的，但理解了背后的逻辑，就觉得Java设计者还是考虑得很周全的。

1. 整数除以零：

ArithmeticException

登录后复制

当你尝试将一个整数除以零时，Java会抛出一个运行时异常

java.lang.ArithmeticException: / by zero

登录后复制

。这是因为在数学上，整数除以零是无意义的。

try {
    int numerator = 10;
    int denominator = 0;
    int result = numerator / denominator; // 这里会抛出ArithmeticException
    System.out.println("结果: " + result);
} catch (ArithmeticException e) {
    System.err.println("错误：不能将整数除以零！" + e.getMessage());
}

登录后复制

为了避免程序崩溃，通常需要在使用除法前对除数进行检查，确保它不为零。

2. 浮点数除以零：

Infinity

登录后复制

和
NaN
登录后复制
与整数不同，浮点数（

float

登录后复制

或

double

登录后复制

）除以零并不会抛出异常。相反，它会产生特殊的结果：

正数除以零： 得到
```
Positive Infinity
```
登录后复制
(正无穷大)。
负数除以零： 得到
```
Negative Infinity
```
登录后复制
(负无穷大)。
零除以零，或无穷大除以无穷大等不确定形式： 得到
```
NaN
```
登录后复制
(Not a Number，不是一个数)。

double d1 = 10.0 / 0.0;  // Positive Infinity
double d2 = -10.0 / 0.0; // Negative Infinity
double d3 = 0.0 / 0.0;   // NaN

System.out.println("10.0 / 0.0 = " + d1);
System.out.println("-10.0 / 0.0 = " + d2);
System.out.println("0.0 / 0.0 = " + d3);

// 如何判断这些特殊值
System.out.println("d1 是无穷大吗？" + Double.isInfinite(d1)); // true
System.out.println("d3 是一个数吗？" + Double.isNaN(d3));     // true

登录后复制

这种设计让浮点数运算在遇到“不合法”的数学操作时，程序不会中断，而是继续执行，但你需要主动检查结果是否为

Infinity

登录后复制

或

NaN

登录后复制

，并根据业务逻辑进行处理。

3. 类型不匹配错误 这是编译时错误，通常发生在你尝试将一个不兼容的数据类型赋值给另一个变量，或者在运算中期望某种类型但实际是另一种。例如，尝试将

double

登录后复制

类型的结果直接赋值给

int

登录后复制

类型变量而不进行强制类型转换。

// int result = 10.0 / 3; // 编译错误：不兼容的类型，从double转换到int可能会有损失
int result = (int) (10.0 / 3); // 正确：强制转换为int，会截断小数
System.out.println("强制转换结果: " + result); // 输出 3

登录后复制

解决这类问题，要么确保参与运算的类型兼容，要么进行显式的类型转换（强制类型转换）。但强制转换要小心，它可能导致数据丢失（比如从