全国协议5人面授小班,企业级独立开发考核,转业者的IT软件工程师基地 登录/注册 | 如何报名
当前位置: Java   >  Java 变量
admin · 更新于 2021-08-06

1. 什么是变量

在程序设计中,变量是指一个包含值的存储地址以及对应的符号名称

从定义上来看,变量大概可分为两部分:变量的名字和变量的值,可通过变量名来访问变量值。简单来说,变量就是存储数据的载体。

对于 Java 语言来讲,Java 是一种强类型的语言,因此变量都必须有一个类型。在 Java 代码中,变量是长这个样子的:

// =左侧的age是变量名,右侧的22是变量值int age = 22;
代码块
  • 1
  • 2

2. 创建变量

我们已经在上面看到了变量在代码中的样子,现在我们来动手创建变量。

Java语言中,我们需要做两件事才能创建一个变量:

  1. 给变量起一个名字
  2. 定义变量的数据类型

创建变量的过程也叫声明变量,声明变量的语法如下:

DataType 变量名;
代码块
  • 1

Tips:关于数据类型,我们将在下一小节介绍。此处只需知道变量有类型之分即可。

声明一个变量,实例如下:

int a;
代码块
  • 1

上述代码,声明了一个名字为a,类型为整型的变量。

我们可以再声明一个名字为b,类型为字符型的变量,实例如下:

char b;
代码块
  • 1

再声明两个整型的变量agenumber,实例如下:

int age;int number;
代码块
  • 1
  • 2

3. 给变量赋值

变量声明操作已经告诉了编译器变量的数据类型。数据类型决定了变量中可以存放什么,不能存放什么,上述的变量aint类型(整型),因此只能存放整数。

一旦声明了一个变量,我们就可以使用赋值语句为其赋值,实例如下:

// 变量声明语句int a;// 赋值语句a = 1;
代码块
  • 1
  • 2
  • 3
  • 4

为变量分配值的语句,就称为赋值语句。需要特别提醒的是,语句中=的意义不同于数学中的等号,在 Java 中,=是赋值符号。

对于变量的声明和赋值操作,我们也可以将这两条语句合并成一条语句,实例如下:

int a = 1;
代码块
  • 1

另外,如果要创建多个类型相同的变量,我们可以在一条语句中将多个变量的声明进行分组:

int a, b;a = 1;b = 2;
代码块
  • 1
  • 2
  • 3

为了精简语法,还可以将变量的声明和赋值同时分组:

int a = 1, b = 2;
代码块
  • 1

在作用域范围内,变量的值能够随时访问或重新赋值,比如:

实例演示
class PrintVariable {
    public static void main(String[] args) {
        int a = 20;
    	System.out.println("修改前变量a=" + a);
    	// 将变量a重新赋值为100
    	a = 100;
    	System.out.println("修改后变量a=" + a);
    }}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
运行案例点击 "运行案例" 可查看在线运行效果

运行结果:

修改前变量a=20
修改后变量a=100
代码块
  • 1
  • 2

上述代码中,声明了一个整型变量a,且初始化值为20,可以使用a = 100;这种赋值语句,对变量a重新赋值。

注意,在 Java 中,对变量进行重新赋值,这样的写法是错误的:

int a = 20;int a = 100;
代码块
  • 1
  • 2

编译代码,将会抛出异常:

Test.Java:5: 错误: 已在方法 main(String[])中定义了变量 a
	int a = 2;
	    ^
1 个错误
代码块
  • 1
  • 2
  • 3
  • 4

编译报错的原因很简单,第二行代码再次定义了变量a,而变量a已经在内存中存在了,不能再重复定义。这与对变量重新赋值不同。

4. 变量命名规范

对于变量的命名,每种编程语言都有自己的规则和约定,Java 语言也不例外。命名变量的规则和约定如下:

  • 变量的名称可以是任何合法的标识符,以字母,美元符号$或下划线_开头。但是,按照约定俗成,变量应始终以字母开头,不推荐使用美元符号和下划线开头;
  • 开头后续的字符可以是字母、数字、美元符号或下划线。为变量选择名称时,推荐使用完整的英文单词,不推荐使用单词缩写,更不要使用中文拼音。这样做有利于代码的阅读和理解。另外请牢记,选择的名称不能是关键字保留字
  • 变量命名区分大小写
  • 变量命名应采用小驼峰命名法。所谓小驼峰命名法,就是如果你选择的名称只包含一个单词,那么用全部小写字母拼写该单词;如果名称包含多个单词,请将第二个单词起的每个单词的第一个字母都大写;
  • 如果变量存储了一个常量值,要将每个字母大写并用下划线字符分隔每个单词。比如static final int MAX_NUM = 100。按照约定俗成,除了常量命名的情况,下划线字符永远不会在其他地方使用。

