Java中的变量

        本文主要是帮助理解变量的本质是什么,在开发中有什么用?变量的三要素是什么?怎么声明变量?怎么给变量赋值?变量是如何分类的?变量的作用域?等一系列问题。总之,这篇文章全面讲解Java中的变量。

        在理解变量之前,认识一下什么是字面量是很有必要的。

1.字面量

        字面量就是数据/数值,例如:1234,true,"abc",'中',3.14。其实在现实生活中我们每天都会接触到数据,例如:你今天的体重是60Kg,你今天花了200元,买了一个西瓜的重量是6.5Kg等等。
        软件其实就是为了解决现实生活中的问题,解决生活当中的问题其实就是处理生活当中的数据,一门编程语言首先要能够表示数据才可以处理数据,所以Java程序通过字面量来表示数据。
        在编程语言中数据一般会被分门别类,所以每个数据都是有数据类型的,不同的数据类型会分配不同大小的内存空间去存储它。
        数据被分为:整数型、浮点型、字符型、布尔型、字符串型等。
                --整数型(数字):1、2、100、-2等。
                --浮点型(数字,带小数):1.0、2.0、3.14等。
                --字符型(文字,单个字符):' a '、' 中 '、' 9 '等。
                --布尔型(真假):true、false等。
                --字符串型(文字,多个字符):"你好呀"、" Hello "、" 100 "、" true "、" 3.14 "、" abc "等。
        需要注意的是,Java中规定字符型字面量必须是单个字符,采用半角的单引号 ' ' 括起来,而字符串型字面量必须使用半角双引号 " " 括起来。这是一个语法规定,不然编译器就报错了。

2.变量

      (1)变量概述

        变量是内存当中存储数据最基本的单元,将数据(字面量)放到内存当中,给这块内存空间起一个名字,这就是变量。所以变量就是内存当中的一块空间,这块空间有名字、有类型、有值,这也是变量必须具备的三要素。
        上面我们提到过一个东西叫做数据类型,数据类型在任何一门编程语言当中都很重要,因为程序在运行的过程中会通过不同的数据类型给数据分配不同大小的空间。有的数据类型占用的空间较小,但有的数据类型占用的空间就会很大。这也是符合现实的,在现实生活中有些数据较大,有些数据则较小。
        变量要求“变量的数据类型”和变量中存储的“数据(字面量)”的类型必须是一致的,换句话说,冰箱是用来存放小食品的,也就是说冰箱只能存放小食品,大象不能往冰箱里放,原因是放不下,空间不合适。例如:int 类型就只能存下 4 个字节大小的整数,再长一点儿放不下,比如 long 类型的整数占有 8 个字节,这样的数据肯定是无法放到 int 类型的变量当中的。
        所谓变量:可变化的量。它的意思是变量中存储的数据不是一成不变的,是可以被改变的,假设变量 i 中之前存储的数据是 10,我们可以将 10 换成 100,变量就是这个意思。
        变量是有三要素组成的,分别是:数据类型、变量名、存储的值。其中存储的值就是上面说到的字面量。

      (2)使用变量 

        我们在使用变量之前需要先进行变量的声明,那么声明变量的语法格式是什么呢?如下:

数据类型   变量名

        我们以“ int ”这种数据类型为例,int 表示整数类型(注意:int 是关键字,不能随意写,必须全部小写)。变量名只要符合标识符命名规则即可,当然也要见名知意,命名规范中还要求变量名首字母小写,后面每个单词首字母大写。请看以下代码则表示声明一个 int 类型的变量age 用来存储年龄数据:

public class VarTest01 {
    public static void main(String[] args){
        int age; // 年龄
    }
}

        大家可以看到上面的代码中这个 age 变量的三要素当中只具备了两个要素:数据类型和变量名,此时的 age 变量并没有存储数据(或者说没有赋值),那么这个 age 变量可以访问吗?我们来试一下,请看代码:

public class VarTest01 {
    public static void main(String[] args){
        int age; // 年龄
        System.out.println(age);
    }
}
        我们对上面的程序进行编译,请看下图:

        以上编译错误信息为:可能尚未初始化变量 age,意思是说 age 变量还没有初始化(没有赋值),也就是说变量 age 中还没有数据,空间还没有开辟出来,可见,Java 语言中的变量要求必须先声明,再赋值,才能访问。那么 java 语言中怎么给变量赋值呢?在 Java 语言中给变量赋值需要采用赋值运算符“=”,请看赋值的语法格式

变量名  =  值;

        在以上的语法当中,等号右边的值其实就是数据,上面所说的字面量就可以当做“值”。其中的等号“=”是一种运算符,它被称为赋值运算符,赋值运算符右边的表达式优先级较高,所以等号右边先执行,将执行结果赋给左边的变量。(注意:Java 语言中的单等号不是用来判断是否相等的,是为了完成赋值运算的)接下来我们给 age 变量赋值,请看以下代码:

