千合高薪教育培训机构吉林千合JAVA/网站定向就业培训/吉林电脑培训学校/长春电脑培训学校/电脑学校/长春培训/吉林培训/长春电脑培训/长春java培训/长春电脑学校/吉林电脑教育/长春电脑教育/it培训

2007-3-29

　类是Java的核心和本质。它是Java语言的基础，因为类定义了对象的本性。既然类是面向对象程序设计Java语言的基础，因此，你想要在Java程序中实现的每一个概念都必须封装在类以内。

　　从本书的开始我们就使用类了。当然，使用的都是非常简单的类。也许理解类的最重要的事情就是它定义了一种新的数据类型。一旦定义后，就可以用这种新类型来创建该类型的对象。这样，类就是对象的模板（template），而对象就是类的一个实例（instance）。既然一个对象就是一个类的实例，所以你经常看到object和instance这两个词可以互换使用。

　　6.1.1、类的通用格式

　　当你定义一个类时，你要声明它准确的格式和属性。你可以通过指定它包含的数据和操作数据的代码来定义类。尽管非常简单的类可能只包含代码或者只包含数据，但绝大多数实际的类都包含上述两者。你将看到，类的代码定义了该类数据的接口。

　　使用关键字class来创建类。在这一点上，类实际上被限制在它的完全格式中。类可以（并且常常）是一个组合体。类定义的通用格式如下所示：

　　　　class classname %26#123;
　　　　type instance-variable1;
　　　　type instance-variable2;
　　　　// ...
　　　　type instance-variableN;
　　　　type methodname1(parameter-list) %26#123;
　　　　// body of method
　　　　%26#125;
　　　　type methodname2(parameter-list) %26#123;
　　　　// body of method
　　　　%26#125;
　　　　// ...
　　　　type methodnameN(parameter-list) %26#123;
　　　　// body of method
　　　　%26#125;
　　　　%26#125;

　　在类中，数据或变量被称为实例变量（instance variables），代码包含在方法（methods）内。定义在类中的方法和实例变量被称为类的成员（members）。在大多数类中，实例变量被定义在该类中的方法操作和存取。这样，方法决定该类中的数据如何使用。

　　定义在类中的变量被称为实例变量，这是因为类中的每个实例(也就是类的每个对象)都包含它自己对这些变量的拷贝。这样，一个对象的数据是独立的且是惟一的。关于这一点我们将马上讨论，但是这是一个重要的概念，因此要早一点学习。

　　所有的方法和我们到目前为止用过的方法main()的形式一样。但是，以后讲到的方法将不仅仅是被指定为static或public。注意类的通用格式中并没有指定main()方法。Java类不需要main()方法。main()方法只是在定义您程序的起点时用到。而且，Java小应用程序也不要求main()方法。

　　注意：如果你有C++编程经验请注意，类的声明和方法的实现要存储在同一个地方并且不能被单独定义。由于所有类的定义必须全部定义在一个单个的源文件中，这有时会生成很大的.java文件。在Java中设计这个特征是因为从长远来说，在一个地方指明，定义以及实现将使代码更易于维护。

　　6.1.2、一个简单的类

　　让我们先从一个简单的例子来开始对类的研究。下面定义了一个名为box的类，它定义了3个实例变量：width，height和depth。当前，box类不包含任何方法（但是随后将增加一些）。

　　　　class Box %26#123; double width; double height; double depth;
　　　　%26#125;

　　前面已经说过，一个类定义一个新的数据类型。在本例中，新的数据类型名为Box。你可以使用这个名字来声明Box类型的对象。记住类声明只是创建一个模板（或类型描述），它并不会创建一个实际的对象。因此，上述代码不会生成任何Box类型的对象实体。

　　要真正创建一个Box对象，你必须使用下面的语句：

　　　　Box mybox = new Box(); // create a Box object called mybox

　　这个语句执行后，mybox就是Box的一个实例了。因此，它将具有“物理的”真实性。现在，先不必考虑这个语句的一些细节问题。

　　每次你创建类的一个实例时，你是在创建一个对象，该对象包含它自己的由类定义的每个实例变量的拷贝。因此，每个Box对象都将包含它自己的实例变量拷贝，这些变量即width，height，和depth。要访问这些变量，你要使用点号“.”运算符。点号运算符（dot operator）将对象名和成员名连接起来。例如，要将mybox的width变量赋值为100，使用下面的语句：

