概述

简单的说，变量就是一个与可更改的值相关联的一个名字或名称，比如int i = 0;这是声明一个名称为 i的变量，并且与之关联的值是0，int则是变量的数据类类型，表示这个i变量可以关联一个整数值，或者说赋值一个整数。

声明变量

声明一个变量的语法格式如下：
[修饰符] 数据类型 变量名 [ = 初始值] [,变量名 [ = 初始值]…];

Tip：[] 中为可选项，因为在 Java 中可以先声明变量，之后在赋值。

  • 我们可以只声明变量，然后再给变量赋值。如：int num;… num = 1;，数据类型我们后面会详细介绍，现在只需要知道num就赋值一个int（正数值）类型的值，并在之后的代码中把变量num赋值为1。
  • 也可以声明变量的同时并给变量赋值。如：char ch = 'A';声明字符变量ch,并把变量ch赋值为'A'，或者说把'A'赋值给变量ch。

标识符

变量命名、类的命名都属于标识符，所以就统一介绍标识符的命名规则及使用规范。

标识符的命名规则（必须）：

  1. 标识符必须以字母、下划线（_）、数字或美元（$）组成；
  2. 标识符必须由字母、下划线（_）或美元（$）开头，不能由数字开头；
  3. 标识符不能是关键字或者保留字；
  4. 标识符中不能有空格;
  5. 标识符没有长度限制；
  6. 标识符对大小写敏感。

