菜鸟Java基础教程 5. Java 变量类型

Java 变量类型

1. 变量的声明_掌握格式

在 Java 语言中，所有的变量在使用前必须声明。

声明变量的基本格式如下：

type identifier [ = value][, identifier [= value] ...] ;

格式说明

这里是对格式的说明：

• type：数据类型，指定了变量可以存储的数据类型，例如 int、double、String 等。
• identifier：变量名，用来标识变量的名称，根据命名规则，必须是一个合法的标识符。
• value：可选项，表示变量的初始值，可以在声明时直接为变量赋值。
• 多个变量可以使用逗号 , 隔开，一次性声明多个同类型的变量。

以下列出了一些变量的声明实例。注意有些包含了初始化过程。

int a, b, c;         // 声明三个int型整数：a、 b、c
int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
byte z = 22;         // 声明并初始化 z
String s = "runoob";  // 声明并初始化字符串 s
double pi = 3.14159; // 声明了双精度浮点型变量 pi
char x = 'x';        // 声明变量 x 的值是字符 'x'。

这些例子展示了Java中变量的声明和初始化过程，每个变量都有不同的数据类型和初始值：

int a, b, c;         // 声明三个int型整数：a、b、c
int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
byte z = 22;         // 声明并初始化 z
String s = "runoob";  // 声明并初始化字符串 s
double pi = 3.14159; // 声明了双精度浮点型变量 pi
char x = 'x';        // 声明变量 x 的值是字符 'x'

解释每一行：

• int a, b, c;：声明了三个整数类型的变量a、b、c。
• int d = 3, e = 4, f = 5;：声明了三个整数类型的变量d、e、f，并分别初始化为3、4、5。
• byte z = 22;：声明了一个字节类型的变量z，并初始化为22。
• String s = "runoob";：声明了一个字符串类型的变量s，并初始化为"runoob"。
• double pi = 3.14159;：声明了一个双精度浮点类型的变量pi，并初始化为3.14159。
• char x = 'x';：声明了一个字符类型的变量x，并初始化为字符’x’。

2.支持的变量类型_熟练掌握何时使用

Java 语言支持的变量类型有：

1. 局部变量

• 局部变量（Local Variables）： 局部变量是在方法、构造函数或块内部声明的变量，它们在声明的方法、构造函数或块执行结束后被销毁，局部变量在声明时需要初始化，否则会导致编译错误。

public void exampleMethod() {       	 
    int localVar = 10; // 局部变量      
    // ...  
    }

这段代码演示了一个局部变量 localVar 的声明和初始化，它只在 exampleMethod 方法内部可见。

2. 实例变量

• 实例变量（Instance Variables）： 实例变量是在类中声明，但在方法、构造函数或块之外，它们属于类的实例，每个类的实例都有自己的副本，如果不明确初始化，实例变量会被赋予默认值（数值类型为0，boolean类型为false，对象引用类型为null）。

public class ExampleClass {
	int instanceVar; // 实例变量
	}
    

这个类中的 instanceVar 是一个实例变量，它属于类的实例，每个实例都有自己的副本。

3. 静态变量或类变量

• 静态变量或类变量（Class Variables）： 类变量是在类中用 static 关键字声明的变量，它们属于类而不是实例，所有该类的实例共享同一个类变量的值，类变量在类加载时被初始化，而且只初始化一次。

public class ExampleClass {
    static int classVar; // 类变量
    }

classVar 是一个静态变量或类变量，属于类而不是实例，所有该类的实例共享同一个类变量的值。

4. 参数变量

• 参数变量（Parameters）： 参数是方法或构造函数声明中的变量，用于接收调用该方法或构造函数时传递的值，参数变量的作用域只限于方法内部。**
  **

public void exampleMethod(int parameterVar) {
 // 参数变量
 // ...
 }

parameterVar 是一个参数变量，用于接收调用 exampleMethod 方法时传递的值，它的作用域只限于方法内部。

这些例子很好地说明了不同类型的变量在Java中的使用方式和特性。

---

5. 实例

以下实例中定义了一个 RunoobTest 类，其中包含了一个成员变量 instanceVar 和一个静态变量 staticVar。

method() 方法中定义了一个参数变量 paramVar 和一个局部变量 localVar。在方法内部，我们将局部变量的值赋给成员变量，将参数变量的值赋给静态变量，然后打印出这些变量的值。

在 main() 方法中，我们创建了一个 RunoobTest 对象，并调用了它的 method() 方法。—

代码实例

public class RunoobTest {
    // 成员变量
    private int instanceVar;
    
    // 静态变量
    private static int staticVar;
    
    //参数变量
    public void method(int paramVar) {
        // 局部变量
        int localVar = 10;
        
        // 使用变量
        instanceVar = localVar;//局部变量的值赋值给成员变量
        staticVar = paramVar;//参数变量的值付给
        
        System.out.println("成员变量: " + instanceVar);
        System.out.println("静态变量: " + staticVar);
        System.out.println("参数变量: " + paramVar);
        System.out.println("局部变量: " + localVar);
    }
    