　　　　mybox.width = 100;

　　该语句告诉编译器对mybox对象内包含的width变量拷贝的值赋为100。通常情况下，你可以使用点号运算符来访问一个对象内的实例变量和方法。下面是使用Box类的完整程序：

　　　　/* A program that uses the Box class.
　　　　Call this file BoxDemo.java
　　　　*/
　　　　class Box %26#123;
　　　　double width; double height; double depth;
　　　　%26#125;
　　　　// This class declares an object of type Box.
　　　　class BoxDemo %26#123;
　　　　public static void main(String args[]) %26#123;
　　　　Box mybox = new Box();
　　　　double vol;
　　　　// assign values to mybox''s instance variables
　　　　mybox.width = 10;
　　　　mybox.height = 20;
　　　　mybox.depth = 15;
　　　　// compute volume of box
　　　　vol = mybox.width * mybox.height * mybox.depth;
　　　　System.out.println(%26quot;Volume is %26quot; + vol);
　　　　%26#125;
　　　　%26#125;

　　你应该把包含该程序的的文件命名为BoxDemo.java，因为main()方法在名为BoxDemo的类中，而不是名为Box的类中。当你编译这个程序时，你会发现生成了两个“.class”文件，一个属于box，另一个属于BoxDemo。Java编译器自动将每个类保存在它自己的“.class”文件中。没有必要分别将Box类和Boxdemo类放在同一个源文件中。你可以分别将它们放在各自的文件中，并分别命名为Box.Java和BoxDemo.java。

　　要运行这个程序，你必须执行BoxDemo.class。运行该程序后，你会看见如下输出：

　　　　Volume is 3000.0

　　前面已经讲过，每个对象都含有它自己的、由它的类定义的实例变量的拷贝。因此，假设你有两个Box对象，每个对象都有其自己的depth，width和height拷贝。改变一个对象的实例变量对另外一个对象的实例变量没有任何影响，理解这一点是很重要的。例如，下面的程序定义了两个Box对象：

　　　　// This program declares two Box objects.
　　　　class Box %26#123;
　　　　double width; double height;double depth;
　　　　%26#125;
　　　　class BoxDemo2 %26#123;
　　　　public static void main(String args[]) %26#123;
　　　　Box mybox1 = new Box();
　　　　Box mybox2 = new Box();
　　　　double vol;
　　　　// assign values to mybox1''s instance variables
　　　　mybox1.width = 10;
　　　　mybox1.height = 20;
　　　　mybox1.depth = 15;
　　　　/* assign different values to mybox2''s
　　　　instance variables */
　　　　mybox2.width = 3;
　　　　mybox2.height = 6;
　　　　mybox2.depth = 9;
　　　　// compute volume of first box
　　　　vol = mybox1.width * mybox1.height * mybox1.depth;
　　　　System.out.println(%26quot;Volume is %26quot; + vol);
　　　　// compute volume of second box
　　　　vol = mybox2.width * mybox2.height * mybox2.depth;
　　　　System.out.println(%26quot;Volume is %26quot; + vol);
　　　　%26#125;
　　　　%26#125;

　　该程序产生的输出如下所示：

　　　　Volume is 3000.0
　　　　Volume is 162.0

　　你可以看到，mybox1的数据与mybox2的数据完全分离。　类是Java的核心和本质。它是Java语言的基础，因为类定义了对象的本性。既然类是面向对象程序设计Java语言的基础，因此，你想要在Java程序中实现的每一个概念都必须封装在类以内。

　　从本书的开始我们就使用类了。当然，使用的都是非常简单的类。也许理解类的最重要的事情就是它定义了一种新的数据类型。一旦定义后，就可以用这种新类型来创建该类型的对象。这样，类就是对象的模板（template），而对象就是类的一个实例（instance）。既然一个对象就是一个类的实例，所以你经常看到object和instance这两个词可以互换使用。

　　6.1.1、类的通用格式

　　当你定义一个类时，你要声明它准确的格式和属性。你可以通过指定它包含的数据和操作数据的代码来定义类。尽管非常简单的类可能只包含代码或者只包含数据，但绝大多数实际的类都包含上述两者。你将看到，类的代码定义了该类数据的接口。

