Java 中的变量 - 简单教程，简单编程

变量是内存中的一个给定位置的名称，它是程序中的基础单元。Java 中的变量有以下几个特征。

在程序执行期间，存储在变量中的值可以随时变更。
变量只是内存中的一个给定位置的名称。对变量的所有操作，都会影响内存中的那个指定位置。
Java 语言中，所有的变量都必须在使用前正确的声明。

如何声明一个变量

我们可以使用下面的格式声明一个变量

int age = 20;

各部分的说明如下图

Java 变量声明

数据类型 : 可以存储在此变量中的数据的类型。数据类型定义了变量指向的内存区域的大小。
变量名称 : 给变量定义的名称。
值 : 存储在变量中的初始值。

例如

float simpleInterest;

上面这句代码声明了一个 float 类型的变量，并命名为 simpleInterest。

可以在同一个变量声明语句中声明多个相同的数据类型的变量。变量之间使用逗号 ( , ) 分隔。

int age = 10, speed = 20;

上面这条语句声明了两个 int 类型的变量 age 和 speed ，并分隔给它们初始化为 10 和 20 。

Java 中变量的分类

Java 中的变量大体可以分为以下三大类：

局部变量
实例变量
静态变量

严格意义上说，只有两大类： 局部变量 和 静态变量 。因为实例变量也是它们中的特殊成员。

接下来，我们就来看看什么是 局部变量，什么又是 静态变量 。

局部变量

如果一个变量是在一个块 { ... } 中，或一个方法中、或一个构造方法中定义的。那么我们就称这种类型的变量为 局部变量 。

局部变量会在进入这个块或调用相应的方法时创建，会在离开那个块时或这方法使用 return 语句后离开方法时销毁。

局部变量只存在于声明和定义它们的块中。也就是说，我们只能在声明和定义它们的那个块中访问它们。

我们写一小段代码来演示一下

JavaTester.java

public class JavaTester {
    public void run()
    {
        // 局部变量 age
        int age = 0;
        age = age + 5;
        System.out.println("我的年龄是： " + age );
    }

    public static void main( String args[] )
    {
        JavaTester tester = new JavaTester();
        tester.run();
    }
}

编译运行上面这段代码，输出结果如下

[yufei@www.twle.cn java]$ javac JavaTester.java && java JavaTester
我的年龄是： 5

上面这段代码中，变量 age 是方法 run() 中的一个局部变量。如果我们在 run() 方法之外使用这个变量 age ，编译器就会抛出一个异常。

public class JavaTester {
    public void run()
    {
        // 局部变量 age
        int age = 0;
        age = age + 5;
    }

    public static void main( String args[] )
    {
        JavaTester tester = new JavaTester();
        tester.run();

        // 在 run() 方法之外使用局部变量 age
        System.out.println("我的年龄是： " + age );
    }
}

编译以上代码，会出错

[yufei@www.twle.cn java]$ javac JavaTester.java && java JavaTester
JavaTester.java:15: 错误: 找不到符号
        System.out.println("我的年龄是： " + age );
                                       ^
  符号:   变量 age
  位置: 类 JavaTester
1 个错误

错误告诉我们，找不到符号 age 。

实例变量

实例变量是非静态的变量。它们声明在一个类的内部，但又不属于任何方法、构造方法和块。

class JavaTester 
{    
    // 这些变量都是实例变量. 
    // 这些变量在类中定义，但又不属于任何一个方法 
    int engMarks; 
    int mathsMarks; 
    int phyMarks; 
}

实例变量是在类中声明的。这些变量会在类的某个实例被创建是一同创建。也会在该实例被销毁时一同销毁。

与局部变量不同的是，我们可以为实例变量添加 访问修饰符 。如果我们不给实例变量添加访问修饰符。那么它们就会自动添加上默认的访问修饰符。

我们可以写一些代码来演示下实例变量的使用

JavaTester.java

import java.io.*; 

public class JavaTester 
{    
    // 这些变量都是实例变量. 
    // 这些变量在类中定义，但又不属于任何一个方法 
    int engMarks; 
    int mathsMarks; 
    int phyMarks; 

    public static void main(String args[]) 
    {   
        // 第一个实例 
        JavaTester obj1 = new JavaTester(); 
        obj1.engMarks = 50; 
        obj1.mathsMarks = 80; 
        obj1.phyMarks = 90; 

        //第二个实例
        JavaTester obj2 = new JavaTester(); 
        obj2.engMarks = 80; 
        obj2.mathsMarks = 60; 
        obj2.phyMarks = 85; 

        //显示第一个对象的实例变量 
        System.out.println("Marks for first object:"); 
        System.out.println(obj1.engMarks); 
        System.out.println(obj1.mathsMarks); 
        System.out.println(obj1.phyMarks); 

        //显示第二个对象的实例变量 
        System.out.println("Marks for second object:"); 
        System.out.println(obj2.engMarks); 
        System.out.println(obj2.mathsMarks); 
        System.out.println(obj2.phyMarks); 
    } 
}

编译运行上面这段代码，输出结果如下

Marks for first object:
50
80
90
Marks for second object:
80
60
85

上面这个范例中。变量 engMarks , mathsMarks , phyMarksare 都是实例变量。

如上面程序中所显示，我们创建了 JavaTester 类的多个对象。每个对象都拥有它们自己的实例变量的副本。这一点可以从输出的结果中看出，每个对象都有自己的实例变量副本

静态变量

静态变量 也称为 类变量。

静态变量 的声明和 实例变量 有点相似。不同的地方在于，静态变量的声明需要添加 static 关键字。

class JavaTester { 

   // 静态变量 salary 
   public static double salary; 
   public static String name = "Harsh"; 
}

与实例变量的另一个不同点是，对于每一个类来说，无论我们创建了多少个该类的对象，这些对象始终共享一个静态变量的副本。

静态变量会在程序开始执行时创建，并在程序结束后销毁。也就是说，静态变量会一直存在于程序的运行期间。

访问静态变量

访问静态变量，我们并不需要先创建类的实例。而是可以直接使用类名 + 变量名来访问。

静态变量的访问方法如下

class_name.variable_name;

例如上面的 JavaTester 类的静态变量 salary 。我们可以使用下面的方式访问

JavaTester.salary

同样的，我们写一段代码来演示下静态变量的使用

JavaTester.java

import java.io.*; 

public class JavaTester 
{  
    // 静态变量 salary 
    public static double salary; 
    public static String name = "Harsh"; 

     public static void main(String args[]) { 

      // 静态变量可以不需要创建对象就可以访问         
      JavaTester.salary = 1000; 
      System.out.println(JavaTester.name + "'s average salary:" + JavaTester.salary); 
   } 

}

编译运行上面这段代码，输出结果如下

[yufei@www.twle.cn java]$ javac JavaTester.java && java JavaTester
Harsh's average salary:1000.0

实例变量 vs 静态变量

每个对象都有自己的实例变量副本，但每个类只能有一个静态变量副本，而不管我们创建了多少个该类的对象。
在对一个对象的实例变量所做的更改不会影响到其它对象的实例变量，因为每个对象都有自己的实例变量副本。但对类的静态变量所做的更改会反应到该类的所有对象。因为这些对象都共用了静态变量的一个副本。
实例变量的访问方法是 对象名 + 变量名 ，而静态变量的访问方法是 类名 + 变量名。