    public static void main(String[] args) {
        RunoobTest v = new RunoobTest();
        v.method(20);
    }
}

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

成员变量: 10
静态变量: 20
参数变量: 20
局部变量: 10

这个示例演示了成员变量、静态变量、参数变量和局部变量之间的关系。

• 成员变量：类中定义的 instanceVar 是一个成员变量，它属于类的实例，并且每个类的实例都有自己的副本。

• 静态变量：类中定义的 staticVar 是一个静态变量，它属于类本身而不是类的实例，所有类的实例共享同一个副本。

• 参数变量：method 方法中的 paramVar 是一个参数变量，它用于接收方法调用时传递的参数值。

• 局部变量：method 方法中的 localVar 是一个局部变量，它在方法内部声明并且只在方法内部可见。

在 method 方法中，参数变量 paramVar 和局部变量 localVar 被使用来赋值给成员变量 instanceVar 和静态变量 staticVar，并且被打印出来。最后，在 main 方法中，创建了一个 RunoobTest 类的实例，并调用了 method 方法，并向其传递了参数值 20。

---

6.使用场景

理解何时使用不同类型的变量是编程中的关键部分。让我们来看看每种类型的变量适合的场景：

1. 局部变量：

   • 当你需要在一个方法、构造函数或者代码块中使用一个临时变量时，使用局部变量是合适的。这些变量仅在定义它们的地方可见，因此不会影响其他部分的代码。
   • 例如，在一个方法中需要进行一些临时计算或者保存一些临时状态时，可以使用局部变量。

2. 实例变量：

   • 当你需要在一个类的多个方法中共享数据时，使用实例变量是合适的。每个类的实例都有自己的实例变量副本，因此可以在不同的方法中访问和修改这些变量的值。
   • 例如，如果一个类需要维护一个对象的状态或属性，可以使用实例变量来表示这些属性。

3. 静态变量或类变量：

   • 当你需要在一个类的所有实例之间共享数据时，使用静态变量是合适的。静态变量属于类而不是实例，因此所有的实例共享同一个变量副本。
   • 例如，如果一个类需要跟踪某个值的全局状态，或者需要存储某个全局配置，可以使用静态变量。

4. 参数变量：

   • 当你需要向一个方法传递数据时，使用参数变量是合适的。参数变量允许你在方法调用时向方法传递数据，从而影响方法的行为。
   • 例如，如果一个方法需要执行某种操作，并且需要操作的数据可能会变化，可以将这些数据作为参数传递给方法。

了解每种类型变量的特性以及它们适合的场景，可以帮助你更好地设计和组织你的代码，使代码更加清晰和可维护。

7. 使用场景plus(脑袋空空)

我们可以使用一个简单的 switch 语句来模拟根据不同情况选择使用哪种类型的变量。让我们来创建一个示例：

//VariableChooser.java 
public class VariableChooser {
    public static void main(String[] args) {
        String situation = "calculate"; // 设置情况变量
        
        switch (situation) {
            case "temporary":
                // 情况1：临时计算
                int localVar = 10; // 使用局部变量
                System.out.println("临时计算结果：" + localVar);
                break;
            case "shared":
                // 情况2：共享数据
                VariablesExample instance1 = new VariablesExample(20); // 使用实例变量
                VariablesExample instance2 = new VariablesExample(30);
                System.out.println("实例1的值：" + instance1.instanceVar);
                System.out.println("实例2的值：" + instance2.instanceVar);
                break;
            case "global":
                // 情况3：全局数据
                VariablesExample.classVar = 40; // 使用类变量
                System.out.println("类变量的值：" + VariablesExample.classVar);
                break;
            case "operation":
                // 情况4：操作数据
                int parameterVar = 50; // 使用参数变量
                VariablesExample example = new VariablesExample(0);
                example.exampleMethod(0, parameterVar);
                break;
            default:
                System.out.println("无法识别的情况");
        }
    }
}

public class VariablesExample {
    // 实例变量
    int instanceVar;

    // 类变量
    static int classVar;

    // 构造方法，用于初始化实例变量
    public VariablesExample(int instanceVar) {
        this.instanceVar = instanceVar;
    }

    // 示例方法，演示局部变量和参数变量的使用
    public void exampleMethod(int localVar, int parameterVar) {
        // 输出局部变量和参数变量的值
        System.out.println("局部变量 localVar = " + localVar);
        System.out.println("参数变量 parameterVar = " + parameterVar);
    }
}

在这个示例中，我们根据不同的情况选择使用不同类型的变量：

• 如果情况是 "temporary"，则使用局部变量进行临时计算。
• 如果情况是 "shared"，则创建两个实例并使用实例变量共享数据。
• 如果情况是 "global"，则使用类变量来表示全局数据。
• 如果情况是 "operation"，则使用参数变量传递数据给方法。

这个 switch 语句演示了根据不同情况选择使用不同类型的变量的示例。

