外币兑换1. 问题背景与需求分析
这道经典的物理运动计算题考察的是对循环结构和变量控制的掌握程度。题目描述一个小球从100米高度自由落下，每次触地后会反弹到上一次高度的一半，如此反复。我们需要计算两个关键数据：
- 第10次落地时，小球总共经过了多少米？
- 第10次反弹后，小球能到达多高？
这类问题在实际开发中有着广泛的应用场景。比如游戏开发中的物理引擎模拟、金融计算中的复利问题、工程领域的振动分析等，都需要类似的递推计算能力。作为Java基础能力的考察点，它完美融合了循环控制、变量更新和数学计算三大核心要素。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 解题思路与算法设计
2.1 运动过程分析
让我们先拆解小球的运动轨迹：
- 初始下落：100米（总距离：100）
- 第一次反弹：上升50米，下落50米（新增距离：50+50=100）
- 第二次反弹：上升25米，下落25米（新增距离：25+25=50）
- 以此类推...
可以发现，从第二次开始，每次反弹带来的距离增量都是前一次的1/2。这是一个典型的等比数列问题。
2.2 数学建模
设初始高度h=100米，反弹次数n：
- 第n次反弹高度：h/(2^n)
- 总距离计算需注意：
- 第一次只有下落：100米
- 后续每次都有上升和下落：100 + 2*(50+25+12.5+...)
因此总距离公式为：
totalDistance = h + 2*(h/2 + h/4 + h/8 + ... + h/2^(n-1))
2.3 算法选择
对于这种有规律的变化过程，我们有三种实现思路：
- 使用for循环精确控制反弹次数
- 使用while循环配合计数器
- 使用递归实现（不推荐，因为存在栈溢出风险）
考虑到代码可读性和执行效率，我们选择for循环方案。以下是算法步骤：
- 初始化高度和总距离
- 进行10次循环（注意第一次下落单独处理）
- 每次循环更新高度和累计距离
- 循环结束后输出结果
3. Java实现详解
3.1 基础版本实现
java复制public class BallBounce {
public static void main(String[] args) {
double height = 100; // 初始高度
double totalDistance = 100; // 第一次下落距离
for (int i = 1; i < 10; i++) {
height /= 2; // 反弹高度减半
totalDistance += 2 * height; // 往返距离累加
}
System.out.println("第10次落地时，共经过：" + totalDistance + "米");
System.out.println("第10次反弹高度：" + (height / 2) + "米");
}
}
关键点说明：
- 使用double类型保证计算精度
- 循环从1开始到9（共9次），因为第一次下落已经单独处理
- 第10次反弹高度是循环结束后的height再除以2
3.2 优化版本实现
我们可以改进代码结构和输出格式：
java复制public class EnhancedBallBounce {
private static final int DROP_TIMES = 10;
private static final double INITIAL_HEIGHT = 100.0;
public static void main(String[] args) {
calculateBounce(DROP_TIMES, INITIAL_HEIGHT);
}
public static void calculateBounce(int times, double initialHeight) {
if (times <= 0) {
throw new IllegalArgumentException("落地次数必须大于0");
}
double currentHeight = initialHeight;
double totalDistance = initialHeight; // 第一次下落
System.out.printf("初始高度：%.2f米\n", initialHeight);
System.out.println("----------------------------------");
for (int i = 1; i < times; i++) {
currentHeight /= 2;
totalDistance += 2 * currentHeight;
System.out.printf("第%d次反弹高度：%.8f米\n", i, currentHeight);
System.out.printf("第%d次落地累计距离：%.4f米\n", i+1, totalDistance);
System.out.println("----------------------------------");
}
System.out.printf("[最终结果] 第%d次落地时：\n", times);
System.out.printf("• 共经过距离：%.4f米\n", totalDistance);
System.out.printf("• 下次反弹高度：%.8f米\n", currentHeight/2);
}
}
优化点包括：
- 使用常量定义初始参数
- 添加参数校验
- 格式化输出（保留4-8位小数）
- 显示每次反弹的中间结果
- 将核心逻辑封装为可复用方法
4. 执行结果分析
运行优化版本程序，输出如下：
code复制初始高度：100.00米
----------------------------------
第1次反弹高度：50.00000000米
第2次落地累计距离：200.0000米
----------------------------------
第2次反弹高度：25.00000000米
第3次落地累计距离：250.0000米
----------------------------------
...
第9次反弹高度：0.19531250米
第10次落地累计距离：299.6094米
----------------------------------
[最终结果] 第10次落地时：
• 共经过距离：299.6094米
• 下次反弹高度：0.09765625米
4.1 数学验证
我们可以用等比数列求和公式验证：
总和S = 100 + 2*(50+25+...+100/2^9)
= 100 + 250(1-0.5^9)/(1-0.5)
≈ 100 + 199.6094
= 299.6094米
与程序输出一致，验证了算法的正确性。
4.2 精度问题探讨
使用double类型计算时需要注意：
- 对于金融等精度要求高的场景，建议使用BigDecimal
- 本例中高度会越来越小，但不会真正变为0（理论上反弹无限次）
- 实际物理世界中，空气阻力和能量损耗会使小球最终停止
5. 常见问题与解决方案
5.1 循环次数错误
问题现象：总距离计算结果偏小
原因分析：
- 循环条件写成了i<=10（多循环一次）
- 初始距离没有单独处理，导致少算100米
正确做法：
java复制// 正确初始化
double totalDistance = initialHeight;
// 正确循环条件
for(int i=1; i<times; i++){...}
5.2 整数除法陷阱
问题现象：反弹高度计算错误（全是整数）
错误代码：
java复制int height = 100;
height = height / 2; // 每次都得到整数
解决方案：
- 使用double类型
- 或者强制类型转换：
java复制height = (double)height / 2;
5.3 输出精度控制
问题现象：输出结果有过多小数位或科学计数法
解决方案：
java复制// 使用printf格式化输出
System.out.printf("高度：%.4f米", height);
// 或者使用DecimalFormat
DecimalFormat df = new DecimalFormat("#.#####");
System.out.println(df.format(height));
6. 进阶思考与扩展
6.1 能量损耗模型
实际物理场景中，反弹高度不会精确为一半。我们可以引入能量损耗系数：
java复制double energyLoss = 0.1; // 10%能量损耗
for(int i=1; i<times; i++){
currentHeight *= (1 - energyLoss) / 2;
// 其余逻辑不变
}
6.2 可视化实现
使用JavaFX绘制小球运动轨迹：
java复制import javafx.animation.*;
import javafx.application.Application;
import javafx.scene.*;
import javafx.scene.shape.*;
import javafx.stage.Stage;
import javafx.util.Duration;
public class BounceVisualization extends Application {
private static final double INIT_HEIGHT = 200;
private static final int BOUNCE_COUNT = 10;
@Override
public void start(Stage stage) {
Circle ball = new Circle(10, javafx.scene.paint.Color.RED);
Group root = new Group(ball);
Scene scene = new Scene(root, 400, 400);
stage.setScene(scene);
stage.show();
animateBounce(ball, BOUNCE_COUNT);
}
private void animateBounce(Circle ball, int bounces) {
double startY = 0;
double height = INIT_HEIGHT;
SequentialTransition seq = new SequentialTransition();
for (int i = 0; i < bounces; i++) {
TranslateTransition fall = new TranslateTransition(
Duration.seconds(0.5), ball);
fall.setFromY(startY);
fall.setToY(height);
TranslateTransition rise = new TranslateTransition(
Duration.seconds(0.5), ball);
rise.setFromY(height);
rise.setToY(startY);
height /= 2;
seq.getChildren().addAll(fall, rise);
}
seq.play();
}
}
6.3 性能优化方向
对于大规模计算（如100万次反弹）：
- 使用公式计算替代循环
- 采用多线程分段计算
- 使用BigDecimal保证高精度
公式优化版本：
java复制public static double calculateTotalDistance(int times, double height) {
if (times == 1) return height;
return height * (3 - Math.pow(0.5, times-2));
}
7. 工程实践建议
- 参数化设计：将初始高度和反弹次数作为方法参数，提高代码复用性
- 单元测试：为核心计算方法编写JUnit测试用例
- 日志记录：在关键步骤添加日志，便于调试
- 异常处理：对非法参数（如负数高度）进行校验
- 文档注释：为公开方法添加规范的JavaDoc
示例测试用例：
java复制@Test
public void testCalculateBounce() {
assertEquals(100.0, calculateTotalDistance(1, 100), 0.001);
assertEquals(200.0, calculateTotalDistance(2, 100), 0.001);
assertEquals(299.609375, calculateTotalDistance(10, 100), 0.001);
}
8. 类似问题拓展
掌握这个问题的解法后，可以解决许多类似问题：
- 银行存款问题：每月固定利率，计算n年后的本息和
- 细菌繁殖问题：每天分裂一次，计算n天后的数量
- 猴子吃桃问题：每天吃一半加一个，求最初有多少桃
- 楼梯爬升问题：每次可以跨1或2阶，求有多少种走法
这些问题的共同特点是：当前状态与前一状态存在确定的数学关系，适合用循环结构解决。