类的封装继承与多态Word格式.docx
《类的封装继承与多态Word格式.docx》由会员分享，可在线阅读，更多相关《类的封装继承与多态Word格式.docx（22页珍藏版）》请在冰点文库上搜索。
p1obj=newp1（）;
obj.set_x（3）;
//通过调用类的公有方法给公有变量赋值
obj.show_x（）;
//通过调用类的公有方法显示公有变量的值
obj.x=18;
//直接给obj对象的公有变量赋值
System.out.println（"
+obj.x）;
//直接输出公有变量的值
程序输出结果如图7-1所示：
图7-1程序运行结果
2.私有的（private）
用private修饰的类成员称为私有的，类的私有成员只能被这个类的方法直接访问。
如果在例7-1中将x声明为私有的，则会出现编译错误，即obj.x=18这个语句出错，因为私有变量不能在类外直接访问，只能通过obj对象的公有方法访问x。
一般把不需要外界知道的数据说明为私有，这样有利于数据的安全性，也符合程序设计中隐藏内部信息处理细节的原则。
3.被保护的（protected）
用protected修饰的类成员成为被保护的。
类的被保护成员允许其归属的类、由此类派生的子类以及同一个包中的其他类访问。
如果一个类有派生子类，为了使子类能够直接访问父类的成员，则把这些成员（大部分是数据）说明为被保护的。
【例7-2】访问类的被保护成员
MyDemoClass.java
classParentClass
{protectedintn=3;
protectedvoidshow_n（）
n="
+n）;
classMyDemoClassextendsParentClass
MyClassobj=newMyClass（）;
obj.show_n（）;
//在MyClass类中直接访问父类中被保护的方法
obj.n=18;
//直接访问父类中被保护的数据
程序的运行结果如图7-2所示：
图7-2程序运行结果
4.默认的
如果类成员前面没有任何关键字修饰，则称为默认的。
默认的类成员除了允许被其归属的类访问外，还允许同一个包中的其他类访问。
若两个类不在同一个包中，即使是这个类的子类，也不允许访问这个类的默认成员。
如果将例7-1中的变量x前面的public关键字去掉，则成为默认类型的变量，程序运行结果不变。
如果将例7-2中的变量x前面的protected关键字去掉,则运行结果同样不变。
对类成员的4种访问权限总结在表7-1中。
表7-1类成员的访问权限
同一个类
同一个包
不同包中的子类
其他包
public
√
protected
默认的
private
7.2继承
7.2.1继承的概念
继承是一种由已有类创建新类的机制。
利用继承，我们可以先创建一个共有属性的一般类，根据该一般类再创建具有特殊属性的新类。
新类继承一般类的状态和行为，并根据需要增加它自己的状态和行为。
从现有类出发定义一个新类，称为新类继承了现有的类，其中被继承的现有类叫做超类（superclass）或父类，由继承而得到的类称为子类（subclass）。
例如，当类sub1继承类super时，就表明sub1是super的子类，即super是sub1的超类（父类）。
子类从超类继承变量和方法，从而可以共享数据和方法。
sub1类由两部分组成：
继承部分和增加部分。
继承部分是从super继承过来的，把super的成员映射成sub1的继承成员；
增加部分是专为sub1编写的代码，如图7-3所示。
图7-3继承性
在Java中规定，一个父类可以同时拥有多个子类，但一个子类只能有一个父类，即单重继承，而且允许多层继承，即子类还可以有它自己的子类，在下一层的继承关系中原先的子类就变成了父类。
这样的继承关系就形成了继承树。
7.2.2类继承的实现
类继承用关键字extends实现，格式为：
class子类名extends父类名
{子类的类体}
如果没有extends子句，则这个类直接继承Object。
【例7-3】类继承和传递性
设计思路：
设计三个类A、B、C，A类中定义多个成员变量和方法，B类继承A类，C类继承B类，并且在B类中增加新的成员变量，在C类中增加新的成员变量。
分别创建三个类的对象，在B、C类对象中访问父类的成员变量，观察继承的传递性。
代码：
//filename:
MyClass.java
classA
{
inta1=1;
publicinta2=2;
protectedinta3=3;
privateinta4=4;
intgeta4（）
{returna4;
classBextendsA
intb=5;
//添加新的数据成员b，同时B类还有从A类继承过来的数据成员
//a1,a2,a3和成员方法geta4（）
classCextendsB
intc=6;
//添加新的数据成员c
voidchange（）//添加新的方法change（）
{
a1+=10;
a2+=10;
a3+=10;
b+=10;
c+=10;
}
classMyClass
Aaa=newA（）;
System.out.println（"
A：
"
+aa.a1+"
"
+aa.a2+"
+aa.a3+"
+aa.geta4（））;
Bbb=newB（）;
B：
+bb.a1+"
+bb.a2+"
+bb.a3+"
+bb.geta4（）
+"
+bb.b）;
Ccc=newC（）;
C：
+cc.a1+"
+cc.a2+"
+cc.a3+"
+cc.geta4（）+
"
+cc.b+"
+cc.c）;
cc.change（）;
+cc.geta4（）
}
请读者自己写出输出结果。
此例中A、B、C3个类的层次关系如图7-4所示。
图7-4类继承的层次关系
7.2.3成员变量的继承
子类继承父类中所有可被子类访问的成员变量。
继承原则如下：
1．能够继承那些声明为public和protected的成员变量。
2．能够继承同一包中的那些默认修饰符的成员变量。
3．不能继承那些声明为private的成员变量。
4．如果子类声明一个与父类成员变量同名的成员变量，则不能继承父类的成员变量。
此时子类的成员变量称做隐藏了父类的成员变量。
总之，子类可继承父类的public、protected和默认修饰变量，不能继承private变量。
反之，如果父类不允许其子类访问它的某些成员，那么它必须以private方式声明该成员。
这一点充分体现了类封装的信息隐蔽原则。
【例7-4】子类继承父类的成员变量。
设Person类定义抽象“人”具有的特征和行为包括姓名、年龄。
Student类定义学生这群人的特征和行为，包括姓名、年龄、系别等。
分别设计Person类与student类。
publicclassPerson
{
Stringname;
//姓名
intage;
//年龄
classStudent
intage;
Stringdept;
//系别
这样的定义其中有大量的重复。
利用继承的原则，将Student类定义为Person类的子类。
程序如下：
publicclassPerson
Stringname;
classStudentextendsPerson//Student是Person类的子类
Stringdept;
}
此时Student共有3个成员变量，从Person类中继承了两个成员变量name和age，自己增加了成员dept。
7.2.4成员方法的继承
子类继承成员方法的规则类似于继承成员变量的规则：
子类继承父类中所有可被子类访问的成员方法。
继承规则如下：
1．能够继承那些声明为public和protected的成员方法。
2．能够继承同一包中的默认修饰符的成员方法。
3．不能继承那些声明为private的成员方法。
4．不能继承父类的构造方法。
如果子类方法与父类方法同名，则不能继承。
子类方法称为覆盖了父类中的那个方法。
总之，子类可继承其父类的public、protected和默认修饰方法，不能继承private方法。
子类除了可以继承父类中的变量及方法，还可以增加自己的成员。
当一个父类成员不适合该子类时，子类会重新定义它，如果是重新定义的是成员变量就是隐藏父类的变量，如果是成员方法就是覆盖父类的方法。
【例7-5】子类继承超类的成员方法。
重新设计Person类及其子类Student1。
Person类中声明了两个保护变量name、age及两个方法：
setdata用于赋初值，print用于打印成员变量的值。
Student1类继承Person类，增加了自己的成员变量dept。
Student1.java
publicclassPerson
protectedStringname;
//保护成员
protectedintage;
voidsetdata（Stringn1,inta1）
name=n1;
age=a1;
publicvoidprint（）
System.out.println（name+"
"
+age）;
classStudent1extendsPerson
protectedStringdept;
Personp1=newPerson（）;
p1.setdata（"
张军"
21）;
p1.print（）;
Student1s1=newStudent1（）;
s1.setdata（"
陈丽华"
20）;
//调用父类的成员方法
s1.dept="
计算机系"
;
//访问本类的成员变量
s1.print（）;
程序的运行结果如图7-5所示：
图7-5程序运行结果
在该程序中，语句：
p1.setdata（“张军”，21）；
表示父类Person对象p1通过调用本类方法为p1的成员变量name、age赋值。
而Student1子类继承了其父类Person的成员变量name、age及方法setdata、print，语句：
s1.setdata（“陈丽华”,19）;
表示子类对象s1通过调用继承来的setdata方法，为s1的成员变量name、age赋值。
在Student1子类中虽然增加了成员变量dept，但在使用中仍然存在问题，不够圆满：
1.调用s1.setdate（）只能为超类中成员赋值,却无法为子类成员dept赋值。
这是因为s1所调用的setdate和print方法是由超类定义的，其中没有对dept的操作。
改进的方法是使用构造方法。
2.调用s1.print（）只能显示超类成员值，却无法显示子类成员dept的值。
为了能使s1.print（）显示dept的值，就需要在Student1子类中对超类的方法print进行重新定义，称为方法的覆盖。
7.2.5重写
重写是指在继承过程中，子类中的成员（包括数据和方法）与其父类中的成员同名，但功能不同，此时，子类的成员“覆盖”从父类继承过来的成员。
包括两种情况：
一是数据覆盖，称为数据隐藏，即父、子类中数据成员的名称相同，类型不同，它们实际上是完全不同的两个数据；
二是方法覆盖，称为方法重写，即父、子类中方法的名称相同，参数表也完全相同，但功能不同。
在数据隐藏和方法覆盖后，子类成员覆盖了父类的同名成员，要访问父类的这些成员，
需用super关键字来引用当前类的父类。
super的用法有3种情况。
1.super.变量名：
访问父类中被隐藏的成员变量。
2.super.方法名（[参数表]）：
调用父类中被重写的方法。
3.super（[参数表]）：
调用父类的构造方法，此时，可用super来表示父类的构造方法。
【例7-6】变量隐藏和方法重写。
设计思路：
设计类A和类B，类B继承类A，在类A中定义一个整型变量A和一个方法show（），在类B中将A变量类型改变为double型，并将show（）方法的方法体重新写，改变在类A中的功能。
在main（）中创建一个类B的对象调用show（）方法。
代码：
TestClass.java
intx=1;
voidshow（）
classA：
）;
doublex=7.8;
//子类B的成员变量double型的x隐藏了父类A的int型的x
voidshow（）//子类B的成员方法覆盖了父类A的成员方法show（）
classB：
voidshow1（）
super.show（）;
//访问父类A的成员方法show（）
System.out.println（super.x）;
//访问父类A的成员变量x
show（）;
//访问本类B的成员方法show（）
System.out.println（x）;
//访问本类B的成员变量x
classTestClass
publicstaticvoidmain（Stringsrgs[]）
bb.show1（）;
输出结果如图7-6所示：
图7-6程序运行结果
7.3多态
多态（polymorphism），是指一个名字可具有多种语义。
在面向对象语言中，多态是在一棵继承树中的类中可以有多个同名但不同方法体及不同形参的方法。
通常有两种途径实现多态：
方法的重载和覆盖。
多态性允许以统一的风格处理已存在的变量及相关的类。
多态性使得向系统增加新功能变得容易。
继承性和多态性是降低软件复杂性的有效技术。
7.3.1方法的重载
方法重载时：
●参数必须不同即参数个数不同，类型也可以不同。
●返回值可以相同，也可以不同。
重载的价值在于它允许通过使用一个普通的方法名来访问一系列相关的方法。
当调用一个方法时具体执行哪一个方法根据调用方法的参数决定，Java运行系统仅执行与调用的参数相匹配的重载方法。
尽管Java并没有规定重载方法之间必须有联系，但习惯上，为了程序的可读性，最好重载相同含义的方法。
例如，输出语句print的参数可以是Java中的任何基本类型，其实就是对print（）方法的重载：
publicvoidprint（booleanb）
publicvoidprint（charc）
publicvoidprint（inti）
publicvoidprint（longl）
publicvoidprint（floatf）
publicvoidprint（doubled）
【例7-7】构造方法的重载。
本例还是以Person构造方法为例说明方法的重载。
子类继承超类中所有的成员变量和成员方法，但子类不能继承超类的构造方法。
解决办法有两种：
一是使用默认的构造方法，二是编写多个直接的构造方法。
本例使用第二种方法。
//filename：
Student.java
classPerson
staticintcount=0;
publicPerson（Stringn1,inta1）
name=n1;
age=a1;
count++;
publicPerson（Stringn1）{//构造方法重载
this（n1,0）;
//调用本类的构造方法
publicPerson（inta1）{//构造方法重载
this（"
未知名"
a1）;
publicPerson（）{//构造方法重载
publicvoidprint（）{
System.out.print（this.getClass（）.getName（）+"
System.out.print（"
count="
+this.count+"
+name+"
，"
publicclassStudentextendsPerson{
Student（Stringn1,inta1,Stringd1）{
super（n1,a1）;
dept=d1;
Student（）{
this（"
0,"
未知系"
publicstaticvoidmain（Stringargs[]）{
Personp1=newPerson（"
王小红"
p1.print（）;
Personp2=newPerson（"
张小云"
p2.print（）;
Personp3=newPerson（19）;
p3.print（）;
Personp4=newPerson（）;
p4.print（）;
Students1=newStudent（"
赵小丽"
19,"
s1.print（）;
Students2=newStudent（）;
s2.print（）;
程序运行结果如图7-7所示：
图7-7程序运行结果
7.3.2方法的覆盖
在前述继承规则中有一条：
子类继承超类中所有可被子类访问的成员方法，如果子类方法与超类方法同名，则不能继承，此时子类的方法称为覆盖（override）了超类中的那个方法。
在进行覆盖时，应注意以下三点：
●子类不能覆盖超类中声明为final或static的方法。
●子类必须覆盖超类中声明为abstract的方法，或者子类也声明为abstract。
●子类覆盖超类中同名方法时,子类方法声明必须与超类被覆盖方法的声明一样。
方法的覆盖（methodoverriding）与类的继承有密切的关系。
覆盖体现了子类补充或改变超类方法的能力。
通过覆盖使一个方法在不同的子类间表现出不同的行为。
在面向对象系统中,对象封装了方法。
恰恰利用诸如重名、重定义让各对象自己去解释执行，而这种多义性决不会带来混乱。
这对于需求分析、模型设计是极为有利的，因为这些
工作不需要涉及具体的数据结构和类型，只是着重于揭示系统的逻辑合理性。
【例7-8】方法的覆盖。
设计Person类定义toString和print方法，print方法显示本类名和父类名，SuperStudent子类中的toString和print方法覆盖了超类Person的同名方法。
SuperStudent
publicPerson（Stringn1,inta1）
this.count++;
//超类对象计数
publicStringtoString（）
returnthis.name+"
+this.age;
System.out.print
升级会员 