---

3. Java 参数变量_灵活运用

要掌握

• 什么是参数变量
• 声明语法
• 如何赋值

---

1. 参数变量的概念

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

---

详解：
当你定义一个方法或构造函数时，你可能需要向它传递一些数据，以便在方法内部使用这些数据执行特定的操作。这些数据是通过参数列表中的参数变量来传递的。让我们来详细看看参数变量的使用：

代码示例

public class ParameterVariablesExample {
//参数变量实例
    // 示例方法，接收一个整数参数和一个字符串参数
    public void myMethod(int parameter1, String parameter2) {
        // 方法体
        System.out.println("参数1的值为：" + parameter1);
        System.out.println("参数2的值为：" + parameter2);
    }

    // 主方法，用于演示参数变量的使用
    public static void main(String[] args) {
        ParameterVariablesExample example = new ParameterVariablesExample();

        // 调用示例方法并传递参数值
        example.myMethod(10, "Hello");

        // 尝试访问参数变量（这里会报错，因为参数变量仅在方法内部可见）
        // System.out.println(parameter1); // 编译错误：无法解析的符号
    }
}

也就是说参数变量调用的方法 中变量，只能在调用的方法里面可见，就像一个黑匣子
确实，可以把参数变量想象成一个黑匣子。当你调用一个方法时，你只需要知道你需要传递什么样的数据给这个方法，而不需要关心方法内部是如何处理这些数据的。参数变量就像是这个方法内部的工具，它们接收你传递的数据，并在方法内部使用这些数据执行相应的操作。你只需关心方法对外的接口（方法的参数和返回值），而不需要关心方法内部的具体实现细节。这种封装性和抽象性使得代码更易于理解和维护。

1. 在方法或构造函数中声明变量_即是参数变量：

参数变量是在方法或构造函数的参数列表中声明的变量。在声明方法时，你需要指定参数的类型和名称。

public void myMethod(int parameter1, String parameter2) {
    // 方法体
}

在这个例子中，parameter1 和 parameter2 就是方法 myMethod 的参数变量，分别代表一个整数类型和一个字符串类型的参数。

2. 接收传递给方法或构造函数的值：

当调用方法或创建对象时，你需要传递参数的值。这些值会被赋给方法或构造函数中对应的参数变量。

myMethod(10, "Hello");

在这个例子中，方法 myMethod 被调用，并传递了一个整数值 10 和一个字符串值 "Hello"。这些值会分别赋给 parameter1 和 parameter2 参数变量。

3. 只在方法或构造函数被调用时存在：

参数变量的作用域仅限于方法或构造函数内部。它们只在方法或构造函数被调用的时候存在，并且在方法或构造函数执行完毕后就会被销毁。

public void myMethod(int parameter) {
    // 参数变量 parameter 只在方法执行期间存在
    System.out.println("参数值为：" + parameter);
}

4. 只能在方法或构造函数内部使用：

参数变量只能在方法或构造函数内部使用。它们不能在方法或构造函数之外的其他地方访问或使用。

public void myMethod(int parameter) {
    // 参数变量 parameter 只能在方法内部使用
    int localVar = parameter * 2; // 使用参数变量进行计算
}

参数变量的使用使得方法或构造函数可以接受外部传入的数据，并在方法内部使用这些数据执行特定的操作。这种机制非常灵活，使得你可以编写更具有通用性和复用性的代码。

5.实例

好的，让我们创建一个包含方法和构造函数的类，并在其中演示参数变量的使用。我们将创建一个简单的 Person 类，其中包含一个构造函数和一个方法，用于显示人员的姓名和年龄。

public class Person {
    // 实例变量
    private String name;
    private int age;
    
    // 构造函数，接收姓名和年龄作为参数
    public Person(String name, int age) {
        // 使用参数变量初始化实例变量
        this.name = name;
        this.age = age;
    }
    
    // 方法，显示人员的姓名和年龄
    public void displayInfo() {
        // 在方法内部使用实例变量
        System.out.println("姓名：" + name);
        System.out.println("年龄：" + age);
    }
    
    public static void main(String[] args) {
        // 创建 Person 对象并传递参数
        Person person1 = new Person("Alice", 30);
        Person person2 = new Person("Bob", 25);
        
        // 调用方法显示人员信息
        person1.displayInfo();
        person2.displayInfo();
    }
}

在这个例子中，我们定义了一个 Person 类，其中包含了一个构造函数 Person(String name, int age) 和一个方法 displayInfo()。构造函数接收姓名和年龄作为参数，并使用参数变量来初始化实例变量 name 和 age。方法 displayInfo() 在方法内部使用实例变量来显示人员的姓名和年龄。

在 main 方法中，我们创建了两个 Person 对象，并分别传递了姓名和年龄作为参数。然后，我们调用 displayInfo() 方法显示每个人员的信息。

这个例子展示了参数变量如何在构造函数和方法中使用，用于接收传递给方法或构造函数的值，并在方法内部进行处理。

