|
|
在Java中，同一个类中的2个或2个以上的方法可以有同一个名字，只要它们的参数声明不同即可。在这种情况下，该方法就被称为重载（overloaded），这个过程称为方法重载（method overloading）。方法重载是Java实现多态性的一种方式。如果你以前从来没有使用过一种允许方法重载的语言，这个概念最初可能有点奇怪。但是你将看到，方法重载是Java最激动人心和最有用的特性之一。
当一个重载方法被调用时，Java用参数的类型和（或）数量来表明实际调用的重载方法的版本。因此，每个重载方法的参数的类型和（或）数量必须是不同的。虽然每个重载方法可以有不同的返回类型，但返回类型并不足以区分所使用的是哪个方法。当Java调用一个重载方法时，参数与调用参数匹配的方法被执行。
下面是一个说明方法重载的简单例子：
// Demonstrate method overloading.
class OverloadDemo {
void test(){
System.out.println("No parameters");
}
// Overloadtest for one integer parameter.
voidtest(int a) {
System.out.println("a: " + a);
}
// Overloadtest for two integer parameters.
voidtest(int a，int b) {
System.out.println("a and b: " + a +" " + b);
}
// overloadtest for a double parameter
doubletest(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 parameters
a: 10
a and b: 10 20
double a: 123.25
Result of ob.test(123.25): 15190.5625
从上述程序可见，test()被重载了四次。第一个版本没有参数，第二个版本有一个整型参数，第三个版本有两个整型参数，第四个版本有一个double型参数。由于重载不受方法的返回类型的影响，test()第四个版本也返回了一个和重载没有因果关系的值。
当一个重载的方法被调用时，Java在调用方法的参数和方法的自变量之间寻找匹配。
但是，这种匹配并不总是精确的。在一些情况下，Java的自动类型转换也适用于重载方法的自变量。例如，看下面的程序：
// Automatic type conversions apply to overloading.
class OverloadDemo {
void test(){
System.out.println("No parameters");
}
// Overloadtest for two integer parameters.
voidtest(int a，int b) {
System.out.println("a and b: " + a +" " + b);
}
// overloadtest for a double parameter
voidtest(double a) {
System.out.println("Inside test(double) a:" + a);
}
}
class Overload {
publicstatic 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 parameters
a and b: 10 20
Inside test(double) a: 88
Inside 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实现 “一个接口，多个方法”范型的一种方式。
要理解这一点，考虑下面这段话：在不支持方法重载的语言中，每个方法必须有一个惟一的名字。但是，你经常希望实现数据类型不同但本质上相同的方法。可以参考绝对值函数的例子。在不支持重载的语言中，通常会含有这个函数的三个及三个以上的版本，每个版本都有一个差别甚微的名字。例如，在C语言中 ，函数abs( )返回整数的绝对值，labs()返回long型整数的绝对值( )，而fabs( )返回浮点值的绝对值。尽管这三个函数的功能实质上是一样的，但是因为C语言不支持重载，每个函数都要有它自己的名字。这样就使得概念情况复杂许多。尽管每一个函数潜在的概念是相同的，你仍然不得不记住这三个名字。在Java中就不会发生这种情况，因为所有的绝对值函数可以使用同一个名字。确实,Java的标准的类库包含一个绝对值方法，叫做abs
( )。这个方法被Java的math类重载，用于处理数字类型。Java根据参数类型决定调用的abs()的版本。
重载的价值在于它允许相关的方法可以使用同一个名字来访问。因此，abs这个名字代表了它执行的通用动作（general action）。为特定环境选择正确的指定（specific）版本是编译器要做的事情。作为程序员的你，只需要记住执行的通用操作就行了。通过多态性的应用，几个名字减少为一个。尽管这个例子相当简单，但如果你将这个概念扩展一下，你就会理解重载能够帮助你解决更复杂的问题。
当你重载一个方法时,该方法的每个版本都能够执行你想要的任何动作。没有什么规定要求重载方法之间必须互相关联。但是，从风格上来说，方法重载还是暗示了一种关系。这就是当你能够使用同一个名字重载无关的方法时，你不应该这么做。例如，你可以使用sqr这个名字来创建一种方法，该方法返回一个整数的平方和一个浮点数值的平方根。但是这两种操作在功能上是不同的。按照这种方式应用方法就违背了它的初衷。在实际的编程中，你应该只重载相互之间关系紧密的操作。
|
除了重载正常的方法外，构造函数也能够重载。实际上，对于大多数你创建的现实的类，重载构造函数是很常见的，并不是什么例外。为了理解为什么会这样，让我们回想上一章中举过的Box类例子。下面是最新版本的Box类的例子：
class Box {
doublewidth;
doubleheight;
doubledepth;
// This isthe constructor for Box.
Box(double w，double h，doubled) {
width = w;
height = h;
depth = d;
}
// computeand return volume
doublevolume() {
return width * height * depth;
}
}
在本例中，Box()构造函数需要三个自变量，这意味着定义的所有Box对象必须给Box()构造函数传递三个参数。例如，下面的语句在当前情况下是无效的：
Box ob = new Box();
因为Box( )要求有三个参数，因此如果不带参数的调用它则是一个错误。这会引起一些重要的问题。如果你只想要一个盒子而不在乎 (或知道)它的原始的尺寸该怎么办？或，如果你想用仅仅一个值来初始化一个立方体，而该值可以被用作它的所有的三个尺寸又该怎么办？如果Box类是像现在这样写的，与此类似的其他问题你都没有办法解决，因为你只能带三个参数而没有别的选择权。
幸好，解决这些问题的方案是相当容易的：重载Box构造函数，使它能处理刚才描述的情况。下面程序是Box的一个改进版本，它就是运用对Box构造函数的重载来解决这些问题的：
/* Here，Box defines three constructors to initialize
thedimensions of a box various ways.
*/
class Box {
doublewidth;
doubleheight;
doubledepth;
//constructor used when all dimensions specified
Box(double w，double h，doubled) {
width = w;
height = h;
depth = d;
}
//constructor used when no dimensions specified
Box() {
width = -1; // use -1 to indicate
height = -1; // an uninitialized
depth = -1; // box
}
//constructor used when cube is created
Box(doublelen) {
width = height = depth = len;
}
// computeand return volume
double volume() {
return width * height * depth;
}
}
class OverloadCons {
publicstatic void main(String args[]) {
// create boxes using the various constructors
Box mybox1 = new Box(10，20，15);
Box mybox2 = new Box();
Box mycube = new Box(7);
double vol;
// get volume of first box
vol = mybox1.volume();
System.out.println("Volume of mybox1 is "+ vol);
// get volume of second box
vol = mybox2.volume();
System.out.println("Volume of mybox2 is "+ vol);
// get volume of cube
vol = mycube.volume();
System.out.println("Volume of mycube is "+ vol);
}
}
该程序产生的输出如下所示：
Volume of mybox1 is 3000.0
Volume of mybox2 is -1.0
Volume of mycube is 343.0
在本例中，当new执行时，根据指定的自变量调用适当的构造函数。
|
到目前为止，我们都使用简单类型作为方法的参数。但是，给方法传递对象是正确的，也是常用的。例如，考虑下面的简单程序：
// Objects may be passed to methods.
class Test {
int a，b;
Test(int i，int j) {
a = i;
b = j;
}
// returntrue if o is equal to the invoking object
booleanequals(Test o) {
if(o.a == a && o.b == b)
return true;
else
returnfalse;
}
}
class PassOb {
publicstatic 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: true
ob1 == ob3: false
在本程序中，在Test中的equals()方法比较两个对象的相等性，并返回比较的结果。也就是，它把调用的对象与被传递的对象作比较。如果它们包含相同的值，则该方法返回值为真，否则返回值为假。注意equals中的自变量o指定Test作为它的类型。尽管Test是程序中创建的类的类型，但是它的使用与Java的内置类型相同。
对象参数的最普通的使用涉及到构造函数。你经常想要构造一个新对象，并且使它的初始状态与一些已经存在的对象一样。为了做到这一点，你必须定义一个构造函数，该构造函数将一个对象作为它的类的一个参数。例如，下面版本的Box允许一个对象初始化另外一个对象：
// Here，Box allows one object to initialize another.
class Box {
double width;
doubleheight;
doubledepth;
//construct clone of an object
Box(Box ob){ // pass object to constructor
width = ob.width;
height = ob.height;
depth = ob.depth;
}
// constructor used when all dimensions specified
Box(double w，double h，doubled) {
width = w;
height = h;
depth = d;
}
//constructor used when no dimensions specified
Box() {
width = -1; // use -1 to indicate
height = -1; // an uninitialized
depth = -1; // box
}
//constructor used when cube is created
Box(doublelen) {
width = height = depth = len;
}
// computeand return volume
doublevolume() {
return width * height * depth;
}
}
class OverloadCons2 {
publicstatic void main(String args[]) {
// create boxes using the various constructors
Box 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 box
vol = mybox1.volume();
System.out.println("Volume of mybox1 is "+ vol);
// get volume of second box
vol = mybox2.volume();
System.out.println("Volume of mybox2 is "+ vol);
// get volume of cube
vol = mycube.volume();
System.out.println("Volume of cube is " +vol);
// get volume of clone
vol = myclone.volume();
System.out.println("Volume of clone is "+ vol);
}
}
在本程序中你能看到，当你开始创建你自己的类的时候，为了方便高效的构造对象，必须为同一构造函数方法提供多种形式。
|
总的来说，计算机语言给子程序传递参数的方法有两种。第一种方法是按值传递（call-by-value）。这种方法将一个参数值（value）复制成为子程序的正式参数。这样，对子程序的参数的改变不影响调用它的参数。第二种传递参数的方法是引用调用（call-by-reference）。在这种方法中，参数的引用（而不是参数值）被传递给子程序参数。
在子程序中，该引用用来访问调用中指定的实际参数。这样，对子程序参数的改变将会影响调用子程序的参数。你将看到，根据传递的对象不同，Java将使用这两种不同的方法。
在Java中，当你给方法传递一个简单类型时，它是按值传递的。因此，接收参数的子程序参数的改变不会影响到该方法之外。例如，看下面的程序：
// Simple types are passed by value.
class Test {
voidmeth(int i，int j) {
i *= 2;
j /= 2;
}
}
class CallByValue {
publicstatic 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 20
a 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 anobject
voidmeth(Test o) {
o.a *= 2;
o.b /= 2;
}
}
class CallByRef {
publicstatic 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 20
ob.a and ob.b after call: 30 10
正如你所看到的，在这个例子中，在 meth ( )中的操作影响了作为参数的对象。
有趣的一点是，当一个对象引用被传递给方法时，引用本身使用按值调用被传递。但是，因为被传递的值指向一个对象，该值的拷贝仍然指向它相应的参数所指向的同一个对象。
注意：当一个简单类型传递给一个方法时，使用按值传递。对象传递则按引用传递。
|
方法能够返回任何类型的数据，包括你创建的类的类型。例如，在下面的程序中， incrByTen()方法返回一个对象，在该对象中的值a比调用对象中的值a大10。
// Returning an object.
class Test {
int a;
Test(int i){
a = i;
}
TestincrByTen() {
Test temp = new Test(a+10);
return temp;
}
}
class RetOb {
publicstatic 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 secondincrease: "
+ ob2.a);
}
}
该程序产生的输出如下所示：
ob1.a: 2
ob2.a: 12
ob2.a after second increase: 22
正如你看到的，每次调用incrByTen()，就产生一个新对象，同时将它的引用返回到调用子程序。
上面的程序还有另外重要的一点:既然所有的对象用关键字new动态地分配内存，你不必担心一个对象会出范围，因为它被其创建的方法终止。只要你程序中有它的一个引用，该对象将会继续存在。当没有该对象的引用时，在下一次垃圾回收发生时该对象将被回收。
|
Java支持递归（recursion）。递归就是依照自身定义事物的过程。在Java编程中，递归是允许方法调用自身调用的属性。调用自身的方法称为是递归的（recursive）。
递归的典型例子是数字的阶乘。数字N的阶乘是1到N之间所有整数的乘积。例如3的阶乘就是1× 2×3，或者是6。下面的程序使用递归来计算数字的阶乘。
// A simple example of recursion.
class Factorial {
// this isa recursive function
intfact(int n) {
int result;
if(n==1) return 1;
result = fact(n-1) * n;
return result;
}
}
class Recursion {
publicstatic 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 6
Factorial of 4 is 24
Factorial 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 {
intvalues[];
RecTest(inti) {
values = new int[i];
}
// displayarray – recursively
voidprintArray(int i) {
if(i==0) return;
else printArray(i-1);
System.out.println("[" + (i-1) + "]" + values[i-1]);
}
}
class Recursion2 {
publicstatic void main(String args[]) {
RecTest ob = new RecTest(10);
int i;
for(i=0; i<10; i++) ob.values[i] = i;
ob.printArray(10);
}
}
该程序产生如下的输出：
[0] 0
[1] 1
[2] 2
[3] 3
[4] 4
[5] 5
[6] 6
[7] 7
[8] 8
[9] 9
|
|
我们知道，封装将数据和处理数据的代码连接起来。同时，封装也提供另一个重要属性：访问控制（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 andprivate.
*/
class Test {
int a; //default access
public intb; // public access
private intc; // private access
// methodsto access c
voidsetc(int i) { // set c‘s value
c = i;
}
int getc(){ // get c‘s value
return c;
}
}
class AccessTest {
publicstatic void main(String args[]) {
Test ob = new Test();
// These are OK，a and b may be accessed directly
ob.a = 10;
ob.b = 20;
// This is not OK and will cause an error
// ob.c =100; // Error!
// You must access c through its methods
ob.setc(100); // OK
System.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 canhold 10 values.
class Stack {
/* Now，both stck and tos are private. Thismeans
that they cannot be accidentally or maliciously
altered in a way that would be harmful to thestack.
*/
private intstck[] = new int[10];
private inttos;
//Initialize top-of-stack
Stack() {
tos = -1;
}
// Push anitem onto the stack
voidpush(int item) {
if(tos==9)
System.out.println("Stack is full.");
else
stck[++tos]= item;
}
// Pop anitem from the stack
int pop() {
if(tos < 0) {
System.out.println("Stack underflow.");
return 0;
}
else
returnstck[tos--];
}
}
在本例中，现在存储堆栈的stck和指向堆栈顶部的下标tos，都被指定为private。这意味着除了通过push()或pop()，它们不能够被访问或改变。例如，将tos指定为private，阻止你程序的其他部分无意中将它的值设置为超过stck 数组下标界的值。
下面的程序表明了改进的Stack类。试着删去注释前面的线条来证明stck和tos成员确实是不能访问的。
class TestStack {
publicstatic void main(String args[]) {
Stack mystack1 = new Stack();
Stack mystack2 = new Stack();
// push some numbers onto the stack
for(int i=0; i<10; i++) mystack1.push(i);
for(int i=10; i<20; i++) mystack2.push(i);
// pop those numbers off the stack
System.out.println("Stack in mystack1:");
for(int i=0; i<10; i++)
System.out.println(mystack1.pop());
System.out.println("Stack in mystack2:");
for(int i=0; i<10; i++)
System.out.println(mystack2.pop());
// these statements are not legal
// mystack1.tos = -2;
// mystack2.stck[3] = 100;
}
}
尽管由类定义的方法通常提供对数据的访问，但情况并不总是这样。当需要时允许一个实例变量为public是完全合适的。例如,为简单起见，本书中大多数的简单类在创建时不关心实例变量的存取。然而，在大多数实际应用的类中，你将有必要仅仅允许通过方法来对数据操作。下一章将回到访问控制的话题。你将看到，在继承中访问控制是至关重要的。
|
1. 思考现实生活中，我们有没有从其他人那里学到些技术或知识，这是不是多态呢？
2. 如果不想让别人进入你们家，你就锁门；不像让别人看见你的表情，你就带墨镜；以及我们对别人的猜疑、竖起心灵的围墙；等等这些和面向对象的访问控制之间有什么相似的地方呢？
|
在本章中，我们主要学习了：
u 面向对象的多态等高级特征；
u 访问修饰符在java中的限定及使用；
|
英文 全文 中文
Overloaded Overloaded 重载
Recursion Recursion 递归
Public Public 公共的，全局的
Private Private 私有的，局部的
Protected Protected 受保护的
|
你父亲是一个地道的中国农民，只会种地干粗活，没有动过电脑；但是你虽然是你父亲的儿子，具备了宽容、善良、勤劳的美德；但你却会熟练地使用电脑，而且还是地道的软件工程师；然而你有时候又不听你父亲的话，和他有心灵的隔阂；试着用本节学到的面向对象的知识，用程序模拟实现这些特征；