　　使用关键字class来创建类。在这一点上，类实际上被限制在它的完全格式中。类可以（并且常常）是一个组合体。类定义的通用格式如下所示：

　　　　class classname %26#123;
　　　　type instance-variable1;
　　　　type instance-variable2;
　　　　// ...
　　　　type instance-variableN;
　　　　type methodname1(parameter-list) %26#123;
　　　　// body of method
　　　　%26#125;
　　　　type methodname2(parameter-list) %26#123;
　　　　// body of method
　　　　%26#125;
　　　　// ...
　　　　type methodnameN(parameter-list) %26#123;
　　　　// body of method
　　　　%26#125;
　　　　%26#125;

　　在类中，数据或变量被称为实例变量（instance variables），代码包含在方法（methods）内。定义在类中的方法和实例变量被称为类的成员（members）。在大多数类中，实例变量被定义在该类中的方法操作和存取。这样，方法决定该类中的数据如何使用。

　　定义在类中的变量被称为实例变量，这是因为类中的每个实例(也就是类的每个对象)都包含它自己对这些变量的拷贝。这样，一个对象的数据是独立的且是惟一的。关于这一点我们将马上讨论，但是这是一个重要的概念，因此要早一点学习。

　　所有的方法和我们到目前为止用过的方法main()的形式一样。但是，以后讲到的方法将不仅仅是被指定为static或public。注意类的通用格式中并没有指定main()方法。Java类不需要main()方法。main()方法只是在定义您程序的起点时用到。而且，Java小应用程序也不要求main()方法。

　　注意：如果你有C++编程经验请注意，类的声明和方法的实现要存储在同一个地方并且不能被单独定义。由于所有类的定义必须全部定义在一个单个的源文件中，这有时会生成很大的.java文件。在Java中设计这个特征是因为从长远来说，在一个地方指明，定义以及实现将使代码更易于维护。

　　6.1.2、一个简单的类

　　让我们先从一个简单的例子来开始对类的研究。下面定义了一个名为box的类，它定义了3个实例变量：width，height和depth。当前，box类不包含任何方法（但是随后将增加一些）。

　　　　class Box %26#123; double width; double height; double depth;
　　　　%26#125;

　　前面已经说过，一个类定义一个新的数据类型。在本例中，新的数据类型名为Box。你可以使用这个名字来声明Box类型的对象。记住类声明只是创建一个模板（或类型描述），它并不会创建一个实际的对象。因此，上述代码不会生成任何Box类型的对象实体。

　　要真正创建一个Box对象，你必须使用下面的语句：

　　　　Box mybox = new Box(); // create a Box object called mybox

　　这个语句执行后，mybox就是Box的一个实例了。因此，它将具有“物理的”真实性。现在，先不必考虑这个语句的一些细节问题。

　　每次你创建类的一个实例时，你是在创建一个对象，该对象包含它自己的由类定义的每个实例变量的拷贝。因此，每个Box对象都将包含它自己的实例变量拷贝，这些变量即width，height，和depth。要访问这些变量，你要使用点号“.”运算符。点号运算符（dot operator）将对象名和成员名连接起来。例如，要将mybox的width变量赋值为100，使用下面的语句：

　　　　mybox.width = 100;

　　该语句告诉编译器对mybox对象内包含的width变量拷贝的值赋为100。通常情况下，你可以使用点号运算符来访问一个对象内的实例变量和方法。下面是使用Box类的完整程序：

　　　　/* A program that uses the Box class.
　　　　Call this file BoxDemo.java
　　　　*/
　　　　class Box %26#123;
　　　　double width; double height; double depth;
　　　　%26#125;
　　　　// This class declares an object of type Box.
　　　　class BoxDemo %26#123;
　　　　public static void main(String args[]) %26#123;
　　　　Box mybox = new Box();
　　　　double vol;
　　　　// assign values to mybox''s instance variables
　　　　mybox.width = 10;
　　　　mybox.height = 20;
　　　　mybox.depth = 15;
　　　　// compute volume of box
　　　　vol = mybox.width * mybox.height * mybox.depth;
　　　　System.out.println(%26quot;Volume is %26quot; + vol);
　　　　%26#125;
　　　　%26#125;