---

2. 声明语法

Java 方法的声明语法如下：

accessModifier returnType methodName(parameterType parameterName1, parameterType parameterName2, ...) {
    // 方法体
}

• parameterType – 表示参数变量的类型。
• parameterName – 表示参数变量的名称。

声明语法中的每个部分都有特定的含义：

1. accessModifier： 方法的访问修饰符，用于控制方法的访问级别。它可以是 public、protected、private 或默认访问修饰符（即没有明确指定的情况）。

2. returnType： 方法的返回类型，表示方法执行后返回的数据类型。如果方法不返回任何值，则返回类型为 void。如果方法返回某种数据类型的值，则返回类型应该是该数据类型的名称。

3. methodName： 方法的名称，用于标识方法。方法名应该符合标识符的命名规范，并且通常采用驼峰命名法（camelCase）。

4. parameterType： 参数变量的数据类型，表示传递给方法的参数的类型。参数类型可以是任何有效的数据类型，包括基本数据类型和引用数据类型。

5. parameterName： 参数变量的名称，用于在方法内部引用传递给方法的参数值。参数名应该符合标识符的命名规范，并且通常采用驼峰命名法。

在声明语法中，方法的返回类型、方法名和参数列表共同构成了方法的签名（signature）。方法的访问修饰符决定了方法是否可以被其他类或包访问。参数类型和参数名决定了方法接受的参数类型和参数名称。

---

声明和赋值

在Java中，参数和变量的赋值操作并不被称为声明。在Java中，声明指的是在代码中明确地告诉编译器某个变量的类型和名称，以便为其分配内存空间。 在Java中，变量的声明通常包括指定变量的类型和名称，例如：

int myVariable;

这里，myVariable 被声明为一个整数类型的变量。

赋值操作是将某个值存储到已经声明的变量中的过程。在Java中，赋值操作使用等号（=）来完成，例如：

myVariable = 10;

这里，将整数值 10 赋给了已经声明的 myVariable 变量。

Java中的方法参数也是变量，它们在方法声明中定义。
在方法声明中，参数被称为形式参数。(形参)
在调用方法时，传递给方法的值称为实际参数。(实参)
在方法内部，形式参数的值被初始化为传递给方法的实际参数的值。

public void myMethod(int parameter) {
    // 方法体
}

在上面的示例中，parameter 是 myMethod 方法的形式参数。当调用 myMethod 方法并传递一个整数值给它时，这个整数值会被赋值给 parameter。

---

3. 参数变量值传递方式

为什么要传递值

在Java中，参数变量用于传递值是基于方法调用的机制。底层的内存空间发生了以下几个步骤：

1. 方法调用：当一个方法被调用时，Java虚拟机（JVM）会创建一个新的栈帧（stack frame），用于存储方法的局部变量、参数、返回地址等信息。

2. 参数传递：在方法调用时，实际参数的值被传递给方法的参数变量。这个过程是通过将实际参数的值复制到栈帧中的参数变量的内存空间中来实现的。

3. 方法执行：在方法的执行过程中，可以在栈帧中访问和操作参数变量的值。方法可以使用这些参数变量的值来完成特定的操作。

4. 方法返回：当方法执行完毕后，它可能会返回一个值。返回值也存储在栈帧中，并被传递给调用方法的上一级调用者。

为什么不能直接调用呢？

直接调用意味着在方法内部直接访问调用者的变量，这样会引起一些问题：

• 封装性：直接访问调用者的变量会破坏封装性，使得方法的实现依赖于调用者的内部实现细节，从而增加了代码的耦合性。

• 可读性：直接访问调用者的变量可能会使代码变得难以理解和维护，因为方法内部的行为不再清晰可见。

• 安全性：直接访问调用者的变量可能会导致数据的不一致性和意外修改，从而降低代码的安全性和稳定性。

通过使用参数变量来传递值，可以避免上述问题，使方法的实现更加清晰、可靠和可维护。

---

值传递方式_值传递和引用传递

在调用方法时，我们必须为参数变量传递值，这些值可以是常量、变量或表达式。

方法参数变量的值传递方式有两种：值传递和引用传递。

值传递：

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

public class Example {
    public void valuePass(int num) {
        num = num * 2; // 修改参数变量的值
    }

    public static void main(String[] args) {
        Example example = new Example();
        int x = 10;
        example.valuePass(x); // 调用方法传递参数值
        System.out.println(x); // 输出结果仍然是 10，因为值传递只修改了副本
    }
}

在这个示例中，valuePass 方法接受一个参数变量 num，然后将其值乘以 2。在 main 方法中调用 valuePass 方法时，传递了变量 x 的值。尽管在方法内部修改了参数变量的值，但在 main 方法中输出 x 的值仍然是 10，这说明值传递只修改了参数变量的副本

---

Java 中的基本数据类型都采用值传递方式传递参数变量的值。为什么?

Java 中的基本数据类型采用值传递方式传递参数变量的值是因为基本数据类型的特性决定了它们的传递方式。

