Java基础篇--变量类型

目录

前言:

Java 参数变量

Java 局部变量

成员变量（实例变量）

类变量（静态变量）

成员变量、局部变量、静态变量的区别

---

前言:

Java语言中支持的变量类型包括：

1. 局部变量（Local Variables）：局部变量是定义在方法、构造方法或语句块中的变量，其作用域仅限于当前方法、构造方法或语句块。局部变量在使用前需要声明，并且不能被访问修饰符修饰。

2. 成员变量（Instance Variables）：成员变量是定义在类中、方法之外的变量，其作用域为整个类，在类中的任何方法、构造方法和语句块中都可以访问。成员变量可以被访问修饰符修饰。

3. 静态变量（Class Variables）：静态变量是定义在类中、方法之外的变量，并且使用static关键字修饰，其作用域也为整个类。静态变量的值在程序运行期间只有一个副本，可以被类中的任何方法、构造方法和语句块访问。静态变量可以被访问修饰符修饰。

4. 参数变量（Parameters）：参数变量是在方法定义时声明的变量，它们作为调用该方法时传递给方法的值。参数变量的作用域仅限于方法内部。

以上是Java语言中常用的变量类型。通过合理地使用这些变量类型，我们可以在程序中存储和操作不同类型的数据。

实例 

public class VariableExample {
    public static void main(String[] args) {
        // 声明并初始化局部变量
        int localVar = 5;
        
        // 输出局部变量值
        System.out.println("局部变量: " + localVar);
        
        // 声明成员变量并赋值
        String instanceVar = "Hello";
        
        // 输出成员变量值
        System.out.println("成员变量: " + instanceVar);
        
        // 声明静态变量并赋值
        staticVar = 10;
        // 输出静态变量值
        System.out.println("静态变量: " + staticVar);
    }
    
    // 静态变量
    private static int staticVar;
}

运行该程序，将会输出如下结果： 

局部变量: 5 
成员变量: Hello 
静态变量: 10

Java 参数变量

参数变量是指在方法或构造函数中声明的变量，用于接收传递给方法或构造函数的值。参数变量与局部变量类似，但它们只在方法或构造函数被调用时存在，并且只能在方法或构造函数内部使用。

语法声明如下：

访问修饰符 返回类型 方法名(参数类型 参数名1, 参数类型 参数名2, ...) {
    // 方法体
}

其中，参数类型表示参数变量的类型，参数名表示参数变量的名称。在调用方法时，需要为参数变量传递相应的值。

Java 中的参数传递方式有两种：值传递和引用传递。

• 值传递：在方法调用时，传递的是实际参数的值的副本。当参数变量被赋予新的值时，只会修改副本的值，不会影响原始值。基本数据类型在方法调用时采用值传递方式。

• 引用传递：在方法调用时，传递的是实际参数的引用（内存地址）。当参数变量被赋予新的值时，会修改原始值的内容。对象类型在方法调用时采用引用传递方式。

实例

public class ParameterExample {

    // 定义一个方法，接收两个整数作为参数并返回它们的和
    public static int addNumbers(int num1, int num2) {
        int sum = num1 + num2;  // 将两个参数相加得到和
        return sum;  // 返回计算结果
    }
    
    public static void main(String[] args) {
        int a = 5;
        int b = 3;
        
        int result = addNumbers(a, b);  // 调用addNumbers方法，并传递a和b作为参数
        
        System.out.println("总和是：" + result);
    }
}

运行以上代码，输出如下：

总和是：8

Java 局部变量

局部变量在方法、构造方法或语句块中声明，并且它们在执行完成后会被销毁。

• 局部变量必须在使用前进行声明，不能被访问修饰符修饰，其作用域仅限于声明它的方法、代码块或构造函数。
• 局部变量只能在声明它的方法、构造方法或代码块内可见，不能被其他方法或代码块访问。
• 局部变量存储在栈内存中，而不是堆内存中。
• 局部变量没有默认值，必须在使用之前进行初始化。可以在声明时进行初始化，也可以在后续的代码中进行初始化。如果在声明时未初始化，变量将被赋予默认值（int 类型为0，boolean 类型为false，引用类型为null）。
• 当方法、构造方法或代码块执行完毕后，局部变量将被销毁，其占用的内存也会被释放。

局部变量的声明语法为：

变量的类型 变量的名称;

实例

public class LocalVariablesExample {
    public static void main(String[] args) {
        // 声明整型局部变量num，并初始化为10
        int num = 10;
        
        // 声明字符串类型的局部变量name，并未进行初始化
        String name;
        
        // 条件语句中使用局部变量num
        if (num > 5) {
            // 在条件成立的情况下，定义并初始化局部变量count
            int count = 20;
            System.out.println("Count: " + count);
        }   // count的作用域仅限于if代码块内部，出了该代码块就无法访问
        
        // 打印局部变量num
        System.out.println("Num: " + num);
        
        // 离开if代码块后，尝试打印局部变量count，
        // 但由于其作用域仅限于if代码块内，因此会出现编译错误
        // System.out.println("Count: " + count);
        
        // 初始化局部变量name
        name = "John";
        System.out.println("Name: " + name);
        
        // 在for循环中使用局部变量i
        for (int i = 0; i < 5; i++) {
            System.out.println("i: " + i);
        }   // i的作用域仅限于for循环内部，出了循环就无法访问
        
        // 尝试打印局部变量i，将会出现编译错误
        // System.out.println("i: " + i);
    }
}