　　你应该把包含该程序的的文件命名为BoxDemo.java，因为main()方法在名为BoxDemo的类中，而不是名为Box的类中。当你编译这个程序时，你会发现生成了两个“.class”文件，一个属于box，另一个属于BoxDemo。Java编译器自动将每个类保存在它自己的“.class”文件中。没有必要分别将Box类和Boxdemo类放在同一个源文件中。你可以分别将它们放在各自的文件中，并分别命名为Box.Java和BoxDemo.java。

　　要运行这个程序，你必须执行BoxDemo.class。运行该程序后，你会看见如下输出：

　　　　Volume is 3000.0

　　前面已经讲过，每个对象都含有它自己的、由它的类定义的实例变量的拷贝。因此，假设你有两个Box对象，每个对象都有其自己的depth，width和height拷贝。改变一个对象的实例变量对另外一个对象的实例变量没有任何影响，理解这一点是很重要的。例如，下面的程序定义了两个Box对象：

　　　　// This program declares two Box objects.
　　　　class Box %26#123;
　　　　double width; double height;double depth;
　　　　%26#125;
　　　　class BoxDemo2 %26#123;
　　　　public static void main(String args[]) %26#123;
　　　　Box mybox1 = new Box();
　　　　Box mybox2 = new Box();
　　　　double vol;
　　　　// assign values to mybox1''s instance variables
　　　　mybox1.width = 10;
　　　　mybox1.height = 20;
　　　　mybox1.depth = 15;
　　　　/* assign different values to mybox2''s
　　　　instance variables */
　　　　mybox2.width = 3;
　　　　mybox2.height = 6;
　　　　mybox2.depth = 9;
　　　　// compute volume of first box
　　　　vol = mybox1.width * mybox1.height * mybox1.depth;
　　　　System.out.println(%26quot;Volume is %26quot; + vol);
　　　　// compute volume of second box
　　　　vol = mybox2.width * mybox2.height * mybox2.depth;
　　　　System.out.println(%26quot;Volume is %26quot; + vol);
　　　　%26#125;
　　　　%26#125;

　　该程序产生的输出如下所示：

　　　　Volume is 3000.0
　　　　Volume is 162.0

　　你可以看到，mybox1的数据与mybox2的数据完全分离。类是Java的核心和本质。它是Java语言的基础，因为类定义了对象的本性。既然类是面向对象程序设计Java语言的基础，因此，你想要在Java程序中实现的每一个概念都必须封装在类以内。

　　从本书的开始我们就使用类了。当然，使用的都是非常简单的类。也许理解类的最重要的事情就是它定义了一种新的数据类型。一旦定义后，就可以用这种新类型来创建该类型的对象。这样，类就是对象的模板（template），而对象就是类的一个实例（instance）。既然一个对象就是一个类的实例，所以你经常看到object和instance这两个词可以互换使用。

　　6.1.1、类的通用格式

　　当你定义一个类时，你要声明它准确的格式和属性。你可以通过指定它包含的数据和操作数据的代码来定义类。尽管非常简单的类可能只包含代码或者只包含数据，但绝大多数实际的类都包含上述两者。你将看到，类的代码定义了该类数据的接口。

　　使用关键字class来创建类。在这一点上，类实际上被限制在它的完全格式中。类可以（并且常常）是一个组合体。类定义的通用格式如下所示：

　　　　class classname %26#123;
　　　　type instance-variable1;
　　　　type instance-variable2;
　　　　// ...
　　　　type instance-variableN;
　　　　type methodname1(parameter-list) %26#123;
　　　　// body of method
　　　　%26#125;
　　　　type methodname2(parameter-list) %26#123;
　　　　// body of method
　　　　%26#125;
　　　　// ...
　　　　type methodnameN(parameter-list) %26#123;
　　　　// body of method
　　　　%26#125;
　　　　%26#125;

　　在类中，数据或变量被称为实例变量（instance variables），代码包含在方法（methods）内。定义在类中的方法和实例变量被称为类的成员（members）。在大多数类中，实例变量被定义在该类中的方法操作和存取。这样，方法决定该类中的数据如何使用。