1. 存储方式简单：基本数据类型的值是直接存储在内存中的一块连续空间中，它们的大小是固定的，且不会改变。这使得它们的值可以直接被复制，并且在方法调用时作为参数传递。

2. 值的独立性：基本数据类型的值是独立的，每个变量都有自己的内存空间来存储其值。因此，对一个变量的值的修改不会影响到其他变量。

3. 性能优化：采用值传递方式可以避免不必要的内存管理和引用跟踪，从而提高程序的执行效率。因为基本数据类型的值是直接存储在栈上的，它们的传递不需要额外的内存分配和回收操作。

基于这些特性，Java 选择了值传递方式来传递基本数据类型的参数变量的值。这样做简化了语言的设计和实现，同时也提高了程序的执行效率和可靠性。

基本数据类型不使用引用传递的主要原因是基本数据类型的特性与引用传递方式不相符合。

1. 存储方式简单：基本数据类型的值是直接存储在内存中的一块连续空间中，它们的大小是固定的，且不会改变。与引用类型不同，基本数据类型的值不需要在堆内存中分配空间，并且不需要额外的内存管理。因此，采用引用传递对于基本数据类型来说是不必要的，且会增加额外的内存开销。

2. 值的独立性：基本数据类型的值是独立的，每个变量都有自己的内存空间来存储其值。采用引用传递可能会导致对同一个变量的修改影响到其他变量，这与基本数据类型的特性相违背。

3. 性能优化：基本数据类型的值传递方式可以避免不必要的内存管理和引用跟踪，从而提高程序的执行效率。采用引用传递方式会增加额外的内存分配和回收操作，降低程序的性能。

综上所述，基本数据类型不使用引用传递是为了符合其特性，简化语言设计和实现，并提高程序的执行效率和可靠性。基本数据类型的值传递方式更加适合于基本数据类型的特性和使用场景。

---

引用传递：

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

public class Example {
    public void referencePass(int[] arr) {
        arr[0] = arr[0] * 2; // 修改数组元素的值
    }

    public static void main(String[] args) {
        Example example = new Example();
        int[] arr = {10};
        example.referencePass(arr); // 调用方法传递参数值
        System.out.println(arr[0]); // 输出结果为 20，因为引用传递修改了原始值
    }
}

在这个示例中，referencePass 方法接受一个数组类型的参数变量 arr，然后将数组第一个元素的值乘以 2。在 main 方法中调用 referencePass 方法时，传递了数组 arr 的引用。在方法内部修改了数组元素的值后，main 方法中输出 arr[0] 的值为 20，这说明引用传递修改了原始值。

3 方法参数变量的使用

以下是一个简单的例子，展示了方法参数变量的使用：

实例

public class RunoobTest {  
    public static void main(String[] args) {  
        int a = 10, b = 20;  
        swap(a, b); // 调用swap方法  
        System.out.println("a = " + a + ", b = " + b); // 输出a和b的值  
    }  
     
    public static void swap(int x, int y) {  
        int temp = x;  
        x = y;  
        y = temp;  
    }  
}  

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

a = 10, b = 20

在这个示例中，swap 方法被调用以交换两个整数的值。然而，由于Java是按值传递的，所以 swap 方法中对参数变量的值的修改不会影响到 main 方法中的变量值。

具体来说，这是因为在方法调用时，swap 方法中的参数 x 和 y 会被初始化为 main 方法中的变量 a 和 b 的副本。当 swap 方法内部修改 x 和 y 的值时，实际上只是修改了副本的值，并不会影响到 main 方法中的变量 a 和 b。

因此，无论 swap 方法如何修改 x 和 y 的值，main 方法中的变量 a 和 b 的值仍然保持不变。

如果想要在 swap 方法中实现真正的交换，可以使用引用类型参数（例如使用包装类 Integer），或者通过返回交换后的值。下面是一种修改方法的方式：

public class RunoobTest {  
    public static void main(String[] args) {  
        Integer a = 10, b = 20; // 使用Integer作为引用类型
        swap(a, b); // 调用swap方法  
        System.out.println("a = " + a + ", b = " + b); // 输出a和b的值  
    }  
    
    public static void swap(Integer x, Integer y) {  
        Integer temp = x;  
        x = y;  
        y = temp;  
    }  
}

在这个修改后的示例中，a 和 b 被声明为 Integer 类型，这样它们就成为了引用类型。当 swap 方法被调用时，它们传递的是引用的副本，因此 swap 方法中对 x 和 y 的值的修改会影响到 main 方法中的变量 a 和 b。

---

4. Java 局部变量

1. 主要概念

声明位置：

• 局部变量声明在方法、构造方法或者语句块中。
• 这意味着它们的作用域被限制在所属的方法、构造方法或语句块内部。

public class Example {
    public void exampleMethod() {
        int localVar = 10; // 在方法内部声明局部变量
        System.out.println(localVar);
    }
}

生命周期：

