double 是 Java 中的一种基本数据类型，用于表示双精度、64 位浮点数，它通常用于需要存储小数值或非常大/非常小的数值的场景。

初始化 double 变量主要有以下几种方式：

声明时直接初始化 (最常用)

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

语法： double 变量名 = 初始值;

示例代码：

public class DoubleInitialization {
    public static void main(String[] args) {
        // 使用十进制小数初始化
        double price = 99.99;
        double pi = 3.14159;
        // 使用科学计数法初始化
        double veryLargeNumber = 1.23e10; // 等于 1.23 * 10^10
        double verySmallNumber = 5.67e-5; // 等于 5.67 * 10^-5
        System.out.println("Price: " + price);
        System.out.println("Pi: " + pi);
        System.out.println("Large Number: " + veryLargeNumber);
        System.out.println("Small Number: " + verySmallNumber);
    }
}

先声明，后初始化

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

语法：

double 变量名;
// ... 其他代码 ...
变量名 = 值;

示例代码：

public class DoubleInitializationLater {
    public static void main(String[] args) {
        // 1. 先声明变量
        double temperature;
        double distance;
        // 2. 在后续代码中赋值
        temperature = 36.6;
        distance = 42.195; // 马拉松距离
        System.out.println("Temperature: " + temperature + " °C");
        System.out.println("Distance: " + distance + " km");
    }
}

隐式类型转换（从 int 到 double）

Java 支持将 int（整数）类型的值自动转换为 double 类型，因为 double 的精度范围和表示能力完全覆盖了 int，在赋值时，Java 会自动在整数后面添加 .0。

示例代码：

public class ImplicitConversion {
    public static void main(String[] args) {
        int integerVar = 100;
        // 将 int 类型的 100 赋值给 double 变量
        // Java 自动将其转换为 100.0
        double doubleVar = integerVar;
        System.out.println("Integer value: " + integerVar); // 输出 100
        System.out.println("Double value: " + doubleVar);   // 输出 100.0
    }
}

显式类型转换（从其他数值类型）

如果你想把一个 float 或者一个 long 类型的值赋给 double，同样可以自动完成，但如果你想把一个 double 赋给一个 float 或 int，就需要进行显式类型转换（也称为“强制类型转换”），因为可能会丢失精度。

示例代码：

public class ExplicitConversion {
    public static void main(String[] args) {
        double doubleValue = 123.456;
        // 强制转换为 float (会丢失精度)
        float floatValue = (float) doubleValue;
        System.out.println("Double to Float: " + floatValue); // 输出 123.456
        // 强制转换为 int (小数部分会直接丢弃)
        int intValue = (int) doubleValue;
        System.out.println("Double to Int: " + intValue);     // 输出 123
    }
}

⚠️ 注意：显式转换会丢失数据，要谨慎使用。

使用 Double 包装类进行初始化

除了基本类型 double，Java 还提供了一个对应的包装类 java.lang.Double，包装类用于在需要对象的地方使用基本类型（例如在集合类 ArrayList, HashMap 中）。

语法：

Double 对象名 = new Double(值); // 构造方法 (已过时，不推荐)
Double 对象名 = 值;             // 自动装箱 (推荐)

示例代码：

public class DoubleWrapper {
    public static void main(String[] args) {
        // 1. 使用构造方法 (旧方式，不推荐)
        Double d1 = new Double(123.45);
        System.out.println("Using constructor: " + d1);
        // 2. 使用自动装箱 (现代 Java 推荐)
        // Java 会自动将 double 值 67.89 包装成 Double 对象
        Double d2 = 67.89;
        System.out.println("Using autoboxing: " + d2);
        // 3. 从 String 初始化 Double 对象
        Double d3 = Double.parseDouble("98.76");
        System.out.println("From String: " + d3);
    }
}

注意：从 Java 9 开始，Double 的构造方法已被标记为 @Deprecated（过时），推荐使用自动装箱的方式。

默认初始化

当一个 double 类型的成员变量（在类中定义，但在方法外）被声明但没有显式初始化时，Java 会自动为其赋予一个默认值。

默认值是 0。

示例代码：

public class DefaultInitialization {
    // 成员变量，没有显式初始化
    double uninitializedDouble;
    public static void main(String[] args) {
        DefaultInitialization obj = new DefaultInitialization();
        // 输出其默认值
        System.out.println("Default value of double: " + obj.uninitializedDouble); // 输出 0.0
    }
}

重要提示：这个规则只适用于类的成员变量，对于在方法内部声明的局部变量，Java 不会赋予默认值，如果你尝试使用一个未初始化的局部变量，编译器会报错。

错误示例：

public class LocalVariableError {
    public static void main(String[] args) {
        double myDouble; // 局部变量，未初始化
        // System.out.println(myDouble); // 编译错误！可能尚未初始化变量 myDouble
    }
}

总结表格

希望这份详细的解释能帮助你完全理解 Java 中 double 的初始化方式！