“尽管以C++为基础，但 Java 是一种更纯粹的面向对象程序设计语言”。
无论C++还是Java 都属于杂合语言。但在 Java 中，设计者觉得这种杂合并不象在 C++里那么重要。杂合语言允许采用多种编程风格；之所以说 C++是一种杂合语言，是因为它支持与 C语言的向后兼容能力。由于C++是C的一个超集，所以包含的许多特性都是后者不具备的，这些特性使 C++在某些地方显得过于复杂。Java 语言首先便假定了我们只希望进行面向对象的程序设计。也就是说，正式用它设计之前，必须先将自己的思想转入一个面向对象的世界（除非早已习惯了这个世界的思维方式）。只有做好这个准备工作，与其他OOP语言相比，才能体会到 Java 的易学易用。在本章，我们将探讨 Java 程序的基本组件，并体会为什么说Java 乃至Java 程序内的一切都是对象。
用引用去操作对象
每种语言都有自己在内存中处理元素的方法。有时候程序员必须时刻注意自己正在处理的什么类型。你曾经直接处理过元素，或你用过一些特殊的语法处理某种间接地引用（如c或c++内的指针）吗？
java在这里做了简化，可以用一致的语法把任何东西被看做对象。但要注意，尽管将一切都“看作”对象，但操纵的标识符实际是指向一个对象的“引用”（reference）。你能把它想象成电视机（the object）和电视机的遥控器（reference）。只要你拿着引用，你就有一个电视机的连接，但是当你换频道或调低音量时，你操作的是引用，再由遥控器去修改电视机（object）。如果你想在房间里移动同时控制电视机，你只需带着遥控器（reference）而不是电视机。
当然，遥控器在没电视机的情况下可以单独存在，就是说你拥有一个reference并不意味着有这个对象连接着一个对象。所以如果你想要抓住一个单词或句子，你应该创造一个String 的reference:
String s;
package com.thinkinjava.one;
public class Everythingisobject {
public static void main(String args[])
{
String s;
System.out.println(s.hashCode());//编译不过
s="abc";
System.out.println(s);
}
}
但是你仅仅创造了一个reference，并没有创造一个object。如果你想赋给s一个消息，它会报错，因为s并没有连接任何对象（没有连接的电视机），没有初始化引用,所以对变量s的任何操作(除了初始化赋值外) 都将引发异常.安全起见，当你创造它时，你应该把引用初始化了：
String s="asdf";
注意：这是java的一个特殊的特征：通过一个文本就把String 类型的引用初始化了，通常，必须为对象使用一种更通用的初始化类型。
你必须创造所有的类型
当你创造了一个引用，你想要这个引用连接一个新的对象。一般你要用new这个操作符。new的意思是：“把我变成这些对象的一个对象”。所以在上面的例子中，可以说：
String s = new String("asdf");
它不仅指出“将我变成一个新字串”，也通过提供一个初始字串，指出了“如何生成这个新字串”(赋予一个初始字符串)。
当然，java除了String还有很多初始类型。重要的你能创造你自己的类型。事实上，在java程序中，创造新类型是基本的活动。
保存在哪里？
搞清楚当程序运行时数据如何放置是很有用的---特别是内存如何分配很重要。有5个不同的地方存储数据：
(1) 寄存器（Registers）。这是最快的保存区域，因为它位于和其他所有保存方式不同的地方：处理器内部。然而，寄存器的数量十分有限，所以寄存器是根据需要来分配。我们 对此没有直接的控制权，也不可能在自己的程序里找到寄存器存在的任何踪迹。
(2) 堆栈(The stack)。驻留于常规 RAM（随机访问存储器）区域，但可通过它的“堆栈指针”获得处理器的直接支持。堆栈指针若向下移，会创建新的内存；若向上移，则会释放那些内 存。这是一种特别快、特别有效的数据保存方式，仅次于寄存器。创建程序时，Java 编译器必须准确地知道堆栈内保存的所有数据的“长度”以及“存在时间”。这是 由于它必须生成相应的代码，以便向上和向下移动指针。这一限制无疑影响了程序的灵活性，所以尽管有些Java 数据要保存在堆栈里——特别是对象句柄，但Java 对象并 不放到其中。
(3) 堆(The heap)。一种常规用途的内存池（也在 RAM区域），其中保存了Java 对象。和堆栈不同，“内存堆”或“堆”（Heap）最吸引人的地方在于编译器不必知道要从堆里分配多少存储空间，也不必知道存储的数据要在堆里停留多长的时间。因此，用堆保存数据时会得到更大的灵活性。要求创建一个对象时，只需用new命令编制相关的代码即可。执行这些代码时，会在堆里自动进行数据的保存。当然，为达到这种灵活性，必然会付出一定的代价：在堆里分配存储空间时会花掉更长的时间！
(4) 静态存储(Constant storage)。这儿的“静态”（Static）是指“位于固定位置”（尽管也在 RAM里）。程序运行期间，静态存储的数据将随时等候调用。可用static 关键字指出一个对象的特定元素是静态的。但 Java 对象本身永远都不会置入静态存储空间。
(5) 常数存储。常数值通常直接置于程序代码内部。这样做是安全的，因为它们永远都不会改变。有的常数需要严格地保护，所以可考虑将它们置入只读存储器（ROM）。
(6) 非RAM 存储(Non-RAM storage)。若数据完全独立于一个程序之外，则程序不运行时仍可存在，并在程序的控制范围之外。其中两个最主要的例子便是“流式对象”和“固定对象”。对于流式对象，对象会变成字节流，通常会发给另一台机器。而对于固定对象，对象保存在磁盘中。即使程序中止运行，它们仍可保持自己的状态不变。对于这些类型的数据存储，一个特别有用的技巧就是它们能存在于其他媒体中。一旦需要，甚至能将它们恢复成普通的、基于RAM的对象。
特别的例子：原始类型
有一组类型在你的程序中要经常使用它们，你要特别对待。你能把它们当成原始类型。特殊对待它们的原因是如果用new去创建一个对象---特别是小的简单的变量---并不高效，因为new的对象在堆（heap）中。对于这些原始类型，java回到了c和c++用的方法，就是不用new去创建变量，不用利用引用的自动变量。这个变量直接容纳了值，并且放在堆栈（stack）中,所以它更加高效。
java决定了每种原始类型的大小。就象在大多数语言里那样，这些大小并不随着机器结构的变化而变化。这种大小的不可更改正是 Java 程序具有很强移植能力的原因之一。
主类型 大小 最小值 最大值 封装器类型
boolean 1 位 - - Boolean
char 16位 Unicode 0 Unicode 2的 16次方-1 Character
byte 8位 -128 +127 Byte（注释①）
short 16 位 -2 的15 次方 +2的 15次方-1 Short（注释①）
int 32位 -2的 31次方 +2 的31 次方-1 Integer
long 64位 -2 的63 次方 +2的 63次方-1 Long
float 32 位 IEEE754 IEEE754 Float
double 64 位 IEEE754 IEEE754 Double
Void - - - Void（注释①）
数值类型都是有符号的类型，所以不要去找没有符号的类型。
boolean没有显式的定义；它仅仅能定义true或false。
原始类型的封装器类允许你在堆里定义一个非原始对象去代表原始类型
例如：
char c = 'x';
Character C = new Character('c');
也可以直接使用：
Character C = new Character('x');
java se5 自动装箱将自动从一个原始类型转为包装类型
Character ch='x';
然后回去：
char c=ch;
封装原始类型的原因将在以后的章节里解释。
高精度数字
java包括两种实现了高精度的数字类型：BigInteger和BigDecimal.尽管它们可以化为封装器类型，但是它们都没有基本类型。
这两个类都有方法对应着基本类型的操作。就是说你在int和float上做的任何事情，在BigInteger和BigDecimal上也能做，就是说你必须调用它们的方法来代替操作符。同时因为涉及到别的更多的东西，性能会降低，操作会更慢。你为了精确度降低了速度。如下：
BigInteger bigInttmp=new BigInteger("222222");
BigInteger bigInttmp1=new BigInteger("333333");
System.out.println(bigInttmp.add(bigInttmp1));
print result:555555
BigInteger支持任意精度的整形。这意味着你能表示任意大小的整形并在操作中不担心丢失任意信息。
BigDecimal支持任意精度的定点数字。例如，可用它进行精确的币值计算。
至于调用这两个类时可选用的构建器和方法，请自行参考联机帮助文档。
Java 的数组
几乎所有的程序语言都支持数组。在C和 C++里使用数组是非常危险的，因为那些数组只是内存块。若程序访问自己内存块以外的数组，或者在初始化之前使用内存（属于常规编程错误），会产生不可预测的后果（注释②）。
②：在C++里，应尽量不要使用数组，换用标准模板库（Standard TemplateLibrary）里更安全的容器。
java一个主要的设计目标就是安全，所以许多困扰c和c++程序员的问题不会在java里存在。一个java数组可以确保初始化并且不会访问到数组范围之外。数组的范围检查会占据每个数组少量的内存开销以及在运行时验证索引，但由此换回的是更高的安全性，以及更高的工作效率。为此付出少许代价是值得的。
当你创建一个数组对象时，相当于是在创建的很多数组引用，而且那些引用的每一个引用都自动初始化为一个特殊值，并带有自己的关键字：null.当java看到null时，它认出这个引用没有志向一个对象。你必须在使用每个引用前，把一个对象赋给每一个引用。并且如果你试图使用一个指向null的引用，就会在运行时报告问题。所以典型的数组问题能在java中阻止。
你也能创建基本类型的数组。同样，编译器确保对它初始化因为它将那个数组的内存化为零。
数组问题将在以后的章节里详细讨论。
绝对不要清除对象：
在许多编程语言中，变量的“生命周期”（Lifetime）一直是程序员需要着重考虑的问题。变量应持续多长时间？如果你去清除它，你应该什么时候进行？对生命周期的迷惑导致了很多的bug，并且这部分展现java如何通过为你做所有的清理工作来简化这个问题的。
作用域
大多数程序设计语言都有“作用域”的概念。对于作用域中定义的名称，作用域决定着名字的“可见性”和“生命周期”。在c和c++和java中，作用域被大括号的位置决定的。如下：
{
int x = 12;
/* only x available */
{
int q = 96;
/* both x & q available */
}
/* only x available */
/* q “out of scope” */
}
作为在作用域里定义的一个变量，它只有在那个作用域结束之前才可使用。在上面的例子中，缩进排版使Java 代码更易辨读。由于 Java 是一种形式*的语言，所以额外的空格、制表位以及回车都不会对结果程序造成影响。注意尽管在 C和 C++里是合法的，但在 Java 里不能象下面这样书写代码：
{
int x = 12;
{
int x = 96; /* illegal */
}
}
编译器会认为变量x 已被定义。所以C 和C++能将一个变量“隐藏”在一个更大的作用域里。但这种做法在Java 里是不允许的，因为Java 的设计者认为这样做使程序产生了混淆。
对象的作用域：
java对象的生命周期跟基本类型的生命周期是不一样的。当你用new创建一个java对象的时候，java对象会徘徊在作用域范围之外。比如：
{
String s = new String("a string");
} /* 作用域的终点 */
引用s在作用域之外消失了。但是，这个被引用s指向的String 对象仍然在内存里。在这个代码中，没有办法在作用域之外访问对象，因为指向对象的引用已经超出了作用域之外。在后面的章节中你会看到对象的引用如何在程序中传递和复制 。
这样的结果是因为只要我们需要由new创建的对象就一直存在，C++程序中的大量问题在java中消失了。在c++中你不能肯定对象在你需要的时候还存在，你也必须要在你用过对象后去清除对象。
这样就带来了有趣的问题。如果java不清除对象，怎样才能防止它们大量充斥内存，并最终造成程序的“凝固”呢？在C++中这个问题很严重。java处理了这个问题。java有一个垃圾收集器，它会检查所有被new创建的对象并且搞清楚那些对象没有被引用。然后它会释放这些对象的内存，所以内存又能被新的对象利用了。这意味着你不用担心内存的回收问题。你能简单的创建对象，并且当你不用他们的时候，它们将自己消失。这就消灭了一类编程问题：所谓的“内存泄露”，程序员经常忘记去释放内存
创建新的数据类型：类
如果任何东西都能看成一个对象，那么什么决定着一种特定对象类型的外观和行为呢？或者说，什么建立了对象的类型？你可能希望有个关键字“type”,并且这是合理的。历史上，不管怎么样，大多数面向对象语言使用class去定义“我将告诉你一个对象的新类型看起来是什么”。class 关键字太常用了，以至于本书许多地方并没有用粗体字或双引号加以强调。在这个关键字的后面，应该跟随新数据类型的名称。例如：
class ATypeName {/*类主体置于这里}
这样就引入了一种新类型，接下来便可用new 创建这种类型的一个新对象：
ATypeName a = new ATypeName();
在ATypeName 里，类主体只由一条注释构成（星号和斜杠以及其中的内容，本章后面还会详细讲述），所以并不能对它做太多的事情。事实上，除非为其定义了某些方法，否则根本不能指示它做任何事情。
字段和方法
当你定义一个class(并且你在java中做的所有的事是定义类，制造这些类的对象，并且把信息传递给对象)，你能把两种类型的元素放在class里：fields(有时叫数据成员)，和methods(有时叫成员函数)。一个field可以是一个你能用引用调用的任何类型的对象，或基本类型。如果是一个对象的引用，你必须初始化这个引用头连接一个对象（使用new去做）。但若是一种主类型，则可在类定义位置直接初始化（正如后面会看到的那样，句柄亦可在定义位置初始化）。
每个对象都为它的field保有存储空间；一般的field不会在对象之间共享。这有一个带有field的class的例子：
class DataOnly {
int i;
float f;
boolean b;
}除了保持数据这个class没有做任何事情。但你能创建这个类的一个对象：
DataOnly d = new DataOnly();你能给fields赋值，当时你必须首先知道如何引用一个对象的一个成员。
为达到引用对象成员的目的，首先要写上对象句柄的名字，再跟随一个点号（句点），再跟随对象内部成员的名字。即“对象引用.成员”。例如：
d.i = 47; d.f = 1.1f; d.b = false;你可能会去修改你的对象包含的其他对象的field。你可以再写点号去访问和修改。如：
myPlane.leftTank.capacity = 100;这个DataOnly类除了保持数据不能做任何事，因为它没有方法。为了去理解是怎么工作的，你必须首先理解参数和返回值。
当field是基本类型时的默认值
当一个基本类型是一个类的成员时，即使你不初始化它他也能保证有一个默认值的：
基本类型 默认值
Boolean false
Char '\u0000'(null)
byte (byte)0
short (short)0
int 0
long 0L
float 0.0f
double 0.0d
当变量当做类的成员使用的时候，java能确保变量的默认值。这就确保了当基本类型作为成员变量时能够被初始化（C++不具备这一功能），可有效遏止多种相关的编程错误。
当这种保证不能用于局部变量--局部变量并不是类的field。因此，如果你在一个方法定义中你有：
int x;
那么x 会得到一些随机值（这与C 和C++是一样的），不会自动初始化成零。我们责任是在正式使用x 前分配一个适当的值。如果忘记，就会得到一条编译期错误，告诉我们变量可能尚未初始化。这种处理正是Java优于C++的表现之一。许多 C++编译器会对变量未初始化发出警告，但在 Java 里却是错误。如下：
成员变量不用人工初始化，java自动分配默认值：
<pre name="code" class="java">public class Everythingisobject {
int fieldObject;
public static void main(String args[])
{
Everythingisobject objDefautVal=new Everythingisobject();
objDefautVal.DefaultValue();
}
private void DefaultValue()
{
int field;
System.out.println(fieldObject);
//System.out.println(field);
}
print:0
局部变量不给初始化默认值会报告编译期错误：
public class Everythingisobject {
int fieldObject;
public static void main(String args[])
{
Everythingisobject objDefautVal=new Everythingisobject();
objDefautVal.DefaultValue();
}
private void DefaultValue()
{
int field;
System.out.println(field);
}
Exception in thread "main" java.lang.Error: Unresolved compilation problem: The local variable field may not have been initialized但是，对于你写的程序来说这种初始化的值也许不是对的，或是非法的。最好是对你的类成员变量有个显式的初始化。
方法、自变量和返回值：
在许多语言中（像c和c++）,function被用于描述子程序。在java中更为通用的是method作为“做某事的途径”。尽管它们表达的实际是同一个意思，但从现在开始，本书将一直使用“方法”，而不是“函数”。
Java 的“方法”决定了一个对象能够接收的消息。通过本节的学习，大家会知道方法的定义有多么简单！方法的基本组成部分包括名字、自变量、返回类型以及主体。下面便是它最基本的形式：
返回类型 方法名( /* 自变量列表*/ ) {/* 方法主体 */}返回类型是指调用方法之后返回的数值类型。显然，方法名的作用是对具体的方法进行标识和引用。自变量列表列出了想传递给方法的信息类型和名称。Java 的方法只能作为类的一部分创建。只能针对某个对象调用一个方法（注释③），而且那个对象必须能够执行那个方法调用。若试图为一个对象调用错误的方法，就会在编译期得到一条出错消息。为一个对象调用方法时，需要先列出对象的名字，在后面跟上一个句点，再跟上方法名以及它的参数列表。亦即“对象名.方法名(自变量1，自变量2，自变量 3...)。举个例子来说，假设我们有一个方法名叫 f()，它没有自变量，返回的是类型为int的一个值。那么，假设有一个名为 a 的对象，可为其调用方法f()，则代码如下：
int x = a.f();返回值的类型必须兼容 x的类型。象这样调用一个方法的行动通常叫作“向对象发送一条消息”。在上面的例子中，消息是f()，而对象是 a。 面向对象的程序设计通常简单地归纳为“向对象发送消息”。
③：正如马上就要学到的那样，“静态”方法可针对类调用，毋需一个对象。
方法参数列表
方法参数列表定义了你向方法传递了什么信息。跟你猜的一样，这些信息--像java中其它的一样--采用对象的形式。所以，你在参数列表中要定义传人对象的类型和每个对象的名称。像java在其它地方处理对象一样，实际上你传递的是引用（对于前面提及的“特殊”数据类型 boolean，char，byte，short，int，long，，float 以及double 来说是一个例外。但在传递对象时，通常都是指传递指向对象的引用。）。但引用的类型必须是正确的。倘若希望自变量是一个“字串”，那么传递的必须是一个字串。
下面让我们考虑将一个字串作为自变量使用的方法。下面列出的是定义代码，必须将它置于一个类定义里，否则无法编译：
int storage(String s) {
return s.length() * 2;
}这个方法告诉在一个类型为String的变量中，你需要多少个byte去处理特定的String的信息（字串里的每个字符都是16位，或者说 2 个字节、以便提供对Unicode 字符的支持）。这个参数是String类型的并且被命名为s。
一旦s被传人方法，你就能像其它对象一样对待它了。（可向其发送消息）。这里，方法length()被调用，它是String的方法之一。它返回的是一个字符串的字符个数。
也可以了解return 关键字的运用。它主要做两件事情。首先，它意味着“离开方法，我已完工了”。其次，假设方法生成了一个值，则那个值紧接在return 语句的后面。在这种情况下，返回值是通过计算表达式“s.length()*2”而产生的。
可按自己的愿望返回任意类型，但倘若不想返回任何东西，就可指示方法返回void（空）。下面列出一些例子。
boolean flag() { return true; }
float naturalLogBase() { return 2.718; }
void nothing() { return; }
void nothing2() {}若返回类型为void，则return 关键字唯一的作用就是退出方法。所以一旦抵达方法末尾，该关键字便不需要了。可在任何地方从一个方法返回。但假设已指定了一种非 void 的返回类型，那么无论从何地返回，编译器都会确保我们返回的是正确的类型。
到此为止，大家或许已得到了这样的一个印象：一个程序只是一系列对象的集合，它们的方法将其他对象作为自己的自变量使用，而且将消息发给那些对象。这种说法大体正确，但通过以后的学习，大家还会知道如何在一个方法里作出决策，做一些更细致的基层工作。至于这一章，只需理解消息传送就足够了。
构建 Java 程序
正式构建自己的第一个 Java 程序前，还有几个问题需要注意。
名字的可见性
在所有编程语言中，一个问题是名称的控制。如果你在程序的一个模块中使用了一个名称，并且另一块程序员使用了另一个名称，你如何区分这两个名称同时阻止这两个名称发生冲突？这个问题在 C语言里特别突出。因为程序未提供很好的名字管理方法。C++的类（即 Java 类的基础）嵌套使用类里的函数，使其不至于同其他类里的嵌套函数名冲突。然而，C++仍然允许使用全局数据以及全局函数，所以仍然难以避免冲突。为解决这个问题，C++用额外的关键字引入了“命名空间”的概念。
java通过一个全新的方法避免了这个问题。为了给一个库生成明确的名字，采用了与Internet域名类似的名字。事实上，Java 的设计者鼓励程序员反转使用自己的Internet 域名，因为它们肯定是独一无二的。由于我的域名是BruceEckel.com，所以我的实用工具库就可命名为com.bruceeckel.utility.foibles。反转了域名后，可将点号想象成子目录。
在Java 1.0 和 Java 1.1 中，域扩展名 com，edu，org，net 等都约定为大写形式。所以库的样子就变成：COM.bruceeckel.utility.foibles。然而，在 Java 1.2的开发过程中，设计者发现这样做会造成一些问题。所以目前的整个软件包都以小写字母为标准。
Java 的这种特殊机制意味着所有文件都自动存在于自己的命名空间里。而且一个文件里的每个类都自动获得一个独一无二的标识符（当然，一个文件里的类名必须是唯一的）。所以不必学习特殊的语言知识来解决这个问题——语言本身已帮我们照顾到这一点。
使用其他组件
一旦要在自己的程序里使用一个预先定义好的类，编译器就必须知道如何找到它。当然，这个类可能就在发出调用的那个相同的源码文件里。如果是那种情况，只需简单地使用这个类即可——即使它直到文件的后面仍未得到定义。Java 消除了“向前引用”的问题，所以不要关心这些事情。
但假若那个类位于其他文件里呢？您或许认为编译器应该足够“联盟”，可以自行发现它。但实情并非如此。假设我们想使用一个具有特定名称的类，但那个类的定义位于多个文件里。或者更糟，假设我们准备写一个程序，但在创建它的时候，却向自己的库加入了一个新类，它与现有某个类的名字发生了冲突。
为解决这个问题，必须消除所有潜在的、纠缠不清的情况。为达到这个目的，要用import 关键字准确告诉Java 编译器我们希望的类是什么。import的作用是指示编译器导入一个“包”——或者说一个“类库”（在其他语言里，可将“库”想象成一系列函数、数据以及类的集合。但请记住，Java 的所有代码都必须写入一个类中）。
大多数时候，我们直接采用来自标准Java 库的组件（部件）即可，它们是与编译器配套提供的。使用这些组件时，没有必要关心冗长的保留域名；举个例子来说，只需象下面这样写一行代码即可：
import java.util.Vector;它的作用是告诉编译器我们想使用 Java 的Vector 类。然而，util 包含了数量众多的类，我们有时希望使用其中的几个，同时不想全部明确地声明它们。为达到这个目的，可使用“*”通配符。如下所示：
import java.util.*;
需导入一系列类时，采用的通常是这个办法。应尽量避免一个一个地导入类。
static 关键字：
一般地，当我们创建一个类时，你会描述这个类的对象的外观和行为，直到你用new关键字你才得到了一个对象，并且使存储空间得以分配而且方法也变得可用。
有两种情况下，这个方式并不满足。一个是如果你想仅仅有个存储空间来保存特别的数据，不管你创建了多少这个类的对象或甚至没有对象被创建。另一个是如果你需要一个方法，并且这个方法不与这个类的任何对象有关系。也就是说你需要一个方法你能够调用即使没有对象被创建。
你能通过static这个关键字去实现这两个效果。当你说某个东西是static，它意味着特定的域值或方法没有与特定的类的实例绑定。所以即使你没有创建一个类的实例你也能调用一个static 方法或访问一个static的域值。而在这之前，对于非 static数据和方法，我们必须创建一个对象，并用那个对象访问数据或方法。这是由于非static数据和方法必须知道它们操作的具体对象。当然，在正式使用前，由于static方法不需要创建任何对象，所以它们不可简单地调用其他的那些成员，同时不引用一个已命名的对象，从而直接访问非 static成员或方法（因为非static成员和方法必须同一个特定的对象关联到一起）。
有些面向对象语言使用“类数据”和类方法两个术语，这意味着数据和方法仅仅跟类这个整体有关系，与类的特定对象没关系。有时候java文章里会出现这些术语。
你能把关键字static放在定义前面就能简单的定义一个静态的域值或方法。比如：以下定义了一个静态的域并初始化：
class StaticTest {
Static int i = 47;
}
即使我们制作两个StaticTest对象，StaticTest.i对于仍然只有一个存储空间。这两个对象共享相同的变量i:
StaticTest st1 = new StaticTest(); StaticTest st2 = new StaticTest();这时，st1.i和st2.i有相同的值47，因为它们引用相同的内存区域。
有两个方法去引用一个static变量。如上面的例子，你能通过对象去访问它，如st2.i。你也能直接用类名去引用它，但直接用类是不能引用非静态成员的。
StaticTest.i++;这个++操作符是给变量加一。此时，无论 st1.i 还是st2.i 的值都是48。
引用静态变量最后使用类直接引用。不只是因为这样做更能反映变量的静态属性，而且这样能给编译器更好的优化机会。
类似的逻辑也适用于静态方法。既可象对其他任何方法那样通过一个对象引用静态方法，亦可用特殊的语法格式“类名.方法()”加以引用。静态方法的定义是类似的：
class StaticFun {
static void incr() { StaticTest.i++; }
}从中可看出，StaticFun 的方法 incr()使静态数据 i增值。通过对象，可用典型的方法调用incr()：
StaticFun sf = new StaticFun();
sf.incr();
或者，由于 incr()是一种静态方法，所以可通过它的类直接调用：
StaticFun.incr();
尽管是“静态”的，但只要应用于一个数据成员，就会明确改变数据的创建方式（一个类一个成员，以及每个对象一个非静态成员）。若应用于一个方法，就没有那么戏剧化了。对方法来说，static一项重要的用途就是帮助我们在不必创建对象的前提下调用那个方法。正如以后会看到的那样，这一点是至关重要的——特别是在定义程序运行入口方法main()的时候。
和其他任何方法一样，static方法也能创建自己类型的命名对象。所以经常把 static方法作为一个“领头羊”使用，用它生成一系列自己类型的“实例”。