2.2 变量与数据类型

变量和数据类型是程序设计的基础，变量用于存储数据，而数据类型则定义了数据的性质和可操作性。以下是对 Java 中变量和数据类型的详细介绍。

1. 变量

变量是程序中的存储单元，用于保存数据。每个变量都有一个名称和数据类型，变量的名称用于引用存储的数据，而数据类型决定了变量能够存储的数据种类。Java 中的变量分为以下几类：

1. 局部变量：在方法或代码块内部定义的，其作用范围仅限于其所在的方法或代码块。它们在使用前必须被初始化，因为局部变量没有默认值。
2. 实例变量：定义在类中但不在任何方法内部的变量，它们与类的每个实例关联，存储对象的状态。每个对象都有自己的实例变量副本，可以在类的任何方法中访问。
3. 类变量（静态变量）：使用 static 关键字定义，属于类本身而不是任何特定的对象。通过类名直接访问，不需要实例化类。

下面我将用一段代码来展示变量的具体使用说明。

public class VariableExample {

    // 类变量
    private static int classVar = 10;

    // 实例变量
    private int instanceVar;

    // 构造器
    public VariableExample(int value) {
        this.instanceVar = value;
    }

   public int getInstanceVar() {
        return instanceVar;
    }

    public void setInstanceVar(int value) {
        this.instanceVar = value;
    }
   

    public void showVariables() {
        // 局部变量
        int localVar = 5;
        System.out.println("Local Variable: " + localVar);
    }

    public static void main(String[] args) {
        //实例变量
        VariableExample example = new VariableExample(20);
        System.out.println("Instance Variable: " + example.getInstanceVar());
        //局部变量
        example.showVariables();
        //类变量
        System.out.println("Class Variable: " + VariableExample.classVar);
    }
}

• 类变量 classVar 被定义为 static，这意味着它是类级别的变量，所有的实例共享一个副本。
• 实例变量 instanceVar 是每个对象的独立副本，使用构造器进行初始化。
• 局部变量 localVar 在方法内定义，仅在 showVariables 方法中有效。

2.数据类型

Java 中的数据类型分为两大类：基本数据类型 和 引用数据类型。

2.1 基本数据类型

基本数据类型用于存储简单的值。Java 提供了 8 种基本数据类型，每种数据类型都有其对应的默认值。

基本数据类型

数据类型	大小	默认值	说明
byte	8 位	0	存储整数值，范围从 -128 到 127
short	16 位	0	存储整数值，范围从 -32,768 到 32,767
int	32 位	0	存储整数值，范围从 -2^31 到 2^31-1
long	64 位	0L	存储长整数值，范围从 -2^63 到 2^63-1
float	32 位	0.0f	存储单精度浮点数
double	64 位	0.0	存储双精度浮点数
char	16 位	'\u0000'	存储单个字符
boolean	1 位	false	存储真或假

• 在 Java 中，String 被设计为一个类而不是基本数据类型，主要是因为 String 类提供了丰富的操作字符串的功能，而这些功能超出了基本数据类型所能提供的范围。

2.2 引用数据类型

引用数据类型用于存储对象的引用，包括类、接口、数组等。与基本数据类型不同，引用数据类型存储的是对象的内存地址，而不是对象本身。以下是关于类和数组的详细讲解和示例代码。

public class Person {
    // 成员变量（属性）
    private String name;
    private int age;

    // 构造器
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 方法
    public void introduce() {
        System.out.println("My name is " + name + " and I am " + age + " years old.");
    }

    public static void main(String[] args) {
        // 创建 Person 类的对象
        Person person = new Person("Alice", 30);
        // 调用方法
        person.introduce();
    }
}

• Person 类包含两个成员变量：name 和 age，用于存储人的名字和年龄。
• 构造器 Person(String name, int age) 用于初始化对象时设置 name 和 age。
• introduce 方法打印人的名字和年龄。
• 在 main 方法中，我们创建了一个 Person 对象，并调用 introduce 方法显示信息。