下面我们对照上述规则和约定来看几个实例。

实例1:

int $a;int _b;int age;
代码块
  • 1
  • 2
  • 3

上面3个变量的声明都是合法的,但是根据约定俗称,不推荐$a这种以美元符号开头、_b这种以下划线开头的命名方式。

实例2:

public class VariablesNameing2 {
    public static void main(String[] args) {
        String Name = "Colorful";
        String name = "Colorful1";
        System.out.println("Name=" + Name);
        System.out.println("name=" + name);
    }}
代码块
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

变量名区分大小写,因此上面的Namename是两个不同的变量。由于只有一个单词组成,应将单词使用全部小写拼写,不推荐第1行Name这种命名方式。

实例3:

// 声明姓和名变量String firstName;String lastname;
代码块
  • 1
  • 2
  • 3

上面声明了两个变量 firstNamelastname,由于它们都是由两个单词组成,按照小驼峰命名法的约定俗成:第2行lastname 变量名由两个英文单词组成,因此推荐改为lastName

5. 常量

所谓常量,就是恒常不变的量。我们可以将常量理解成一种特殊的变量。

与变量不同的是,一旦它被赋值后,在程序的运行过程中不允许被改变。常量使用final关键字修饰:

final DataType 常量名 = 常量值;
代码块
  • 1

Tips:常量的命名规范与普通变量有所不同,要将每个字母大写并用下划线字符分隔每个单词。

如果我们尝试在代码中修改常量的值:

class ConstantTest {
    public static void main(String[] args) {
        // 声明并初始化常量 TOTAL_NUM
        final int TOTAL_NUM = 200;
        // 对 TOTAL_NUM 重新赋值
        TOTAL_NUM = 20;
    }}
代码块
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

编译执行代码,编译器将会报错:

ConstantTest.Java:6: 错误: 无法为最终变量TOTAL_NUM分配值
        TOTAL_NUM = 20;
        ^
1 个错误
代码块
  • 1
  • 2
  • 3
  • 4

适当地使用常量可以提高代码的安全性和可维护性。例如,我们可以在程序中声明一个表示网站名称的常量: final String SITE_NAME = "汉码未来";,这样在所有需要用到网站名称的地方,都调用这个常量即可。这样既保证了其值不可修改,提高了代码的安全性,又统一了调用方的规范。

6. 变量的种类

学习变量的种类,需要你对 Java 的类和对象有一定的了解。目前不要求完全理解,等到后面学完面向对象相关知识后再回过头来回味。

