java中的方法和类2.doc

第7章 进一步研究方法和类133第7章 进一步研究方法和类在本章中我们接着上一章继续研究方法和类。我们先研究几个有关方法的主题，包括方法重载、参数传递和递归。然后研究类，讨论存取控制，关键字static的用法，以及Java最重要的内置类之一：String。7.1 方 法 重 载在Java中，同一个类中的2个或2个以上的方法可以有同一个名字，只要它们的参数声明不同即可。在这种情况下，该方法就被称为重载（overloaded），这个过程称为方法重载（method overloading）。方法重载是Java实现多态性的一种方式。如果你以前从来没有使用过一种允许方法重载的语言，这个概念最初可能有点奇怪。但是你将看到，方法重载是Java最激动人心和最有用的特性之一。当一个重载方法被调用时，Java用参数的类型和（或）数量来表明实际调用的重载方法的版本。因此，每个重载方法的参数的类型和（或）数量必须是不同的。虽然每个重载方法可以有不同的返回类型，但返回类型并不足以区分所使用的是哪个方法。当Java调用一个重载方法时，参数与调用参数匹配的方法被执行。下面是一个说明方法重载的简单例子：/ Demonstrate method overloading.class OverloadDemo void test() System.out.println(No parameters); / Overload test for one integer parameter. void test(int a) System.out.println(a: + a); / Overload test for two integer parameters. void test(int a，int b) System.out.println(a and b: + a + + b); / overload test for a double parameter double test(double a) System.out.println(double a: + a);return a*a; class Overload public static void main(String args) OverloadDemo ob = new OverloadDemo();double result;/ call all versions of test()ob.test(); ob.test(10);ob.test(10，20);result = ob.test(123.25);System.out.println(Result of ob.test(123.25): + result); 该程序产生如下输出：No parametersa: 10a and b: 10 20double a: 123.25Result of ob.test(123.25): 15190.5625从上述程序可见，test()被重载了四次。第一个版本没有参数，第二个版本有一个整型参数，第三个版本有两个整型参数，第四个版本有一个double型参数。由于重载不受方法的返回类型的影响，test()第四个版本也返回了一个和重载没有因果关系的值Page: 110的值。当一个重载的方法被调用时，Java在调用方法的参数和方法的自变量之间寻找匹配。但是，这种匹配并不总是精确的。在一些情况下，Java的自动类型转换也适用于重载方法的自变量。例如，看下面的程序：/ Automatic type conversions apply to overloading.class OverloadDemo void test() System.out.println(No parameters); / Overload test for two integer parameters. void test(int a，int b) System.out.println(a and b: + a + + b); / overload test for a double parameter void test(double a) System.out.println(Inside test(double) a: + a); class Overload public static void main(String args) OverloadDemo ob = new OverloadDemo();int i = 88;ob.test(); ob.test(10，20);ob.test(i); / this will invoke test(double)ob.test(123.2); / this will invoke test(double) 该程序产生如下输出：No parametersa and b: 10 20Inside test(double) a: 88Inside test(double) a: 123.2在本例中，OverloadDemo 的这个版本没有定义test(int)。因此当在Overload内带整数参数调用test()时，找不到和它匹配的方法。但是，Java可以自动地将整数转换为double型，这种转换就可以解决这个问题。因此，在test(int)找不到以后，Java将i扩大到double型，然后调用test(double)。当然，如果定义了test(int)，当然先调用test(int)而不会调用test(double)。只有在找不到精确匹配时，Java的自动转换才会起作用。方法重载支持多态性，因为它是Java实现 “一个接口Page: 111接口 注：后同，多个方法”范型的一种方式。要理解这一点，考虑下面这段话：在不支持方法重载的语言中，每个方法必须有一个惟一的名字。但是，你经常希望实现数据类型不同但本质上相同的方法。可以参考绝对值函数的例子。在不支持重载的语言中，通常会含有这个函数的三个及三个以上的版本，每个版本都有一个差别甚微的名字。例如，在C语言中 ，函数abs( )返回整数的绝对值，labs( )返回long型整数的绝对值( )，而fabs( )返回浮点值的绝对值。尽管这三个函数的功能实质上是一样的，但是因为C语言不支持重载，每个函数都要有它自己的名字。这样就使得概念情况复杂许多。尽管每一个函数潜在的概念是相同的，你仍然不得不记住这三个名字。在Java中就不会发生这种情况，因为所有的绝对值函数可以使用同一个名字。确实,Java的标准的类库包含一个绝对值方法，叫做abs ( )。这个方法被Java的math类重载，用于处理数字类型。Java根据参数类型决定调用的abs()的版本。重载的价值在于它允许相关的方法可以使用同一个名字来访问。因此，abs这个名字代表了它执行的通用动作（general action）。为特定环境选择正确的指定（specific）版本是编译器要做的事情。作为程序员的你，只需要记住执行的通用操作就行了。通过多态性的应用，几个名字减少为一个。尽管这个例子相当简单，但如果你将这个概念扩展一下，你就会理解重载能够帮助你解决更复杂的问题。当你重载一个方法时,该方法的每个版本都能够执行你想要的任何动作。没有什么规定要求重载方法之间必须互相关联。但是，从风格上来说，方法重载还是暗示了一种关系。这就是当你能够使用同一个名字重载无关的方法时，你不应该这么做。例如，你可以使用sqr这个名字来创建一种方法，该方法返回一个整数的平方和一个浮点数值的平方根。但是这两种操作在功能上是不同的。按照这种方式应用方法就违背了它的初衷。在实际的编程中，你应该只重载相互之间关系紧密的操作。7.1.1 构造函数重载除了重载正常的方法外，构造函数也能够重载。实际上，对于大多数你创建的现实的类，重载构造函数是很常见的，并不是什么例外。为了理解为什么会这样，让我们回想上一章中举过的Box类例子。下面是最新版本的Box类的例子：class Box double width; double height; double depth; / This is the constructor for Box. Box(double w，double h，double d) width = w;height = h;depth = d; / compute and return volume double volume() return width * height * depth; 在本例中，Box()构造函数需要三个自变量，这意味着定义的所有Box对象必须给Box()构造函数传递三个参数。例如，下面的语句在当前情况下是无效的：Box ob = new Box();因为Box( )要求有三个参数，因此如果不带参数的调用它则是一个错误。这会引起一些重要的问题。如果你只想要一个盒子而不在乎 (或知道)它的原始的尺寸该怎么办？或，如果你想用仅仅一个值来初始化一个立方体，而该值可以被用作它的所有的三个尺寸又该怎么办？如果Box类是像现在这样写的，与此类似的其他问题你都没有办法解决，因为你只能带三个参数而没有别的选择权。幸好，解决这些问题的方案是相当容易的：重载Box构造函数，使它能处理刚才描述的情况。下面程序是Box的一个改进版本，它就是运用对Box构造函数的重载来解决这些问题的：/* Here，Box defines three constructors to initialize the dimensions of a box various ways.*/class Box double width; double height; double depth; / constructor used when all dimensions specified Box(double w，double h，double d) width = w;height = h;depth = d; / constructor used when no dimensions specified Box() width = -1; / use -1 to indicateheight = -1; / an uninitializeddepth = -1; / box / constructor used when cube is created Box(double len) width = height = depth = len; / compute and return volume double volume() return width * height * depth; class OverloadCons public static void main(String args) / create boxes using the various constructorsBox mybox1 = new Box(10，20，15);Box mybox2 = new Box();Box mycube = new Box(7);double vol;/ get volume of first boxvol = mybox1.volume();System.out.println(Volume of mybox1 is + vol);/ get volume of second boxvol = mybox2.volume();System.out.println(Volume of mybox2 is + vol);/ get volume of cubevol = mycube.volume();System.out.println(Volume of mycube is + vol); 该程序产生的输出如下所示：Volume of mybox1 is 3000.0Volume of mybox2 is -1.0Volume of mycube is 343.0在本例中，当new执行时，根据指定的自变量调用适当的构造函数。7.2 把对象作为参数到目前为止，我们都使用简单类型作为方法的参数。但是，给方法传递对象是正确的，也是常用的。例如，考虑下面的简单程序：/ Objects may be passed to methods.class Test int a，b; Test(int i，int j) a = i;b = j; / return true if o is equal to the invoking object boolean equals(Test o) if(o.a = a & o.b = b) return true;else return false; class PassOb public static void main(String args) Test ob1 = new Test(100，22);Test ob2 = new Test(100，22);Test ob3 = new Test(-1，-1);System.out.println(ob1 = ob2: + ob1.equals(ob2);System.out.println(ob1 = ob3: + ob1.equals(ob3); 该程序产生如下输出：ob1 = ob2: trueob1 = ob3: false在本程序中，在Test中的equals()方法比较两个对象的相等性，并返回比较的结果。也就是，它把调用的对象与被传递的对象作比较。如果它们包含相同的值，则该方法返回值为真，否则返回值为假。注意equals中的自变量o指定Test作为它的类型。尽管Test是程序中创建的类的类型，但是它的使用与Java的内置类型相同。对象参数的最普通的使用涉及到构造函数。你经常想要构造一个新对象，并且使它的初始状态与一些已经存在的对象一样。为了做到这一点，你必须定义一个构造函数，该构造函数将一个对象作为它的类的一个参数。例如，下面版本的Box允许一个对象初始化另外一个对象：/ Here，Box allows one object to initialize another.class Box double width; double height; double depth; / construct clone of an object Box(Box ob) / pass object to constructorwidth = ob.width;height = ob.height;depth = ob.depth; / constructor used when all dimensions specified Box(double w，double h，double d) width = w;height = h;depth = d; / constructor used when no dimensions specified Box() width = -1; / use -1 to indicateheight = -1; / an uninitializeddepth = -1; / box / constructor used when cube is created Box(double len) width = height = depth = len; / compute and return volume double volume() return width * height * depth; class OverloadCons2 public static void main(String args) / create boxes using the various constructorsBox mybox1 = new Box(10，20，15);Box mybox2 = new Box();Box mycube = new Box(7);Box myclone = new Box(mybox1);double vol;/ get volume of first boxvol = mybox1.volume();System.out.println(Volume of mybox1 is + vol);/ get volume of second boxvol = mybox2.volume();System.out.println(Volume of mybox2 is + vol);/ get volume of cubevol = mycube.volume();System.out.println(Volume of cube is + vol);/ get volume of clonevol = myclone.volume();System.out.println(Volume of clone is + vol); 在本程序中你能看到，当你开始创建你自己的类的时候，为了方便高效的构造对象，必须为同一构造函数方法提供多种形式。7.3 参数是如何传递的总的来说，计算机语言给子程序传递参数的方法有两种。第一种方法是按值传递（call-by-value）。这种方法将一个参数值（value）复制成为子程序的正式参数。这样，对子程序的参数的改变不影响调用它的参数。第二种传递参数的方法是引用调用（call-by-reference）。在这种方法中，参数的引用（而不是参数值）被传递给子程序参数。在子程序中，该引用用来访问调用中指定的实际参数。这样，对子程序参数的改变将会影响调用子程序的参数。你将看到，根据传递的对象不同，Java将使用这两种不同的方法。在Java中，当你给方法传递一个简单类型时，它是按值传递的。因此，接收参数的子程序参数的改变不会影响到该方法之外。例如，看下面的程序：/ Simple types are passed by value.class Test void meth(int i，int j) i *= 2;j /= 2; class CallByValue public static void main(String args) Test ob = new Test();int a = 15，b = 20;System.out.println(a and b before call: + a + + b);ob.meth(a，b); System.out.println(a and b after call: + a + + b); 该程序的输出如下所示：a and b before call: 15 20a and b after call: 15 20可以看出，在meth( )内部发生的操作不影响调用中a和b的值。它们的值没在本例中没有变为30和10。当你给方法传递一个对象时，这种情形就会发生戏剧性的变化，因为对象是通过引用传递的。记住，当你创建一个类类型的变量时，你仅仅创建了一个类的引用。因此，当你将这个引用传递给一个方法时，接收它的参数将会指向该参数指向的同一个对象。这有力地证明了对象是通过引用调用传递给方法的。该方法中对象的改变确实影响了作为参数的对象。例如，考虑下面的程序：/ Objects are passed by reference.class Test int a，b; Test(int i，int j) a = i;b = j; / pass an object void meth(Test o) o.a *= 2;o.b /= 2; class CallByRef public static void main(String args) Test ob = new Test(15，20);System.out.println(ob.a and ob.b before call: + ob.a + + ob.b);ob.meth(ob);System.out.println(ob.a and ob.b after call: + ob.a + + ob.b); 该程序产生下面的输出：ob.a and ob.b before call: 15 20ob.a and ob.b after call: 30 10正如你所看到的，在这个例子中，在 meth ( )中的操作影响了作为参数的对象。有趣的一点是，当一个对象引用被传递给方法时，引用本身使用按值调用被传递。但是，因为被传递的值指向一个对象，该值的拷贝仍然指向它相应的参数所指向的同一个对象。注意：当一个简单类型传递给一个方法时，使用按值传递。对象传递则按引用传。7.4 返 回 对 象方法能够返回任何类型的数据，包括你创建的类的类型。例如，在下面的程序中，incrByTen()方法返回一个对象，在该对象中的值a比调用对象中的值a大10。/ Returning an object.class Test int a; Test(int i) a = i; Test incrByTen() Test temp = new Test(a+10);return temp; class RetOb public static void main(String args) Test ob1 = new Test(2);Test ob2;ob2 = ob1.incrByTen();System.out.println(ob1.a: + ob1.a);System.out.println(ob2.a: + ob2.a);ob2 = ob2.incrByTen();System.out.println(ob2.a after second increase: + ob2.a); 该程序产生的输出如下所示：ob1.a: 2ob2.a: 12ob2.a after second increase: 22正如你看到的，每次调用incrByTen()，就产生一个新对象，同时将它的引用返回到调用子程序。上面的程序还有另外重要的一点:既然所有的对象用关键字new动态地分配内存，你不必担心一个对象会出范围，因为它被其创建的方法终止。只要你程序中有它的一个引用，该对象将会继续存在。当没有该对象的引用时，在下一次Page: 118垃圾回收垃圾回收发生时该对象将被回收。7.5 递 归Java支持递归（recursion）。递归就是依照自身定义事物的过程。在Java编程中，递归是允许方法调用自身调用的属性。调用自身的方法称为是递归的（recursive）。递归的典型例子是数字的阶乘。数字N的阶乘是1到N之间所有整数的乘积。例如3的阶乘就是1 23，或者是6。下面的程序使用递归来计算数字的阶乘。/ A simple example of recursion.class Factorial / this is a recursive function int fact(int n) int result;if(n=1) return 1;result = fact(n-1) * n;return result; class Recursion public static void main(String args) Factorial f = new Factorial();System.out.println(Factorial of 3 is + f.fact(3);System.out.println(Factorial of 4 is + f.fact(4);System.out.println(Factorial of 5 is + f.fact(5); 该程序产生的输出如下所示：Factorial of 3 is 6Factorial of 4 is 24Factorial of 5 is 120如果你对递归的方法比较陌生，那么fact( )的操作可能看起来似乎有点糊涂。它是这样工作的：当fact( )带着参数1被调用时，该方法返回1；否则它返回fact( n-1 )与n的乘积。为了对这个表达式求值，fact()带着参数n-1被调用。重复这个过程直到 n 等于 1，且对该方法的调用开始返回。为了更好地理解fact( )方法是如何工作的,让我们通过一个短例子来说明。例如当计算 3 的阶乘时，对fact()的第一次调用引起参数2的第二次调用。这个调用将引起fact以参数1的第三次调用，这个调用返回1，这个值接着与2（第二次调用时n的值）相乘。然后该结果（现为2）返回到fact()的最初的调用，并将该结果与3（n的初始值）相乘。这时得到答案，6。如果你在fact()中插入println()语句，显示每次调用的阶数以及中间结果，你会觉得很有意思。当一个方法调用它自身的时候，堆栈就会给新的局部变量和自变量分配内存，方法代码就带着这些新的变量从头执行。递归调用并不产生方法新的拷贝。只有参数是新的。每当递归调用返回时，旧的局部变量和自变量就从堆栈中清除，运行从方法中的调用点重新开始。递归方法可以说是像“望远镜”一样，可以自由伸缩。许多子程序的递归版本执行时会比它们的迭代版本要慢一点,因为它们增加了额外的方法调用的消耗。对一个方法太多的递归调用会引起堆栈崩溃。因为自变量和局部变量的存储都在堆栈中，每次调用都创建这些变量新的拷贝，堆栈有可能被耗尽。如果发生这种情况，Java的运行时系统就会产生异常。但是，除非递归子程序疯狂运行，否则你大概不会担心这种情况。递归的主要优点在于：某些类型的算法采用递归比采用迭代算法要更加清晰和简单。例如快速排序算法按照迭代方法是很难实现的。还有其他一些问题，特别是人工智能问题，就依赖于递归提供解决方案。最后，有些人认为递归要比迭代简单。当编写递归方法时，你必须使用if条件语句在递归调用不执行时来强制方法返回。如果你不这么做，一旦你调用方法，它将永远不会返回。这类错误在使用递归时是很常见的。尽量多地使用println()语句，使你可以了解程序的进程；如果发现错误，立即中止程序运行。下面是递归的又一个例子。递归的方法 printArray ( )打印数组values中的前i个元素。/ Another example that uses recursion.class RecTest int values; RecTest(int i) values = new inti; / display array recursively void printArray(int i) if(i=0) return;else printArray(i-1);System.out.println( + (i-1) + + valuesi-1); class Recursion2 public static void main(String args) RecTest ob = new RecTest(10);int i;for(i=0; i10; i+) ob.valuesi = i;ob.printArray(10); 该程序产生如下的输出：0 01 12 23 34 45 56 67 78 89 97.6 介绍访问控制我们知道，封装将数据和处理数据的代码连接起来。同时，封装也提供另一个重要属性：访问控制（access control）。通过封装你可以控制程序的哪一部分可以访问类的成员。通过控制访问，可以阻止对象的滥用。例如，通过只允许适当定义的一套方法来访问数据，你能阻止该数据的误用。因此，如果使用得当，可以把类创建一个“黑盒子”，虽然可以使用该类，但是它的内部机制是不公开的，不能修改。但是，本书前面创建的类可能不会完全适合这个目标。例如，考虑在第6章末尾示例的Stack类。方法push( )和pop()确实为堆栈提供一个可控制的接口，这是事实，但这个接口并没被强制执行。也就是说，程序的其他部分可以绕过这些方法而直接存取堆栈，这是可能的。当然，如果使用不当，这可能导致麻烦。本节将介绍能精确控制一个类各种各样成员的访问的机制。一个成员如何被访问取决于修改它的声明的访问指示符（access specifier）。Java提供一套丰富的访问指示符。存取控制的某些方面主要和继承或包联系在一起（包，package，本质上是一组类）。Java的这些访问控制机制将在以后讨论。现在，让我们从访问控制一个简单的类开始。一旦你理解了访问控制的基本原理，其他部分就比较容易了。Java的访问指示符有public（公共的，全局的）、private（私有的，局部的）、和protected（受保护的）。Java也定义了一个默认访问级别。指示符protected仅用于继承情况中。下面我们描述其他两个访问指示符。让我们从定义public和private开始。当一个类成员被public指示符修饰时，该成员可以被你的程序中的任何其他代码访问。当一个类成员被指定为private时，该成员只能被它的类中的其他成员访问。现在你能理解为什么main( )总是被public指示符修饰。它被在程序外面的代码调用，也就是由Java运行系统调用。如果不使用访问指示符，该类成员的默认访问设置为在它自己的包内为public，但是在它的包以外不能被存取（包将在以后的章节中讨论）。到目前为止，我们开发的类的所有成员都使用了默认访问模式，它实质上是public。然而，这并不是你想要的典型的方式。通常，你想要对类数据成员的访问加以限制，只允许通过方法来访问它。另外，有时你想把一个方法定义为类的一个私有的方法。访问指示符位于成员类型的其他说明的前面。也就是说，成员声明语句必须以访问指示符开头。下面是一个例子：public int i;private double j;private int myMethod(int a，char b) / .要理解public和private对访问的作用，看下面的程序：/* This program demonstrates the difference between public and private.*/class Test int a; / default access public int b; / public access private int c; / private access / methods to access c void setc(int i) / set cs valuec = i; int getc() / get cs valuereturn c; class AccessTest public static void main(String args) Test ob = new Test();/ These are OK，a and b may be accessed directlyob.a = 10;ob.b = 20;/ This is not OK and will cause an error/ ob.c = 100; / Error!/ You must access c through its methodsob.setc(100); / OKSystem.out.println(a，b，and c: + ob.a + + ob.b + + ob.getc(); 可以看出，在Test类中，a使用默认访问指示符，在本例中与public相同。b被显式地指定为public。成员c被指定为private，因此它不能被它的类之外的代码访问。所以，在AccessTest类中不能直接使用c。对它的访问只能通过它的public方法：setc()和getc()。如果你将下面语句开头的注释符号去掉，/ ob.c = 100; / Error!则由于违规，你不能编译这个程序。为了理解访问控制在实际中的应用，我们来看在第6章末尾所示的Stack类的改进版本。/ This class defines an integer stack that can hold 10 values.class Stack /* Now，both stck and tos are private. This meansthat they cannot be accidentally or maliciouslyaltered in a way that would be harmful to the stack. */ private int stck = new int10; private int tos; / Initialize top-of-stack Stack() tos = -1; / Push an item onto the stack void push(int item) if(tos=9) System.out.println(Stack is full.);else stck+tos = item; / Pop an item from the stack int pop() if(tos 0) System.out.println(Stack underflow.); return 0;else return stcktos-; 在本例中，现在存储堆栈的stck和指向堆栈顶部的下标tos，都被指定为private。这意味着除了通过push()或pop()，它们不能够被访问或改变。例如，将tos指定为private，阻止你程序的其他部分无意中将它的值设置为超过stck 数组下标界的值。下面的程序表明了改进的Stack类。试着删去注释前面的线条来证明stck和tos成员确实是不能访问的。class TestStack public static void main(String args) Stack mystack1 = new Stack();Stack mystack2 = new Stack();/ push some numbers onto the stackfor(int i=0; i10; i+) mystack1.push(i);for(int i=10; i20; i+) mystack2.push(i);/ pop those numbers off the stackSystem.out.println(Stack in mystack1:);for(int i=0; i10; i+) System.out.println(mystack1.pop();System.out.println(Stack in mystack2:);for(int i=0; i10; i+) System.out.println(mystack2.pop();/ these statements are not legal/ mystack1.tos = -2;/ mystack2.stck3 = 100; 尽管由类定义的方法通常提供对数据的访问，但情况并不总是这样。当需要时允许一个实例变量为public是完全合适的。例如,为简单起见，本书中大多数的简单类在创建时不关心实例变量的存取。然而，在大多数实际应用的类中，你将有必要仅仅允许通过方法来对数据操作。下一章将回到访问控制的话题。你将看到，在继承中访问控制是至关重要的。7.7 理解static有时你希望定义一个类成员，使它的使用完全独立于该类的任何对象。通常情况下，类成员必须通过它的类的对象访问，但是可以创建这样一个成员，它能够被它自己使用，而不必引用特定的实例。在成员的声明前面加上关键字static(静态的)就能创建这样的成员。如果一个成员被声明为static，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象。你可以将方法和变量都声明为static。static成员的最常见的例子是main( )。因为在程序开始执行时必须调用main()，所以它被声明为static。声明为static的变量实质上就是全局变量。当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。声明为static的方法有以下几条限制： 它们仅能调用其他的static方法。 它们只能访问static数据。 它们不能以任何方式引用this或super（关键字super与继承有关，在下一章中描述）。如果你需要通过计算来初始化你的static变量，你可以声明一个static块，Static块仅在该类被加载时执行一次。下面的例子显示的类有一个static方法，一些static变量，以及一个static初始化块：/ Demonstrate static variables，methods，and blocks.class UseStatic static int a = 3; static int b; static void meth(int x) System.out.println(x = + x);System.out.println(a = + a);System.out.println(b = + b); static System.out.println(Static block initialized.);b = a * 4; public static void main(String args) meth(42); 一旦UseStatic类被装载，所有的static语句被运行。首先，a被设置为3，接着static块执行(打印一条消息)，最后，b被初始化为a*4或12。然后调用main()，main()调用meth()，把值42传递给x。3个println ( )语句引用两个static变量a和b，以及局部变量x 。注意：在一个static方法中引用任何实例变量都是非法的。下面是该程序的输出：Static block initialized.x = 42a = 3b = 12在定义它们的类的外面，static方法和变量能独立于任何对象而被使用。这样，你只要在类的名字后面加点号运算符即可。例如，如果你希望从类外面调用一个static方法，你可以使用下面通用的格式：classname.method()这里，classname 是类的名字，在该类中定义static方法。可以看到，Page: 125颜色这种格式与通过对象引用变量调用非static方法的格式类似这种格式与通过对象引用变量调用非static方法的格式类似。一个static变