public class ArrayExample {
    public static void main(String[] args) {
        // 创建一个整数数组
        int[] numbers = {1, 2, 3, 4, 5};
        
        // 遍历并打印数组中的元素
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("Element at index " + i + ": " + numbers[i]);
        }

        // 创建一个字符串数组
        String[] names = {"Alice", "Bob", "Charlie"};
        
        // 使用增强的for循环遍历并打印数组中的元素
        for (String name : names) {
            System.out.println("Name: " + name);
        }
    }
}

• int[] numbers 创建了一个包含整数的数组，并初始化为 {1, 2, 3, 4, 5}。
• for 循环遍历 numbers 数组的所有元素，并打印出每个元素的值及其索引。
• String[] names 创建了一个包含字符串的数组，并初始化为 {"Alice", "Bob", "Charlie"}。
• 使用增强的 for 循环遍历 names 数组的所有元素，并打印出每个名字。

2.3 基本数据类型之间的相互转换

在 Java 中，基本数据类型（primitive types）之间的转换涉及自动类型转换（隐式转换）和显式类型转换（强制转换）。下面是八种基本数据类型之间的相互转换方式：

• 自动类型转换（隐式转换）

自动类型转换发生在较小的数据类型被转换为较大的数据类型时，这种转换是安全的，不会导致数据丢失。自动转换遵循以下规则：

• `byte` -> `short` -> `int` -> `long` -> `float` -> `double`
• `char` -> `int` -> `long` -> `float` -> `double`

public class ConversionExample {
    public static void main(String[] args) {
        byte b = 10;
        int i = b;  // byte -> int (自动转换)
        long l = i; // int -> long (自动转换)
        float f = l; // long -> float (自动转换)
        double d = f; // float -> double (自动转换)
        
        System.out.println("Byte to Int: " + i);
        System.out.println("Int to Long: " + l);
        System.out.println("Long to Float: " + f);
        System.out.println("Float to Double: " + d);
    }
}

• 显式类型转换（强制转换）

显式类型转换（强制转换）发生在将较大的数据类型转换为较小的数据类型时，这种转换可能会导致数据丢失或精度丢失。转换需要使用强制转换运算符 `(type)`。

public class ExplicitConversionExample {
    public static void main(String[] args) {
        double d = 9.78;
        int i = (int) d;  // double -> int (强制转换，数据丢失)
        float f = (float) d; // double -> float (强制转换，精度丢失)
        char c = (char) i; // int -> char (强制转换，可能出现无效字符)
        
        System.out.println("Double to Int: " + i);
        System.out.println("Double to Float: " + f);
        System.out.println("Int to Char: " + c);
    }
}

• 类型转换规则

以下是每种基本数据类型及其转换规则的详细说明。

1. byte: 最小的整数类型，占用 8 位。可以自动转换为 short, int, long, float, 和 double。需要显式转换为 char、short、int、long、float 和 double 。

2. short: 占用 16 位，范围大于 byte。可以自动转换为 int, long, float, 和 double。需要显式转换为 byte, char, int, long, float 和 double 。

3. int: 占用 32 位，是 Java 中最常用的整数类型。可以自动转换为 long, float, 和 double。需要显式转换为 byte, short, char, long, float 和 double 。

4. long: 占用 64 位，范围大于 int。可以自动转换为 float 和 double。需要显式转换为 byte, short, char, int, float 和 double 。

5. float: 占用 32 位，表示浮点数。可以自动转换为 double。需要显式转换为 byte, short, char, int, long 和 double 。

6. double: 占用 64 位，表示双精度浮点数。可以自动转换为 byte, short, char, int, long, 和 float。

7. char: 占用 16 位，表示单个 Unicode 字符。可以自动转换为 int, long, float, 和 double。需要显式转换为 byte, short, int, long, float, 和 double 。

自动类型转换发生在较小的数据类型转换为较大的数据类型时，而显式类型转换需要通过强制转换运算符来实现，通常用于将较大的数据类型转换为较小的数据类型。在转换过程中，需要注意可能的数据丢失和精度丢失问题。

扩展阅读

Java Primitive Data Types