以上实例编译运行结果如下:

Count: 20
Num: 10
Name: John
i: 0
i: 1
i: 2
i: 3
i: 4

成员变量（实例变量）

• 成员变量（实例变量）是在类中声明的变量，位于方法、构造方法和语句块之外。
• 当对象被实例化后，每个成员变量的值就确定下来了。
• 成员变量在对象创建时被创建，在对象销毁时被销毁。
• 成员变量的值应该至少被一个方法、构造方法或者语句块引用，以便外部可以通过这些方式获取实例变量的信息。
• 成员变量可以在使用前或使用后进行声明。
• 访问修饰符可以修饰成员变量。
• 成员变量对于类中的方法、构造方法或语句块是可见的。通常情况下，应将成员变量设为私有。通过使用访问修饰符，成员变量可以对子类可见。
• 成员变量具有默认值。数值类型变量的默认值是0，布尔类型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定。
• 成员变量可以直接通过变量名访问。但在静态方法和其他类中，应使用完全限定名：ObjectName.VariableName。

成员变量的声明语法为：

accessModifier type variableName;
accessModifier --表示访问修饰符，可以是 public、protected、private 或默认访问级别（即没有显式指定访问修饰符）。
type -- 表示变量的类型。
variableName -- 表示变量的名称。

与局部变量不同，成员变量的值在创建对象时被分配，即使没有进行初始化，它们也会被赋予默认值。例如，int类型的变量默认值为0，boolean类型的变量默认值为false。

成员变量可以通过对象或类名来访问（如果它们是静态成员变量）。如果没有进行显式初始化，它们将被赋予默认值。可以在构造函数或其他方法中对成员变量进行初始化，也可以通过对象或类名访问并设置它们的值。

实例 

public class MyClass {
    private int myVariable; // 私有整型成员变量

    public MyClass() {
        myVariable = 0; // 构造方法中将成员变量初始化为0
    }

    public void setMyVariable(int value) {
        myVariable = value; // 设置成员变量的值
    }

    public int getMyVariable() {
        return myVariable; // 获取成员变量的值
    }


// 示例用法：

    public static void main(String[] args) {
        MyClass myObject = new MyClass(); // 创建MyClass的对象

        myObject.setMyVariable(10); // 设置成员变量值为10

        int variableValue = myObject.getMyVariable(); // 获取成员变量的值

        System.out.println("成员变量的值是: " + variableValue);
    }
}

以上实例编译运行结果如下:

成员变量的值是: 10

类变量（静态变量）

类变量（静态变量）是在类中声明的变量，使用关键字static修饰。与实例变量不同，类变量属于整个类而不是某个特定对象。 以下是类变量的特点和用法：

1. 类变量在类加载时就被创建，并且在整个程序运行期间只有一个副本(唯一性)。
2. 类变量是通过类名直接访问的，无需创建类的实例。
3. 类变量通常用于表示与类相关的共享数据或状态，可以被所有该类的对象共享(共享性)。
4. 类变量的值可以在声明时指定，也可以在静态代码块中进行初始化。
5. 类变量的访问修饰符可以是public、protected、private或默认访问级别。
6. 类变量可以被类的所有方法访问，包括静态方法和非静态方法。
7. 类变量具有默认值，数值类型默认为0，boolean类型默认为false，引用类型默认为null。

实例 

public class MyClass {
    private static int classVariable; // 静态整型类变量

    public static void setClassVariable(int value) {
        classVariable = value; // 设置类变量的值
    }

    public static int getClassVariable() {
        return classVariable; // 获取类变量的值
    }


// 示例用法：

    public static void main(String[] args) {
        MyClass.setClassVariable(10); // 设置类变量的值为10

        int variableValue = MyClass.getClassVariable(); // 获取类变量的值

        System.out.println("类变量的值: " + variableValue);
    }
}

以上实例编译运行结果如下:

类变量的值: 10

成员变量、局部变量、静态变量的区别

	成员变量	局部变量	静态变量
定义位置	在类中,方法外	方法中,或者方法的形式参数	在类中,方法外
初始化值	有默认初始化值	无,先定义,赋值后才能使用	有默认初始化值
调用方式	对象调用	---	对象调用，类名调用
存储位置	堆中	栈中	方法区
生命周期	与对象共存亡	与方法共存亡	与类共存亡
别名	实例变量	---	类变量