• 局部变量在所属的方法、构造方法或语句块被执行的时候创建，执行完成后被销毁。
• 这意味着局部变量只在其所属的执行环境中有效。局部变量的生命周期仅限于其所属的方法、构造方法或语句块的执行过程。一旦执行结束，局部变量就会被销毁，其占用的内存空间被释放。

public class Example {
    public void exampleMethod() {
        int localVar = 10; // 在方法内部声明局部变量
        System.out.println(localVar);
    }
}

声明和作用域：

• **局部变量必须在使用前声明，并且不能被访问修 饰符修饰，因为它们的作用域已经被限制在了声明它们的方法、代码块或构造函数中。
• 局部变量只在声明它的方法、构造方法或者语句块中可见，不能被其他方法或代码块访问。**
• 它们的作用域被限制在声明它们的方法、代码块或构造函数中，因此不能在其他方法或代码块中访问。声明局部变量意味着告诉编译器在哪里分配内存以存储该变量的值。

public class Example {
    public void exampleMethod() {
        // 在方法内部声明局部变量
        int localVar = 10; 
        System.out.println(localVar);
    }
    
    public void anotherMethod() {
        // 无法访问 exampleMethod 中的局部变量
        // System.out.println(localVar); // 编译错误
    }
}

内存分配：

• 局部变量是在栈上分配的。
• 这意味着变量的生命周期与其所属方法的执行周期相关，并且在方法执行完毕后会自动被销毁。
• 这意味着它们的存储空间在方法执行期间被分配，并且在方法执行结束后被释放。

public class Example {
    public void exampleMethod() {
        // 在方法内部声明局部变量
        int localVar = 10; 
        System.out.println(localVar);
        // 方法执行完毕，局部变量自动销毁
    }
}

默认值：

• 局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。
• 与成员变量不同，局部变量在声明后不会自动被初始化。因此，在使用局部变量之前，必须先显式地进行初始化。
• 如果尝试在未初始化的情况下使用局部变量，将会导致编译错误。

public class Example {
    public void exampleMethod() {
        // 声明局部变量但未初始化
        int localVar;
        // 尝试使用未初始化的局部变量，会导致编译错误
        // System.out.println(localVar); // 编译错误
    }
}
 

2. 声明语法

局部变量的声明语法为：
type variableName;

• type – 表示变量的类型。
• variableName – 表示变量的名称。

局部变量必须在使用之前进行初始化，否则编译器会报错。初始化可以在声明时或后面的代码中进行。如果在声明时未初始化，变量将被赋予默认值，如 int 类型的变量默认为 0，boolean 类型的变量默认为 false，引用类型的变量默认为 null。

局部变量只在声明它的方法、构造方法或语句块内可见，其他方法、构造方法或语句块不能访问该局部变量。当方法、构造方法或语句块执行完毕后，局部变量将被销毁，其占用的内存也会被释放。

实例

以下是一个简单的例子，展示了局部变量的使用：

实例

public class LocalVariablesExample {  
    public static void main(String[] args) {  
        int a = 10; // 局部变量a的声明和初始化  
        int b;     // 局部变量b的声明  
        b = 20;    // 局部变量b的初始化  
         
        System.out.println("a = " + a);  
        System.out.println("b = " + b);  
         
        // 如果在使用之前不初始化局部变量，编译器会报错  
        // int c;  
        // System.out.println("c = " + c);  
    }  
}  

以上实例中我们声明并初始化了两个局部变量 a 和 b，然后打印出它们的值。注意，如果在使用局部变量之前不初始化它，编译器会报错。

---

这个示例演示了Java中局部变量的声明和初始化。

• a 是一个局部变量，它在声明时进行了初始化，值为 10。
• b 也是一个局部变量，它在声明后进行了初始化，值为 20。

在 Java 中，局部变量必须在使用前进行声明，并且在使用之前必须进行初始化。如果尝试在使用之前使用未初始化的局部变量，编译器会报错。

下面的代码展示了如果尝试在使用之前不初始化局部变量会导致编译错误：

// 如果在使用之前不初始化局部变量，编译器会报错  
int c;  
System.out.println("c = " + c);  

因此，为了避免编译错误，应该在使用局部变量之前进行初始化。

---

在以下实例中 age 是一个局部变量，定义在 pupAge()方法中，它的作用域就限制在这个方法中：

package com.runoob.test; 
public class Test{ 
	public void pupAge(){ 
	int age = 0; 
	age = age + 7; 
	System.out.println("小狗的年龄是: " + age); 
	} 
	public static void main(String[] args){
		Test test = new Test(); 
		test.pupAge(); 
		} 
	}

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

小狗的年龄是: 7

---

在下面的例子中 age 变量没有初始化，所以在编译时会出错：

package com.runoob.test; 
public class Test{ 
	public void pupAge(){ 
		int age; age = age + 7; 
		System.out.println("小狗的年龄是 : " + age); 
		} 
	public static void main(String[] args){ 
		Test test = new Test(); 
		test.pupAge(); 
		} 
	}

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