Java 语言定义了以下4 种变量 :

  • 实例变量(见代码中instanceVariable
  • 类变量(见代码中classVariable
  • 局部变量(见代码中localVariable
  • 参数(见代码中parameterargs
public class KindsOfVariables {
    // 1.实例变量
    public int instanceVariable = 1;
    // 2.类变量
    public static int classVariable;
    
    public void demoMethod(int parameter) { // 3.参数	    
        // 4.局部变量
        int localVariable;
    }
    
    public static void main(String[] args) {
        // 入口方法
    }}
代码块
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

6.1 实例变量

实例变量在类范围内声明。声明时不使用static关键字修饰,因此也称为非静态字段

实例变量用于存储对象的状态,它的值对于类的每个实例都是唯一的,每个对象都拥有自己的变量副本。只要相应的对象存在于内存中,它就占用着存储空间。

下面是一个实例变量的实例,当然,我们还没有介绍类和对象的概念,如果你了解类和对象,可以阅读源码帮助理解:

实例演示
public class Student {
    // 实例变量 name
    public String name;
    // 实例变量 age
    public int age;

    // 构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 打印学生基本信息的方法
    public void printInfo() {
        System.out.println("学生姓名为:" + name);
        System.out.println("学生年龄为:" + age);
    }

    public static void  main(String[] args) {
        // 实例化两个学生对象
        Student student1 = new Student("小码", 20);
        Student student2 = new Student("小李", 18);
        // 分别调用打印学生基本信息方法,打印两个对象下的两个实例变量
        student1.printInfo();
        System.out.println("--------分割线--------");
        student2.printInfo();
    }}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
运行案例点击 "运行案例" 可查看在线运行效果

运行结果:

学生姓名为:小码
学生年龄为:20
--------分割线--------
学生姓名为:小李
学生年龄为:18
代码块
  • 1
  • 2
  • 3
  • 4
  • 5

实例变量和实例对象相关,因此需要通过new关键字实例化出对象,通过对象才能访问其实例变量(也称实例属性)。 上述代码中,nameage就是用于存储其对象的属性,我们实例化了两个学生对象,其实例变量nameage,在每个对象实例中是唯一的。

6.2 类变量

类变量在类范围内使用static关键字修饰,因此类变量又被称为静态字段、静态变量

static修饰符告诉编译器,无论类被实例化多少次,类变量始终只有一个变量副本。只要类被加载到内存中,它就会存在。

另外,类变量可以被声明为常量,通过使用final关键字以表示变量永远不会改变。例如:public static final NAME = "慕慕",这里的NAME就是不会改变的常量。再次提醒,在常量的命名规范中,要将字母全部大写。

对于类变量,我们再来看一个实例:

实例演示
public class Course {
  
  	// 类变量 courseType
  	public static String courseType = "文字课程";
  	// 常量 COURSE_NAME
  	public static final String COURSE_NAME = "Java 基础教程";
  	
	public static void main(String[] args) {
      	// 分别打印类变量和常量
      	System.out.println(Course.courseType);
      	System.out.println(Course.COURSE_NAME);
    }}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
运行案例点击 "运行案例" 可查看在线运行效果

运行结果:

文字课程
Java 基础教程
代码块
  • 1
  • 2

类变量和类相关,因此不需要使用new关键字实例化对象后再调用,可以直接通过类名 + .点运算符 + 类变量名的方式调用。

上述代码中,courseType 和COURSE_NAME都使用static关键字修饰,它们都可以直接通过Course.变量名的方式调用。

6.3 局部变量

局部变量是在方法范围内被声明和使用的。它们没有任何关键字修饰,可以根据变量声明的位置来认定局部变量(即方法的左花括号和右花括号之间),因此,局部变量只可以对声明它们的方法可见。方法返回后,它们将被销毁。

main方法中的局部变量实例:

public static void main(String[] args) {
  	// 局部变量 name
  	String name = "小码";
  	// 局部变量 age
  	int age = 20;    	
  	System.out.println("姓名:" + name);
  	System.out.println("年龄:" + age);}
代码块
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

我们再来看一个自定义方法中的局部变量实例:

public class PrintNumber {
  
  	public void printer() {
  	    int num = 10;
  	    for(int i = 1; i <= num; i ++) {
	      	System.out.println(i);
        }
    }
  }
代码块
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

局部变量和方法相关,因此只能在方法内部局部定义和使用,在第二个实例中没有代码注释,请思考printer方法中有哪几个局部变量。

6.4 参数

参数是用于传递给方法签名的变量(例如入口方法main中的args),它们可以在方法中的任何位置被调用。在方法执行的期间位于内存中,方法返回后被销毁。

例如,上面实例变量的实例中,Student类的构造方法就接收两个参数,如下为代码截取:

// Student 类构造方法public Student(String name, int age) {  // name 和 age 就是传递给Student构造方法的参数
    this.name = name;
    this.age = age;}
代码块
  • 1
  • 2
  • 3
  • 4
  • 5

注意,方法体中的this.namethis.age指代的是实例变量,而 nameage是参数,它们被用于赋值给实例变量。

7. 小结

在本小节中,我们知道了变量是存储数据的载体,声明变量时要注意变量的命名规范,给变量赋值时要根据声明的数据类型赋值。

Java 中变量有4个种类,分别是:实例变量、类变量、局部变量、参数。其中变量如果使用了final关键字修饰,就可定义一个不可变的常量。

当然,需要再次强调的是:不要使用中文拼音来命名变量,这是很常见的但非常不好的习惯。英文基础差的童鞋可以下载一个英文词典,当你要选择一个变量的名称时,多查阅一下单词,选择出最符合变量特征的单词。好的变量命名不仅让你的代码易于阅读理解,也有助于你更好地梳理实际编码中繁琐的业务逻辑。


为什么选择汉码未来