变量是Java 程序的一个基本存储单元。变量由一个标识符，类型及一个可选初始值的组合定义。此外，所有的变量都有一个作用域，定义变量的可见性，生存期。接下来讨论变量的这些元素。声明一个变量 在Java 中，所有的变量必须先声明再使用。基本的变量声明方法如下：type identifier [ = value][，identifier [= value] ...] ; type 是Java 的基本类型之一，或类及接口类型的名字。标识符（identifier ）是变量的名字，指定一个等号和一个值来初始化变量。请记住初始化表达式必须产生与指定的变量类型一样（或兼容）的变量。声明指定类型的多个变量时，使用逗号将各变量分开。 动态初始化 尽管前面的例子仅将字面量作为其初始值，Java 也允许在变量声明时使用任何有效的表达式来动态地初始化变量。例如，下面的短程序在给定直角三角形两个直角边长度的情况下，求其斜边长度。// Demonsate dynamic initialization. class DynInit { public static void main(Sing args[]) { double a = 3.0, b = 4.0; // c is dynamically initializeddouble c = Math.sqrt(a * a b * b); System.out.println("Hypotenuse is " c); } } 这里，定义了3个局部变量a，b，c。前两个变量a和b初始化为常量。然而直角三角形的斜边c被动态地初始化（使用勾股定理）。该程序用了Java 另外一个内置的方法sqrt()，它是Math类的一个成员，计算它的参数的平方根。这里关键的一点是初始化表达式可以使用任何有效的元素，包括方法调用、其他变量或字面量。变量的作用域和生存期 到目前为止，我们使用的所有变量都是在方法main() 的后面被声明。然而，Java 允许变量在任何程序块内被声明。在第2章中已解释过了，程序块被包括在一对大括号中。一个程序块定义了一个作用域（scope ）。这样，你每次开始一个新块，你就创建了一个新的作用域。你可能从先前的编程经验知道，一个作用域决定了哪些对象对程序的其他部分是可见的，它也决定了这些对象的生存期。大多数其他计算机语言定义了两大类作用域：全局和局部。然而，这些传统型的作用域不适合Java 的严格的面向对象的模型。当然将一个变量定义为全局变量是可行的，但这是例外而不是规则。在Java 中2个主要的作用域是通过类和方法定义的。尽管类的作用域和方法的作用域的区别有点人为划定。因为类的作用域有若干独特的特点和属性，而且这些特点和属性不能应用到方法定义的作用域，这些差别还是很有意义的。因为有差别，类（以及在其内定义的变量）的作用域将被推迟到第6章当讨论类时再来讨论。到现在为止，我们将仅仅考虑由方法或在一个方法内定义的作用域。 方法定义的作用域以它的左大括号开始。但是，如果该方法有参数，那么它们也被包括在该方法的作用域中。 作为一个通用规则，在一个作用域中定义的变量对于该作用域外的程序是不可见（即访问）的。因此，当你在一个作用域中定义一个变量时，你就将该变量局部化并且保护它不被非授权访问和/或修改。实际上，作用域规则为封装提供了基础。 作用域可以进行嵌套。例如每次当你创建一个程序块，你就创建了一个新的嵌套的作用域。这样，外面的作用域包含内部的作用域。这意味着外部作用域定义的对象对于内部作用域中的程序是可见的。但是，反过来就是错误的。内部作用域定义的对象对于外部是不可见的。为理解嵌套作用域的效果，考虑下面的程序： // Demonsate block scope. class Scope { public static void main(Sing args[]) { int x; // known to all code within main x = 10; if(x == 10) { // start new scope int y = 20; // known only to this block // x and y both known here. System.out.println("x and y: " x " " y); x = y * 2; } // y = 100; // Error! y not known here // x is still known here. System.out.println("x is " x); } } 正如注释中说明的那样，在方法main() 的开始定义了变量x，因此它对于main() 中的所有的随后的代码都是可见的。在if程序块中定义了变量y。因为一个块定义一个作用域，y 仅仅对在它
的块以内的其他代码可见。这就是在它的块之外的程序行y=100; 被注释掉的原因。如果你将该行前面的注释符号去掉，编译程序时就会出现错误，因为变量y在它的程序块之外是不可见的。在if程序块中可以使用变量x，因为块（即一个嵌套作用域）中的程序可以访问被其包围作用域中定义的变量。 变量可以在程序块内的任何地方被声明，但是只有在他们被声明以后才是合法有效的。因此，如果你在一个方法的开始定义了一个变量，那么它对于在该方法以内的所有程序都是可用的。反之，如果你在一个程序块的末尾声明了一个变量，它就没有任何用处，因为没有程序会访问它。 例如，下面这个程序段就是无效的，因为变量count 在它被定义以前是不能被使用的。 // This fragment is wrong! count = 100; // oops! cannot use count before it is declared! int count; 另一个需要记住的重要之处是：变量在其作用域内被创建，离开其作用域时被撤消。 这意味着一个变量一旦离开它的作用域，将不再保存它的值了。因此，在一个方法内定义的变量在几次调用该方法之间将不再保存它们的值。同样，在块内定义的变量在离开该块时也将丢弃它的值。因此，一个变量的生存期就被限定在它的作用域中。 如果一个声明定义包括一个初始化，那么每次进入声明它的程序块时，该变量都要被重新初始化。例如，考虑这个程序： // Demonsate lifetime of a variable. class LifeTime { public static void main(Sing args[]) { int x; for(x = 0; x < 3; x ) { int y = -1; // y is initialized each time block is entered System.out.println("y is: " y); // this always prints -1 y = 100; System.out.println("y is now: " y);} } } 该程序运行的输出如下：y is: -1 y is now: 100 y is: -1 y is now: 100 y is: -1 y is now: 100 可以看到，每次进入内部的for循环，y都要被重新初始化为-1。即使它随后被赋值为100，该值还是被丢弃了。最后一点：尽管程序块能被嵌套，你不能将内部作用域声明的变量与其外部作用域声明的变量重名。在这一点上，Java 不同于C和C 。下面的例子企图为两个独立的变量起同样的名字。在Java 中，这是不合法的。但在C/C 中，它将是合法的，而且2个变量bar将是独立的。// This program will not compile class ScopeErr {public static void main(Sing args[]) { int bar = 1; { // creates a new scopeint bar = 2; // Compile-time error – bar already defined! } } }
core java适合您
在Java 中，所有的变量必须先声明再使用。基本的变量声明方法如下：type identifier [ = value][，identifier [= value] ...] ; type 是Java 的基本类型之一，或类及接口类型的名字。标识符（identifier ）是变量的名字，指定一个等号和一个值来初始化变量。请记住初始化表达式必须产生与指定的变量类型一样（或兼容）的变量。声明指定类型的多个变量时，使用逗号将各变量分开。
动态初始化
尽管前面的例子仅将字面量作为其初始值，Java 也允许在变量声明时使用任何有效的表达式来动态地初始化变量。例如，下面的短程序在给定直角三角形两个直角边长度的情况下，求其斜边长度。// Demonsate dynamic initialization.
class DynInit {
public static void main(Sing args[]) {
double a = 3.0, b = 4.0;
// c is dynamically initializeddouble c = Math.sqrt(a * a b * b); System.out.println("Hypotenuse is " c);
}
}
这里，定义了3个局部变量a，b，c。前两个变量a和b初始化为常量。然而直角三角形的斜边c被动态地初始化（使用勾股定理）。该程序用了Java 另外一个内置的方法sqrt()，它是Math类的一个成员，计算它的参数的平方根。这里关键的一点是初始化表达式可以使用任何有效的元素，包括方法调用、其他变量或字面量。变量的作用域和生存期
到目前为止，我们使用的所有变量都是在方法main() 的后面被声明。然而，Java 允许变量在任何程序块内被声明。在第2章中已解释过了，程序块被包括在一对大括号中。一个程序块定义了一个作用域（scope ）。这样，你每次开始一个新块，你就创建了一个新的作用域。你可能从先前的编程经验知道，一个作用域决定了哪些对象对程序的其他部分是可见的，它也决定了这些对象的生存期。大多数其他计算机语言定义了两大类作用域：全局和局部。然而，这些传统型的作用域不适合Java 的严格的面向对象的模型。当然将一个变量定义为全局变量是可行的，但这是例外而不是规则。在Java 中2个主要的作用域是通过类和方法定义的。尽管类的作用域和方法的作用域的区别有点人为划定。因为类的作用域有若干独特的特点和属性，而且这些特点和属性不能应用到方法定义的作用域，这些差别还是很有意义的。因为有差别，类（以及在其内定义的变量）的作用域将被推迟到第6章当讨论类时再来讨论。到现在为止，我们将仅仅考虑由方法或在一个方法内定义的作用域。
方法定义的作用域以它的左大括号开始。但是，如果该方法有参数，那么它们也被包括在该方法的作用域中。
作为一个通用规则，在一个作用域中定义的变量对于该作用域外的程序是不可见（即访问）的。因此，当你在一个作用域中定义一个变量时，你就将该变量局部化并且保护它不被非授权访问和/或修改。实际上，作用域规则为封装提供了基础。
作用域可以进行嵌套。例如每次当你创建一个程序块，你就创建了一个新的嵌套的作用域。这样，外面的作用域包含内部的作用域。这意味着外部作用域定义的对象对于内部作用域中的程序是可见的。但是，反过来就是错误的。内部作用域定义的对象对于外部是不可见的。为理解嵌套作用域的效果，考虑下面的程序：
// Demonsate block scope.
class Scope {
public static void main(Sing args[]) {
int x; // known to all code within main
x = 10;
if(x == 10) { // start new scope
int y = 20; // known only to this block
// x and y both known here.
System.out.println("x and y: " x " " y);
x = y * 2;
}
// y = 100; // Error! y not known here
// x is still known here.
System.out.println("x is " x);
}
}
正如注释中说明的那样，在方法main() 的开始定义了变量x，因此它对于main() 中的所有的随后的代码都是可见的。在if程序块中定义了变量y。因为一个块定义一个作用域，y 仅仅对在它
变量可以在程序块内的任何地方被声明，但是只有在他们被声明以后才是合法有效的。因此，如果你在一个方法的开始定义了一个变量，那么它对于在该方法以内的所有程序都是可用的。反之，如果你在一个程序块的末尾声明了一个变量，它就没有任何用处，因为没有程序会访问它。
例如，下面这个程序段就是无效的，因为变量count 在它被定义以前是不能被使用的。
// This fragment is wrong!
count = 100; // oops! cannot use count before it is declared!
int count;
另一个需要记住的重要之处是：变量在其作用域内被创建，离开其作用域时被撤消。
这意味着一个变量一旦离开它的作用域，将不再保存它的值了。因此，在一个方法内定义的变量在几次调用该方法之间将不再保存它们的值。同样，在块内定义的变量在离开该块时也将丢弃它的值。因此，一个变量的生存期就被限定在它的作用域中。
如果一个声明定义包括一个初始化，那么每次进入声明它的程序块时，该变量都要被重新初始化。例如，考虑这个程序：
// Demonsate lifetime of a variable.
class LifeTime {
public static void main(Sing args[]) {
int x;
for(x = 0; x < 3; x ) {
int y = -1; // y is initialized each time block is entered
System.out.println("y is: " y); // this always prints -1
y = 100;
System.out.println("y is now: " y);}
}
}
该程序运行的输出如下：y is: -1
y is now: 100
y is: -1
y is now: 100
y is: -1
y is now: 100
可以看到，每次进入内部的for循环，y都要被重新初始化为-1。即使它随后被赋值为100，该值还是被丢弃了。最后一点：尽管程序块能被嵌套，你不能将内部作用域声明的变量与其外部作用域声明的变量重名。在这一点上，Java 不同于C和C 。下面的例子企图为两个独立的变量起同样的名字。在Java 中，这是不合法的。但在C/C 中，它将是合法的，而且2个变量bar将是独立的。// This program will not compile
class ScopeErr {public static void main(Sing args[]) {
int bar = 1;
{ // creates a new scopeint bar = 2; // Compile-time error – bar already defined!
}
}
}