Test.java:4:variable number might not have been initialized
age = age + 7;
         ^
1 error

---

5. 成员变量（实例变量）

1. 重要概念

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

这些是关于Java中成员变量的重要规则和特性。让我通过一个简单的示例来说明：

public class MemberVariablesExample {
    private int number; // 声明一个私有的成员变量 number

    public MemberVariablesExample(int number) { // 构造方法，用于初始化成员变量
        this.number = number; // 使用构造方法参数初始化成员变量
    }

    public void setNumber(int number) { // 方法用于设置成员变量的值
        this.number = number;
    }

    public int getNumber() { // 方法用于获取成员变量的值
        return this.number;
    }

    public static void main(String[] args) {
        MemberVariablesExample example = new MemberVariablesExample(10); // 创建一个 MemberVariablesExample 对象
        System.out.println("初始值：" + example.getNumber()); // 输出初始值
        example.setNumber(20); // 修改成员变量的值
        System.out.println("修改后的值：" + example.getNumber()); // 输出修改后的值
    }
}

在这个示例中：

• number 是一个私有的成员变量，在类中声明但在方法之外。
• 当创建 MemberVariablesExample 对象时，会调用构造方法来初始化 number 成员变量的值。
• 成员变量 number 可以通过 setNumber() 方法进行修改，通过 getNumber() 方法进行获取。
• 成员变量具有默认值，但在构造方法中可以进行初始化。
• 成员变量可以直接通过变量名访问，或者在静态方法以及其他类中使用完全限定名来访问。

通过这个示例，可以更好地理解成员变量的特性和使用方法。

---

成员变量的声明语法为：

accessModifier type variableName;

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

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

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

2. 实例

以下实例我们声明了两个成员变量 a 和 b，并对其进行了访问和设置。注意，我们可以通过对象访问成员变量，也可以通过类名访问静态成员变量。

实例

public class RunoobTest {
private int a; // 私有成员变量a
public String b = “Hello”; // 公有成员变量b

  public static void main(String[] args) {  
     RunoobTest obj = new RunoobTest(); // 创建对象  
       
      obj.a = 10; // 访问成员变量a，并设置其值为10  
      System.out.println("a = " + obj.a);  
       
      obj.b = "World"; // 访问成员变量b，并设置其值为"World"  
      System.out.println("b = " + obj.b);  
  }  

}

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

a = 10
b = World

以下实例我们声明了两个成员变量 name 和 salary，并对其进行了访问和设置。

Employee.java 文件代码：

import java.io.*;
public class Employee{
   // 这个成员变量对子类可见
   public String name;
   // 私有变量，仅在该类可见
   private double salary;
   //在构造器中对name赋值
   public Employee (String empName){
      name = empName;
   }
   //设定salary的值
   public void setSalary(double empSal){
      salary = empSal;
   }  
   // 打印信息
   public void printEmp(){
      System.out.println("名字 : " + name );
      System.out.println("薪水 : " + salary);
   }
 
   public static void main(String[] args){
      Employee empOne = new Employee("RUNOOB");
      empOne.setSalary(1000.0);
      empOne.printEmp();
   }
}

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

$ javac Employee.java 
$ java Employee
名字 : RUNOOB
薪水 : 1000.0

---

6. 类变量（静态变量）

Java 中的静态变量是指在类中定义的一个变量，它与类相关而不是与实例相关，即无论创建多少个类实例，静态变量在内存中只有一份拷贝，被所有实例共享。

静态变量在类加载时被创建，在整个程序运行期间都存在。

1. 定义方式

静态变量的定义方式是在类中使用 static 关键字修饰变量，通常也称为类变量。

以下实例中我们定义一个静态变量 count ，其初始值为 0：

实例

public class MyClass {  
    public static int count = 0;  
    // 其他成员变量和方法  
}  

2. 访问方式

由于静态变量是与类相关的，因此可以通过类名来访问静态变量，也可以通过实例名来访问静态变量。

实例

MyClass.count = 10; // 通过类名访问  
MyClass obj = new MyClass();  
obj.count = 20; // 通过实例名访问  

3.生命周期

静态变量的生命周期与程序的生命周期一样长，即它们在类加载时被创建，在整个程序运行期间都存在，直到程序结束才会被销毁。因此，静态变量可以用来存储整个程序都需要使用的数据，如配置信息、全局变量等。

4.初始化时机

静态变量在类加载时被初始化，其初始化顺序与定义顺序有关。

如果一个静态变量依赖于另一个静态变量，那么它必须在后面定义。

实例

public class MyClass {  
    public static int count1 = 0;  
    public static int count2 = count1 + 1;  
    // 其他成员变量和方法  
}  

上面的例子中，count1 要先于 count2 初始化，否则编译时会报错。

5. 常量和静态变量的区别