public class VarTest01 {
    public static void main(String[] args){
        int age; // 年龄
        age = 20;
        System.out.println(age);
    }
}

        我们对以上的代码进行编译并运行,请看下图结果:

        可以看到,以上程序的运行在控制台输出了:20。这里需要注意的是,当在 Java程序中输出某个变量的时候,会自动输出变量中所保存的值。以上的测试说明了我们的赋值是没有问题的。那么赋值运算还有其他注意事项吗?有的。在进行赋值运算的时候,Java 中规定 “值” 的数据类型必须和 “变量” 的数据类型保持一致,也就是说 int 类型的变量只能存储 int 类型的数据,不能存储其他类型的数据,我们来进行一个简单的测试,请看以下代码:

public class VarTest01 {
    public static void main(String[] args){
        int age; 
        age = "20"; // 字符串类型的字面值
    }
}

        我们对以上程序进行编译,请看下图的编译结果:

        通过以上的编译我们可以看出,程序的第四行出错了,错误信息是:类型不兼容,这是因为编译器检测到 age 变量是 int 类型,只能存储 int 类型的数据,结果赋给 age 变量的数据不是一个 int 类型的数据,而是一个带有双引号的字符串。 通过以上的测试证实了在进行赋值运算的时候,“值”的数据类型必须和“变量”的数据类型一致才可以。
 
        变量赋值之后可以再次重新赋值吗?当然可以,要不然怎么能叫变量呢。请看以下代码:
 
public class VarTest01 {
    public static void main(String[] args){
        int age; 
        age = 20;
        System.out.println(age);
        age = 30;
        System.out.println(age);
    }
}

        我们对以上代码进行编译和运行,结果如下图所示:

        通过测试可以看到变量是可以重新赋值的。在以上的程序当中,我们看到变量的声明和赋值是分两行代码完成的,那么变量的声明和赋值可以在一行上完成吗,我们再进行一个简单的测试,请看以下代码:
 
public class VarTest02 {
    public static void main(String[] args){
        int count = 100;
        System.out.println(count);
    }
}

        我们对以上程序进行编译和运行,请看运行结果:

        通过以上的测试,可以看出,变量的声明和赋值是可以在一行上完成的,声明变量的同时可以完成赋值运算。那么 Java 允许一次声明多个同类型的变量吗( C++ 是允许的, Java 可以吗)?请看以下代码:
public class VarTest03 {
    public static void main(String[] args) {
        int a = 200, b = 300, c = 400;
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
    }
}
        以上程序当中,我们看到第三行代码,一次声明了 3 int 类型的变量,并且分别进行了赋值。我们对以上的程序进行编译和运行,结果如下图所示:
        通过运行结果可以看出,Java 是允许一次声明多个同类型的变量的。我们将以上的代码进行一个简单的修改,请看修改之后的代码:
public class VarTest03 {
    public static void main(String[] args) {
        int a, b, c = 400;
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
    }
}

        对以上的程序进行编译,请看以下编译结果:

        我们可以看到程序编译报错了,而错误信息中显示 a 变量和 b 变量并没有赋值,这说明了代码“int a, b, c = 400; ”表示声明了三个 int 类型的变量,分别起名 a b c ,其中 c 变量赋值400,而 a b 是没有赋值的,这里一定要注意,以上代码并不表示给 abc 三个变量同时赋值 400
        接下来我们再来研究一下,在同一个大括号当中,可以声明两个同名的变量吗?请看以下代码:
public class VarTest04 {
    public static void main(String[] args) {
        int age = 20;
        int age = 30;
        System.out.println(age);
    }
}

        我们对以上的代码进行编译,请看下图结果:

        通过以上的编译结果,可以看到第 4 行出错了,结果也证实了在同一个大括号当中不能同时声明多个同名的变量。这是因为在同一个大括号当中表示在内存的同一个域当中,在同一块区域上面有两个名字都叫做 age 的变量,这是不允许的,因为这样程序在运行的时候, java 虚拟机也不知道该访问哪个变量了(好比说,你有两个朋友,他们的俩的名字都叫张三,当你们三个人同时在场的时候,你呼张三,其实他俩也不知道你在叫谁呢!)。所以,同一个域中变量名不能重名,但是记住:变量是可以重新赋值的。比如以下代码:
public class VarTest04 {
    public static void main(String[] args) {
        int age = 20;
        age = 30;
        System.out.println(age);
    }
}

        我们将以上代码进行编译并运行,请看下图结果:

        最后我们再来看一下,在方法体当中的代码是否存在执行顺序,变量可以先访问,后声明吗?请看以下代码:
public class VarTest05 {
    public static void main(String[] args) {
        System.out.println(age);
        int age = 20;
    }
}

        对以上程序进行编译,请看下图编译结果:

        以上测试结果中显示第 3 行报错了,错误信息是找不到符号,换句话说 age 变量是不存在 的,通过这个测试得知,方法中的代码是有执行顺序的,遵循自上而下的顺序依次逐行执行,也说明了变量必须先声明,然后才能使用。
      (3)变量分类
        变量根据声明的位置不同可分为: 局部变量和成员变量在方法体当中声明的变量以及方法的每一个参数都是局部变量在方法体外,类体内声明的变量称为成员变量成员变量声明时如果使用 static 关键字修饰的为静态成员变量(简称静态变量)如果没有 static 关键字修饰则称为实例成员变量(简称实例变量),请看以下代码:
