初始化 double 变量主要有以下几种方式，并伴随着一些重要的注意事项。

声明时直接初始化

这是最常见、最直接的方式，在声明变量的同时，为其赋予一个初始值。

public class DoubleInitialization {
    public static void main(String[] args) {
        // 1. 使用小数直接初始化
        double price = 19.99;
        double pi = 3.141592653589793;
        // 2. 使用科学计数法初始化
        double massOfElectron = 9.10938356e-31; // e-31 表示乘以 10 的 -31 次方
        // 3. 使用整数初始化 (Java 会自动将 int 转换为 double)
        double integerAsDouble = 100;
        System.out.println("Price: " + price);
        System.out.println("Pi: " + pi);
        System.out.println("Mass of Electron: " + massOfElectron);
        System.out.println("Integer as Double: " + integerAsDouble);
    }
}

输出：

Price: 19.99
Pi: 3.141592653589793
Mass of Electron: 9.10938356E-31
Integer as Double: 100.0

先声明，后初始化

你可以先声明一个 double 变量，稍后在代码中为其赋值。

public class DeclareThenInitialize {
    public static void main(String[] args) {
        // 声明一个 double 变量，此时它没有默认值（局部变量必须显式初始化）
        double temperature;
        // 稍后为其赋值
        temperature = 36.6;
        System.out.println("Body temperature: " + temperature);
    }
}

重要提示：

• 局部变量：在方法或代码块内部声明的变量（如上面的 temperature），Java 不会为其分配默认值，如果你在使用它之前没有初始化，编译器会报错。

  public void someMethod() {
      double uninitializedVar; // 编译错误！
      System.out.println(uninitializedVar); // 错误：可能尚未初始化变量
  }

• 成员变量：在类内部、方法外部声明的变量（即类的字段），Java 会为其分配一个默认值，对于 double，默认值是 0。

  public class MyClass {
      double memberVar; // 默认初始化为 0.0
      public void printValue() {
          System.out.println("Member variable: " + memberVar); // 输出 0.0
      }
  }

通过表达式或方法调用初始化

变量的值可以来自一个计算表达式、另一个变量的赋值或一个方法的返回值。

public class ExpressionInitialization {
    public static void main(String[] args) {
        double a = 10.5;
        double b = 2.0;
        // 1. 通过算术表达式初始化
        double sum = a + b;       // 12.5
        double difference = a - b; // 8.5
        double product = a * b;    // 21.0
        double quotient = a / b;  // 5.25
        System.out.println("Sum: " + sum);
        System.out.println("Quotient: " + quotient);
        // 2. 通过另一个变量初始化
        double copyOfA = a; // copyOfA 的值现在是 10.5
        // 3. 通过方法调用初始化
        double randomValue = Math.random(); // Math.random() 返回一个 [0.0, 1.0) 范围内的 double 值
        System.out.println("Random value: " + randomValue);
    }
}

从字符串转换初始化

如果你有一个表示数字的字符串,可以使用 Double 包装类的静态方法 parseDouble() 或 valueOf() 来将其转换为 double 类型。

public class FromStringInitialization {
    public static void main(String[] args) {
        String strNumber = "123.456";
        String scientificStr = "5.2e10"; // 5.2 * 10^10
        // 使用 Double.parseDouble()
        double num1 = Double.parseDouble(strNumber);
        System.out.println("Parsed from string: " + num1);
        // 使用 Double.valueOf()
        double num2 = Double.valueOf(scientificStr);
        System.out.println("Parsed from scientific string: " + num2); // 输出 5.2E10
        // 如果字符串不是一个有效的数字格式，会抛出 NumberFormatException
        try {
            double invalidNum = Double.parseDouble("not a number");
        } catch (NumberFormatException e) {
            System.out.println("Error: Cannot parse 'not a number' to a double.");
        }
    }
}

⚠️ 重要注意事项

浮点数精度问题

这是使用 double (和 float) 时最需要注意的一点，计算机使用二进制（基数为2）来表示数字，而十进制小数（如0.1）在二进制中是无限循环的，因此无法被精确表示，这会导致微小的精度误差。

public class PrecisionIssue {
    public static void main(String[] args) {
        double a = 0.1;
        double b = 0.2;
        double sum = a + b;
        // 预期是 0.3，但实际输出是 0.30000000000000004
        System.out.println("a + b = " + sum); 
        // 不要使用 == 来比较两个 double 是否相等
        if (sum == 0.3) {
            System.out.println("Sum is exactly 0.3"); // 这行代码不会执行
        }
        // 正确的比较方式是判断它们的差值是否在一个很小的误差范围内
        if (Math.abs(sum - 0.3) < 1e-10) {
            System.out.println("Sum is approximately 0.3"); // 这行代码会执行
        }
    }
}

对于需要高精度计算的场景（如金融、货币计算），应避免使用 double 和 float，应该使用 java.math.BigDecimal 类。

double vs float

• double 是双精度，占用 64 位（8字节）。
• float 是单精度，占用 32 位（4字节）。
• double 提供的精度和范围大约是 float 的两倍，是 Java 中默认的浮点类型。
• 只有在内存极其紧张或对精度要求不高的特定情况下才考虑使用 float，使用 float 时，数值后面需要加上 f 或 F 后缀。

float f = 3.14f; // 必须加 f 后缀，否则 3.14 会被默认当作 double 处理，导致编译错误

double vs Double

• double：是基本数据类型，存储实际的数值，不是对象。

• Double：是 double 的包装类，它是一个对象，可以包含 double 值，还能提供一些有用的工具方法（如 parseDouble(), valueOf(), isNaN() 等）。

• 在 Java 5 之后，自动装箱（Autoboxing）机制使得你可以直接将 double 赋值给 Double 对象，反之亦然。

  double primitiveDouble = 10.5;
  Double wrapperDouble = primitiveDouble; // 自动装箱
  double backToPrimitive = wrapperDouble; // 自动拆箱

核心建议：

1. 除非有特殊需求（如节省内存），否则优先使用 double 而不是 float。
2. 永远不要使用 来精确比较两个 double 值是否相等，应使用误差范围判断。
3. 对于需要精确十进制计算的场景（如货币），请使用 BigDecimal。