常量也是与类相关的，但它是用 final 关键字修饰的变量，一旦被赋值就不能再修改。与静态变量不同的是，常量在编译时就已经确定了它的值，而静态变量的值可以在运行时改变。另外，常量通常用于存储一些固定的值，如数学常数、配置信息等，而静态变量通常用于存储可变的数据，如计数器、全局状态等。

总之，静态变量是与类相关的变量，具有唯一性和共享性，可以用于存储整个程序都需要使用的数据，但需要注意初始化时机和与常量的区别。

6. 静态变量的访问修饰符

静态变量的访问修饰符可以是 public、protected、private 或者默认的访问修饰符（即不写访问修饰符）。

需要注意的是，静态变量的访问权限与实例变量不同，因为静态变量是与类相关的，不依赖于任何实例。

7. 静态变量的线程安全性

Java 中的静态变量是属于类的，而不是对象的实例。因此，当多个线程同时访问一个包含静态变量的类时，需要考虑其线程安全性。

静态变量在内存中只有一份拷贝，被所有实例共享。因此，如果一个线程修改了静态变量的值，那么其他线程在访问该静态变量时也会看到修改后的值。这可能会导致并发访问的问题，因为多个线程可能同时修改静态变量，导致不确定的结果或数据一致性问题。

为了确保静态变量的线程安全性，需要采取适当的同步措施，如同步机制、原子类或 volatile 关键字，以便在多线程环境中正确地读取和修改静态变量的值。

8. 静态变量的命名规范

静态变量（也称为类变量）的命名规范通常遵循驼峰命名法，并且通常使用全大写字母，单词之间用下划线分隔，并且要用 static 关键字明确标识。

• 使用驼峰命名法： 静态变量的命名应该使用驼峰命名法，即首字母小写，后续每个单词的首字母大写。例如：myStaticVariable。

• 全大写字母： 静态变量通常使用全大写字母，单词之间用下划线分隔。这被称为"大写蛇形命名法"（Upper Snake Case）。例如：MY_STATIC_VARIABLE。

• 描述性： 变量名应该是有意义的，能够清晰地表达该变量的用途。避免使用单个字符或不具有明确含义的缩写。

• 避免使用缩写： 尽量避免使用缩写，以提高代码的可读性。如果使用缩写是必要的，确保广泛理解，并在注释中进行解释。

实例

public class MyClass {
// 使用驼峰命名法
public static int myStaticVariable;

// 使用大写蛇形命名法  
public static final int MAX_SIZE = 100;  

// 避免使用缩写  
public static final String employeeName;  

// 具有描述性的变量名  
public static double defaultInterestRate;  

}

9. 静态变量的使用场景

静态变量通常用于以下场景：

• 存储全局状态或配置信息
• 计数器或统计信息
• 缓存数据或共享资源
• 工具类的常量或方法
• 单例模式中的实例变量

10. 实例

以下实例定义了一个 AppConfig 类，其中包含了三个静态变量 APP_NAME、APP_VERSION 和 DATABASE_URL，用于存储应用程序的名称、版本和数据库连接URL。这些变量都被声明为 final，表示它们是不可修改的常量。

在 main() 方法中，我们打印出了这些静态变量的值。

AppConfig.java 文件代码：

public class AppConfig {
    public static final String APP_NAME = "MyApp";
    public static final String APP_VERSION = "1.0.0";
    public static final String DATABASE_URL = "jdbc:mysql://localhost:3306/mydb";
    
    public static void main(String[] args) {
        System.out.println("Application name: " + AppConfig.APP_NAME);
        System.out.println("Application version: " + AppConfig.APP_VERSION);
        System.out.println("Database URL: " + AppConfig.DATABASE_URL);
    }
}

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

Application name: MyApp
Application version: 1.0.0
Database URL: jdbc:mysql://localhost:3306/mydb

可以看到，这些静态变量存储的全局配置信息可以在整个程序中使用，并且不会被修改。这个例子展示了静态变量的另一个常见应用，通过它我们可以很方便地存储全局配置信息，或者实现其他需要全局共享的数据。

以下实例定义了一个 Counter 类，其中包含了一个静态变量 count，用于记录创建了多少个 Counter 对象。

每当创建一个新的对象时，构造方法会将计数器加一。静态方法 getCount() 用于获取当前计数器的值。

在 main() 方法中，我们创建了三个 Counter 对象，并打印出了计数器的值。

Counter.java 文件代码：

public class Counter {
    private static int count = 0;
    
    public Counter() {
        count++;
    }
    
    public static int getCount() {
        return count;
    }
    
    public static void main(String[] args) {
        Counter c1 = new Counter();
        Counter c2 = new Counter();
        Counter c3 = new Counter();
        System.out.println("目前为止创建的对象数: " + Counter.getCount());
    }
}

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

目前为止创建的对象数: 3

可以看到，计数器记录了创建了三个对象。这个例子展示了静态变量的一个简单应用，通过它我们可以很方便地统计对象的创建次数，或者记录其他需要全局共享的数据。

本章节中我们学习了Java的变量类型，下一章节中我们将介绍Java修饰符的使用。