　　定义在类中的变量被称为实例变量，这是因为类中的每个实例(也就是类的每个对象)都包含它自己对这些变量的拷贝。这样，一个对象的数据是独立的且是惟一的。关于这一点我们将马上讨论，但是这是一个重要的概念，因此要早一点学习。

　　所有的方法和我们到目前为止用过的方法main()的形式一样。但是，以后讲到的方法将不仅仅是被指定为static或public。注意类的通用格式中并没有指定main()方法。Java类不需要main()方法。main()方法只是在定义您程序的起点时用到。而且，Java小应用程序也不要求main()方法。

　　注意：如果你有C++编程经验请注意，类的声明和方法的实现要存储在同一个地方并且不能被单独定义。由于所有类的定义必须全部定义在一个单个的源文件中，这有时会生成很大的.java文件。在Java中设计这个特征是因为从长远来说，在一个地方指明，定义以及实现将使代码更易于维护。

　　6.1.2、一个简单的类

　　让我们先从一个简单的例子来开始对类的研究。下面定义了一个名为box的类，它定义了3个实例变量：width，height和depth。当前，box类不包含任何方法（但是随后将增加一些）。

　　　　class Box %26#123; double width; double height; double depth;
　　　　%26#125;

　　前面已经说过，一个类定义一个新的数据类型。在本例中，新的数据类型名为Box。你可以使用这个名字来声明Box类型的对象。记住类声明只是创建一个模板（或类型描述），它并不会创建一个实际的对象。因此，上述代码不会生成任何Box类型的对象实体。

　　要真正创建一个Box对象，你必须使用下面的语句：

　　　　Box mybox = new Box(); // create a Box object called mybox

　　这个语句执行后，mybox就是Box的一个实例了。因此，它将具有“物理的”真实性。现在，先不必考虑这个语句的一些细节问题。

　　每次你创建类的一个实例时，你是在创建一个对象，该对象包含它自己的由类定义的每个实例变量的拷贝。因此，每个Box对象都将包含它自己的实例变量拷贝，这些变量即width，height，和depth。要访问这些变量，你要使用点号“.”运算符。点号运算符（dot operator）将对象名和成员名连接起来。例如，要将mybox的width变量赋值为100，使用下面的语句：

　　　　mybox.width = 100;

　　该语句告诉编译器对mybox对象内包含的width变量拷贝的值赋为100。通常情况下，你可以使用点号运算符来访问一个对象内的实例变量和方法。下面是使用Box类的完整程序：

　　　　/* A program that uses the Box class.
　　　　Call this file BoxDemo.java
　　　　*/
　　　　class Box %26#123;
　　　　double width; double height; double depth;
　　　　%26#125;
　　　　// This class declares an object of type Box.
　　　　class BoxDemo %26#123;
　　　　public static void main(String args[]) %26#123;
　　　　Box mybox = new Box();
　　　　double vol;
　　　　// assign values to mybox''s instance variables
　　　　mybox.width = 10;
　　　　mybox.height = 20;
　　　　mybox.depth = 15;
　　　　// compute volume of box
　　　　vol = mybox.width * mybox.height * mybox.depth;
　　　　System.out.println(%26quot;Volume is %26quot; + vol);
　　　　%26#125;
　　　　%26#125;

　　你应该把包含该程序的的文件命名为BoxDemo.java，因为main()方法在名为BoxDemo的类中，而不是名为Box的类中。当你编译这个程序时，你会发现生成了两个“.class”文件，一个属于box，另一个属于BoxDemo。Java编译器自动将每个类保存在它自己的“.class”文件中。没有必要分别将Box类和Boxdemo类放在同一个源文件中。你可以分别将它们放在各自的文件中，并分别命名为Box.Java和BoxDemo.java。

　　要运行这个程序，你必须执行BoxDemo.class。运行该程序后，你会看见如下输出：

　　　　Volume is 3000.0

　　前面已经讲过，每个对象都含有它自己的、由它的类定义的实例变量的拷贝。因此，假设你有两个Box对象，每个对象都有其自己的depth，width和height拷贝。改变一个对象的实例变量对另外一个对象的实例变量没有任何影响，理解这一点是很重要的。例如，下面的程序定义了两个Box对象：