public class VarTest06 {
    int x = 20; // 实例变量
    static int y = 200; // 静态变量
    public static void sum(int a, int b){ // 局部变量 a 和 b
        int firstNum = 100; // 局部变量
    }
}
        在以上代码当中,sum 是和 main 相似的方法,在 sum 方法当中 a b 都是方法上的参数属 于局部变量,在 sum 的方法体当中声明的 firstNum 属于局部变量。大家也可以看到在 sum 方法体外面声明了两个变量,一个是 x ,一个是 y ,这两个变量都属于成员变量, x 变量没有使用 static 修饰属于实例变量,而 y 属于静态变量。
        局部变量只在方法体当中有效,方法开始执行的时候局部变量的内存才会被分配,当方法执行结束之后,局部变量的内存就释放了。所以局部变量的生命周期非常短暂。
      (4)变量的作用域
        所谓变量的作用域就是变量的有效范围,实际上局部变量、实例变量、静态变量它们存储在 Java 虚拟机的不同内存区域上,所以变量是有作用域的。关于变量的有效范围,有一个口诀:“出了大括号就不认识了”。我们来测试一下,请看以下代码:
public class VarTest07 {
    public static void main(String[] args){
        int k = 100; // 局部变量 k
    }
    public static void m() {
        System.out.println(k);
    }
}
        在以上代码中我们可以看到在 main 方法中声明了一个变量 k 是一个局部变量,只在本方法中有效(main 方法),那么在 m 方法中是否可以访问局部变量 k 呢?我们对以上程序进行编译,请看下图结果:
 
        通过以上的编译结果可以看到第 6 行出错了,错误信息找不到符号,也就是说 k 变量是不存在的无法访问的。这也印证了之前所说的那句话:出了大括号就不认识了。接下来我们对以上程序进行修改,如果将变量声明为静态变量呢?变量的作用域会发生改变吗?请看以下代码:
public class VarTest07 {
    static int k = 100; // 静态变量 k
    public static void main(String[] args){
        System.out.println("main k = " + k);
    }
    public static void m(){
        System.out.println(k);
    }
}

        我们对以上代码进行编译,并运行,请看下图结果:

        我们可以看到编译通过了,并且程序也正常运行了。那为什么只输出了 main 方法中的 k ,而 m 方法中的 k 没有输出呢?这是因为 m 方法并没有执行,程序的执行是从 main 方法作为入口进来执行的,在 main 方法中并没有手动调用 m 方法,所以 m 方法是不会执行的。不过这个测试也印证了那句话:出了大括号就不认识了,只要没有出大括号,变量就是有效的可访问的,以上程序声明 k 变量的位置在类体当中,方法体在类体当中包含,所以在以上的 main 方法和 m 方法中都是可以访问 k 变量的。接下来我们对以上的程序进一步修改,请看以下代码:
public class VarTest07 {
    static int k = 100; // 静态变量 k
    public static void main(String[] args){
        int k = 300; // 局部变量 k
        System.out.println("main k = " + k);
    }
    public static void m(){
        System.out.println(k);
    }
}
        看到以上代码,我们发现在 main 方法当中声明了一个局部变量 k ,有人可能会说,有两个同名的变量 k ,这个程序编译会报错的,因为变量名不能重名,如果你要是这么想的就错了,我们之前确实说过变量名不能重名,但是我们指的是“在同一个域”当中变量名不能重名,以上程序声明的两个变量 k 处在不同的域当中,一个是类体域,一个是方法体域。那么我们对以上程序进行编译并运行,结果会是怎样呢,请看下图结果:
        通过上图我们看到程序不但编译通过了,而且还运行了,并且运行的结果不是 100 ,而是 300,这说明了 Java 程序遵守“就近原则”,其实这个就近原则不止是 Java 语言中存在,大部分的编程语言都符合这个原则。也就是说以上程序在 main 方法中访问变量 k 的话,访问的是局部变量 k ,而不是静态变量 k 。那  m 方法中的 k 访问的是哪个呢?我们尝试在 main 方法中调用 m 方法,让 m 方法执行,来测试一下输出结果,请看以下代码:
public class VarTest07 {
    static int k = 100;  // 静态变量 k
    public static void main(String[] args){
        int k = 300; // 局部变量 k
        System.out.println("main k = " + k);
        m(); // 调用 m 方法
    }
    public static void m(){
        System.out.println(k);
    }
}
         我们对以上程序进行编译并运行,请看下图结果:
 
        通过以上的测试我们可以看到在 m 方法中访问的是静态变量 k ,因为输出结果是 100 ,而不是 300 。因为局部变量 k 的作用域在 main 方法中。
        (本文仅代表个人观点,不喜勿喷!)
  • 2
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值