标识符的使用规范（约定成俗，不是必须但建议）：

  • 表示类名的标识符：每个单词的首字母大写，如Book, JavaBook
  • 表示方法和变量的标识符：第一个单词小写，从第二个单词开始首字母大写，我们称之为“驼峰原则”，如read(), readBook()

  • 表示常量的标识符：全部单词大写，用下划线分隔，如BASE_URL，PI

    Java 的变量类型

    变量根据声明的位置不同可以分为：

  • 局部变量

  • 成员变量
    • 静态成员变量（类变量）
    • 实例成员变量（实例变量)
  1. 在方法体中声明的变量以及方法的每一个参数变量都是局部变量。
  2. 在方法体外，类体内声明的变量称为成员变量。
  3. 成员变量声明时如果使用static关键字修饰的称为静态成员变量（简称静态变量或类变量）

  4. 如果没有static关键字修饰则称为实例成员变量（简称实例变量）

    实例变量

    声明在方法体外，类体之内，没有用**static**关键字修饰的变量。
    顾名思义，实例变量是属于实例对象的，对于每个实例对象，都拥有自己的实例变量副本，它们互不影响，相互隔离。

    1. public class InstanceVariable {
    2.  /**
    3.   * 成员变量（实例变量） var
    4.   */
    5.  String var = "initValue";
    7.  /**
    8.   * main 方法输出结果
    9.   *
    10.   * obj1.var:initValue
    11.   * obj2.var:initValue
    12.   * obj3.var:initValue
    13.   * 用 obj2 改变 var 的值
    14.   * 再分别访问实例变量
    15.   * obj1.var:initValue
    16.   * obj2.var:newValue
    17.   * obj3.var:initValue
    18.   */
    19.  public static void main(String[] args) {
    20.      // 创建 3 个对象
    21.      InstanceVariable obj1 = new InstanceVariable();
    22.      InstanceVariable obj2 = new InstanceVariable();
    23.      InstanceVariable obj3 = new InstanceVariable();
    24.      // 访问 实例变量 var
    25.      System.out.println("obj1.var:" + obj1.var);
    26.      System.out.println("obj2.var:" + obj2.var);
    27.      System.out.println("obj3.var:" + obj3.var);
    28.      System.out.println("用 obj2 改变 var 的值");
    29.      obj2.var = "newValue";
    30.      System.out.println("再分别访问实例变量");
    31.      System.out.println("obj1.var:" + obj1.var);
    32.      // 只有 obj2.var 的值改变
    33.      System.out.println("obj2.var:" + obj2.var);
    34.      System.out.println("obj3.var:" + obj3.var);
    36.      //实例变量不能通过类名访问，以下代表会报错，因为实例变量属于实例对象，每个对象都有自己变量副本，互不影响
    37.      // System.out.println("StaticVariable.staticVar:" + InstanceVariable.staticVar);
    38.  }
    39. }

    如上代码所示，创建 3 个对象，并且创建对象时实例变量都被赋值为initValue,然后修改对象 obj2的实例变量var的值为"newValue",可以看到其他对象的值不会改变，只会改变对象obj2的变量值。
    所以实例变量属于实例对象，对象直接相互隔离，各对象维护自己的变量副本。

    静态变量

    声明在方法体外，类体之内，并且用**static**关键字修饰的变量。
    静态变量也可以叫做类变量，静态变量属于类，对于类的每个实例都共享这一个变量。
    比如我创建三个类的实例对象去访问一个静态变量，得到的结果是一样的，并且我通过其中一个实例对这个静态变量进行修改，同样会反馈给其他对象。

    1. public class StaticVariable {
    2.  /**
    3.   * 声明一个静态变量 staticVar (静态变量声明 是用 static 关键字修饰变量即可)
    4.   */
    5.  static String staticVar = "initValue";
    7.  /**
    8.   * main 方法输出结果：
    9.   *
    10.   * obj1.staticVar:initValue
    11.   * obj2.staticVar:initValue
    12.   * obj3.staticVar:initValue
    13.   * 用其中一个对象修改静态变量
    14.   * 再分别访问静态变量
    15.   * obj1.staticVar:newValue
    16.   * obj2.staticVar:newValue
    17.   * obj3.staticVar:newValue
    18.   * 最后，我们可以直接用类名访问静态变量，如下
    19.   * StaticVariable.staticVar:newValue
    20.   */
    21.  public static void main(String[] args) {
    22.      // 创建 3 个对象
    23.      StaticVariable obj1 = new StaticVariable();
    24.      StaticVariable obj2 = new StaticVariable();
    25.      StaticVariable obj3 = new StaticVariable();
    26.      // 访问 静态变量 staticVar (其实不推荐用对象访问静态变量，用 【类名.静态变量名】 方式更好)
    27.      System.out.println("obj1.staticVar:" + obj1.staticVar);
    28.      System.out.println("obj2.staticVar:" + obj2.staticVar);
    29.      System.out.println("obj3.staticVar:" + obj3.staticVar);
    30.      System.out.println("用其中一个对象修改静态变量");
    31.      obj2.staticVar = "newValue";
    32.      System.out.println("再分别访问静态变量");
    33.      System.out.println("obj1.staticVar:" + obj1.staticVar);
    34.      System.out.println("obj2.staticVar:" + obj2.staticVar);
    35.      System.out.println("obj3.staticVar:" + obj3.staticVar);
    36.      System.out.println("最后，我们可以直接用类名访问静态变量，如下");
    37.      System.out.println("StaticVariable.staticVar:" + StaticVariable.staticVar);
    38.  }
    39. }

    如上代码所示，无论用什么对象访问静态变量得到的结果是相同的，所以我们访问静态变量是不推荐使用对象访问，直接用类名.静态变量名访问，也只有静态变量可以这样用类名访问。

    局部变量

    在类的方法体中声明的以及方法的每一个参数都是局部变量。
    它们的作用域仅限与方法中，这意味着出了方法，就无法访问到方法中的局部变量。
    以下代码我会声明一个与局部变量名称相同的成员变量，来演示局部变量的作用域。

    1. public class LocalVariable {
    2.  String var = "成员变量";
    4.  void method(){
    5.      String var = "方法内变量";
    6.      System.out.println(var);
    7.  }
    9.  /**
    10.   * main 方法输出结果：
    11.   *
    12.   * 调用一下方法，会打印方法里的变量 var :方法内变量
    13.   * 打印类的变量 var :成员变量
    14.   */
    15.  public static void main(String[] args) {
    16.      LocalVariable obj = new LocalVariable();
    17.      System.out.print("调用一下方法，会打印方法里的变量 var :");
    18.      obj.method();
    19.      System.out.println("打印类的变量 var :" + obj.var);
    20.      // 可见方法之外访问不到方法内的局部变量，
    21.      //但方法内可以访问外部的成员，这会用到 this 关键字，我们留点悬念以后再说
    22.  }
    23. }

    变量类型一览表

    | 局部变量、成员变量、静态变量的区别 | | | | | —- | —- | —- | —- | | 类型 | 声明位置 | 从属于 | 生命周期 | | 局部变量 | 方法或语句块内部 | 方法/语句块 | 从声明位置开始，直到方法或语句块执行完毕，局部变量消失 | | 成员变量
    (实例变量) | 类内部，方法外部 | 对象 | 对象创建，成员变量也跟着创建。
    对象消失，成员变量也跟着消失； | | 静态变量
    (类变量) | 类内部，static修饰 | 类 | 类被加载，静态变量就有效；
    类被卸载，静态变量消失。 |

常量

常量通常指的是一个固定的值，例如：1、 2、 3、 ‘a’、 ‘b’、 true、 false、 “helloWorld” 等。
在Java语言中，利用关键字 final修饰变量来定义一个常量。
常量一旦被初始化后不能再更改其值。