　　　　// This program declares two Box objects.
　　　　class Box %26#123;
　　　　double width; double height;double depth;
　　　　%26#125;
　　　　class BoxDemo2 %26#123;
　　　　public static void main(String args[]) %26#123;
　　　　Box mybox1 = new Box();
　　　　Box mybox2 = new Box();
　　　　double vol;
　　　　// assign values to mybox1''s instance variables
　　　　mybox1.width = 10;
　　　　mybox1.height = 20;
　　　　mybox1.depth = 15;
　　　　/* assign different values to mybox2''s
　　　　instance variables */
　　　　mybox2.width = 3;
　　　　mybox2.height = 6;
　　　　mybox2.depth = 9;
　　　　// compute volume of first box
　　　　vol = mybox1.width * mybox1.height * mybox1.depth;
　　　　System.out.println(%26quot;Volume is %26quot; + vol);
　　　　// compute volume of second box
　　　　vol = mybox2.width * mybox2.height * mybox2.depth;
　　　　System.out.println(%26quot;Volume is %26quot; + vol);
　　　　%26#125;
　　　　%26#125;

　　该程序产生的输出如下所示：

　　　　Volume is 3000.0
　　　　Volume is 162.0

　　你可以看到，mybox1的数据与mybox2的数据完全分离。

类是Java的核心和本质。它是Java语言的基础，因为类定义了对象的本性。既然类是面向对象程序设计Java语言的基础，因此，你想要在Java程序中实现的每一个概念都必须封装在类以内。

　　从本书的开始我们就使用类了。当然，使用的都是非常简单的类。也许理解类的最重要的事情就是它定义了一种新的数据类型。一旦定义后，就可以用这种新类型来创建该类型的对象。这样，类就是对象的模板（template），而对象就是类的一个实例（instance）。既然一个对象就是一个类的实例，所以你经常看到object和instance这两个词可以互换使用。

　　6.1.1、类的通用格式

　　当你定义一个类时，你要声明它准确的格式和属性。你可以通过指定它包含的数据和操作数据的代码来定义类。尽管非常简单的类可能只包含代码或者只包含数据，但绝大多数实际的类都包含上述两者。你将看到，类的代码定义了该类数据的接口。

　　使用关键字class来创建类。在这一点上，类实际上被限制在它的完全格式中。类可以（并且常常）是一个组合体。类定义的通用格式如下所示：

　　　　class classname %26#123;
　　　　type instance-variable1;
　　　　type instance-variable2;
　　　　// ...
　　　　type instance-variableN;
　　　　type methodname1(parameter-list) %26#123;
　　　　// body of method
　　　　%26#125;
　　　　type methodname2(parameter-list) %26#123;
　　　　// body of method
　　　　%26#125;
　　　　// ...
　　　　type methodnameN(parameter-list) %26#123;
　　　　// body of method
　　　　%26#125;
　　　　%26#125;

　　在类中，数据或变量被称为实例变量（instance variables），代码包含在方法（methods）内。定义在类中的方法和实例变量被称为类的成员（members）。在大多数类中，实例变量被定义在该类中的方法操作和存取。这样，方法决定该类中的数据如何使用。

　　定义在类中的变量被称为实例变量，这是因为类中的每个实例(也就是类的每个对象)都包含它自己对这些变量的拷贝。这样，一个对象的数据是独立的且是惟一的。关于这一点我们将马上讨论，但是这是一个重要的概念，因此要早一点学习。

　　所有的方法和我们到目前为止用过的方法main()的形式一样。但是，以后讲到的方法将不仅仅是被指定为static或public。注意类的通用格式中并没有指定main()方法。Java类不需要main()方法。main()方法只是在定义您程序的起点时用到。而且，Java小应用程序也不要求main()方法。

　　注意：如果你有C++编程经验请注意，类的声明和方法的实现要存储在同一个地方并且不能被单独定义。由于所有类的定义必须全部定义在一个单个的源文件中，这有时会生成很大的.java文件。在Java中设计这个特征是因为从长远来说，在一个地方指明，定义以及实现将使代码更易于维护。

　　6.1.2、一个简单的类

　　让我们先从一个简单的例子来开始对类的研究。下面定义了一个名为box的类，它定义了3个实例变量：width，height和depth。当前，box类不包含任何方法（但是随后将增加一些）。

　　　　class Box %26#123; double width; double height; double depth;
　　　　%26#125;

