Java 变量类型

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

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

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

格式说明：

type – 数据类型。

identifier – 是变量名，可以使用逗号 , 隔开来声明多个同类型变量。

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

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 语言支持的变量类型有：

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

public void exampleMethod() {

int localVar = 10; // 局部变量

// …

}

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

public class ExampleClass {

int instanceVar; // 实例变量

}

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

public class ExampleClass {

static int classVar; // 类变量

}

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

public void exampleMethod(int parameterVar) {

// 参数变量

// …

}

以下实例中定义了一个 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

Java 参数变量

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

Java 方法的声明语法如下：

accessModifier returnType methodName(parameterType parameterName1, parameterType parameterName2, …) {

// 方法体

}

parameterType – 表示参数变量的类型。

parameterName – 表示参数变量的名称。

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

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

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

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

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

实例

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

Java 局部变量

Java 的局部变量是在方法、构造方法或语句块内部声明的变量，其作用域限制在声明它的代码块内部。

局部变量的声明语法为：

type variableName;

type – 表示变量的类型。

variableName – 表示变量的名称。

说明：

作用域：局部变量的作用域限于它被声明的方法、构造方法或代码块内。一旦代码执行流程离开这个作用域，局部变量就不再可访问。

生命周期：局部变量的生命周期从声明时开始，到方法、构造方法或代码块执行结束时终止。之后，局部变量将被垃圾回收。

初始化：局部变量在使用前必须被初始化。如果不进行初始化，编译器会报错，因为 Java 不会为局部变量提供默认值。

声明：局部变量的声明必须在方法或代码块的开始处进行。声明时可以指定数据类型，后面跟着变量名，例如：int count;。

赋值：局部变量在声明后必须被赋值，才能在方法内使用。赋值可以是直接赋值，也可以是通过方法调用或表达式。

限制：局部变量不能被类的其他方法直接访问，它们只为声明它们的方法或代码块所私有。

内存管理：局部变量存储在 Java 虚拟机（JVM）的栈上，与存储在堆上的实例变量或对象不同。

垃圾回收：由于局部变量的生命周期严格限于方法或代码块的执行，它们在方法或代码块执行完毕后不再被引用，因此JVM的垃圾回收器会自动回收它们占用的内存。

重用：局部变量的名称可以在不同的方法或代码块中重复使用，因为它们的作用域是局部的，不会引起命名冲突。

参数和返回值：方法的参数可以视为一种特殊的局部变量，它们在方法被调用时初始化，并在方法返回后生命周期结束。

实例

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

实例

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，然后打印出它们的值。注意，如果在使用局部变量之前不初始化它，编译器会报错。

在以下实例中 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

成员变量（实例变量）

成员变量声明在一个类中，但在方法、构造方法和语句块之外。

当一个对象被实例化之后，每个成员变量的值就跟着确定。

成员变量在对象创建的时候创建，在对象被销毁的时候销毁。

成员变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息。

成员变量可以声明在使用前或者使用后。

访问修饰符可以修饰成员变量。

成员变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把成员变量设为私有。通过使用访问修饰符可以使成员变量对子类可见。

成员变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是 false，引用类型变量的默认值是 null。变量的值可以在声明时指定，也可以在构造方法中指定；

成员变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObjectReference.VariableName。

成员变量的声明语法为：

accessModifier type variableName;

accessModifier --表示访问修饰符，可以是 public、protected、private 或默认访问级别（即没有显式指定访问修饰符）。

type – 表示变量的类型。

variableName – 表示变量的名称。

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

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

实例

以下实例我们声明了两个成员变量 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

类变量（静态变量）

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

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

定义方式

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

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

实例

public class MyClass {

public static int count = 0;

// 其他成员变量和方法

}

访问方式

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

实例

MyClass.count = 10; // 通过类名访问

MyClass obj = new MyClass();

obj.count = 20; // 通过实例名访问

生命周期

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

初始化时机

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

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

实例

public class MyClass {

public static int count1 = 0;

public static int count2 = count1 + 1;

// 其他成员变量和方法

}

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

常量和静态变量的区别

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

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

静态变量的访问修饰符

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

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

静态变量的线程安全性

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

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

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

静态变量的命名规范

静态变量（也称为类变量）的命名规范通常遵循驼峰命名法，并且通常使用全大写字母，单词之间用下划线分隔，并且要用 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;

}

静态变量的使用场景

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

存储全局状态或配置信息

计数器或统计信息

缓存数据或共享资源

工具类的常量或方法

单例模式中的实例变量

实例

以下实例定义了一个 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修饰符的使用。