Java入门到精通--Java之类设计

本文主要介绍了Java入门到精通--Java之类设计 ,通过具体的内容向大家展现,希望对大家Java开发的学习有所帮助。多态普通的方法重载在Java中,同一个类中的2个或2个以上的方法可以有同一个名字,只要它们的参数声明不同即可。在这种情况。

本文主要介绍了Java入门到精通--Java之类设计 ,通过具体的内容向大家展现,希望对大家Java开发的学习有所帮助。

多态

普通的方法重载

在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. 如果不想让别人进入你们家,你就锁门;不像让别人看见你的表情,你就带墨镜;以及我们对别人的猜疑、竖起心灵的围墙;等等这些和面向对象的访问控制之间有什么相似的地方呢?

小结:

在本章中,我们主要学习了:

面向对象的多态等高级特征;

访问修饰符在java中的限定及使用;

Java入门到精通--Java之类设计文章到此结束,字数约19110字,希望可以帮助到大家。屹东网往后会继续推荐Java入门到精通--Java之类设计相关内容。