　　前面已经说过，一个类定义一个新的数据类型。在本例中，新的数据类型名为Box。你可以使用这个名字来声明Box类型的对象。记住类声明只是创建一个模板（或类型描述），它并不会创建一个实际的对象。因此，上述代码不会生成任何Box类型的对象实体。

　　要真正创建一个Box对象，你必须使用下面的语句：

　　　　Box mybox = new Box(); // create a Box object called mybox

　　这个语句执行后，mybox就是Box的一个实例了。因此，它将具有“物理的”真实性。现在，先不必考虑这个语句的一些细节问题。

　　每次你创建类的一个实例时，你是在创建一个对象，该对象包含它自己的由类定义的每个实例变量的拷贝。因此，每个Box对象都将包含它自己的实例变量拷贝，这些变量即width，height，和depth。要访问这些变量，你要使用点号“.”运算符。点号运算符（dot operator）将对象名和成员名连接起来。例如，要将mybox的width变量赋值为100，使用下面的语句：

　　　　mybox.width = 100;

　　该语句告诉编译器对mybox对象内包含的width变量拷贝的值赋为100。通常情况下，你可以使用点号运算符来访问一个对象内的实例变量和方法。下面是使用Box类的完整程序：

　　　　/* A program that uses the Box class.
　　　　Call this file BoxDemo.java
　　　　*/
　　　　class Box %26#123;
　　　　double width; double height; double depth;
　　　　%26#125;
　　　　// This class declares an object of type Box.
　　　　class BoxDemo %26#123;
　　　　public static void main(String args[]) %26#123;
　　　　Box mybox = new Box();
　　　　double vol;
　　　　// assign values to mybox''s instance variables
　　　　mybox.width = 10;
　　　　mybox.height = 20;
　　　　mybox.depth = 15;
　　　　// compute volume of box
　　　　vol = mybox.width * mybox.height * mybox.depth;
　　　　System.out.println(%26quot;Volume is %26quot; + vol);
　　　　%26#125;
　　　　%26#125;

　　你应该把包含该程序的的文件命名为BoxDemo.java，因为main()方法在名为BoxDemo的类中，而不是名为Box的类中。当你编译这个程序时，你会发现生成了两个“.class”文件，一个属于box，另一个属于BoxDemo。Java编译器自动将每个类保存在它自己的“.class”文件中。没有必要分别将Box类和Boxdemo类放在同一个源文件中。你可以分别将它们放在各自的文件中，并分别命名为Box.Java和BoxDemo.java。

　　要运行这个程序，你必须执行BoxDemo.class。运行该程序后，你会看见如下输出：

　　　　Volume is 3000.0

　　前面已经讲过，每个对象都含有它自己的、由它的类定义的实例变量的拷贝。因此，假设你有两个Box对象，每个对象都有其自己的depth，width和height拷贝。改变一个对象的实例变量对另外一个对象的实例变量没有任何影响，理解这一点是很重要的。例如，下面的程序定义了两个Box对象：

　　　　// This program declares two Box objects.
　　　　class Box %26#123;
　　　　double width; double height;double depth;
　　　　%26#125;
　　　　class BoxDemo2 %26#123;
　　　　public static void main(String args[]) %26#123;
　　　　Box mybox1 = new Box();
　　　　Box mybox2 = new Box();
　　　　double vol;
　　　　// assign values to mybox1''s instance variables
　　　　mybox1.width = 10;
　　　　mybox1.height = 20;
　　　　mybox1.depth = 15;
　　　　/* assign different values to mybox2''s
　　　　instance variables */
　　　　mybox2.width = 3;
　　　　mybox2.height = 6;
　　　　mybox2.depth = 9;
　　　　// compute volume of first box
　　　　vol = mybox1.width * mybox1.height * mybox1.depth;
　　　　System.out.println(%26quot;Volume is %26quot; + vol);
　　　　// compute volume of second box
　　　　vol = mybox2.width * mybox2.height * mybox2.depth;
　　　　System.out.println(%26quot;Volume is %26quot; + vol);
　　　　%26#125;
　　　　%26#125;

　　该程序产生的输出如下所示：

　　　　Volume is 3000.0
　　　　Volume is 162.0

　　你可以看到，mybox1的数据与mybox2的数据完全分离。

ava类基础