Embed Size (px)
DESCRIPTION
第 6 章 继承和多态机制. 面向对象语言的三大特征是封装、继承和多态，通过本章的学习，读者应该达到以下目标： 【 学习目标 】 理解继承和多态的的原理； 用代码实现子类对父类的继承； 使用方法的覆盖和重载实现多态性 ； 实现子类和父类对象之间的类型转换。. 6.1 继承性. 继承性是一种机制，通过该机制，可以自动实现类之间方法和数据的共享，实现代码的复用。通过继承新产生的类称为子类，又称派生类；被继承的类被称为父类，又称基类。父类包括所有直接或间接被继承的类。 - PowerPoint PPT Presentation
Citation preview
第 6 章 继承和多态机制
• 面向对象语言的三大特征是封装、继承和多态，通过本章的学习，读者应该达到以下目标：
• 【学习目标】
• 理解继承和多态的的原理；• 用代码实现子类对父类的继承；• 使用方法的覆盖和重载实现多态性 ；• 实现子类和父类对象之间的类型转换。
6.1 继承性• 继承性是一种机制，通过该机制，可以自动实
现类之间方法和数据的共享，实现代码的复用。通过继承新产生的类称为子类，又称派生类；被继承的类被称为父类，又称基类。父类包括所有直接或间接被继承的类。
• 一个类可以继承其父类的所有成员变量和方法，而且继承具有传递性，如果 A 继承 B ， B 继承 C ，则 A 间接地继承了 C 。因此，一个类实际上继承了层次结构中在其上面的所有类的成员变量和方法。
• 当 A 继承 B 时，表明 A 类是 B 类的子类，而类 B 是类 A 的父类，类 A 可以由两部分组成，即从类 B 继承得到的部分和自身增加的部分。图 6-1 给出了类之间继承关系示意图。
A 中新增的部分
从 B 类继承的部分
B 类
6.1.1 extends 关键字• 【任务 6-1 】为 Student 类产生子类 onJobStudent • （一）任务描述• 设某个学生类的定义及使用方法如下：
public class Student{String name;// 姓名int No;// 学号
String Info(){ return " 姓名： "+name+" 学号： "+No; }}
另外，对于成人教育的在职工作人员，也是学生的一种，只是特殊的一类学生，现在希望将在职学生类设计为 Student 类的子类。
• （二）任务分析• 在 Java 中，用 extends 关键字来实现子类与
父类的继承关系。可以先产生一个新的onJobStudent 类，用 extends 关键字让onJobStudent 类成为了 Student 类的子类，那么子类 onJobStudent 将继承在同一个包中的父类 Student 的非私有（参考 7.3 ）的变量和方法。
• （三）任务实施• onJobStudent 类实现代码如下
public class onJobStudent extends Student{}
为了说明子类 onJobStudent 将继承父类 Student 的变量和方法，可以编写测试类如下，
public class testOnJobStudent {public static void main(String[] args) {
onJobStudent li=new onJobStudent();
li.name=" 李丽 ";li.No=20080101;System.out.println(li.Info());
}}
运行 testOnJobStudent 类，其输出为
姓名：李丽 学号： 20080101
结论• 可见，虽然在 onJobStudent 类中，没有定义任何变量和方
法，但是在 testOnJobStudent 类中的 main （）函数中调用 li. name 是合法的，因为 li 是一个 onJobStudent 类的对象， 而 onJobStudent 是 Student 类的子类，它继承了Student 类的变量 name ，所以可以访问。同理， li.No ， li.Info() 都是合法的。
6.1.2 子类对父类的扩展【任务 6-2 】在 onJobStudent 类中增加自身的
属性和方法 （一）任务描述既然在职学生是一类特殊的学生，所以肯定有他们不同于普通学生类的特
征，例如，在职学生一般都有单位，有职称，现在希望在【任务 6-1 】的基础上，在 onJobStudent 类中保存单位和职称的信息，并提供一个方法打印这些信息。已知 Student 类代码如下：
public class Student{String name;// 姓名int No;// 学号
String Info(){ return " 姓名： "+name+" 学号： "+No; }}
（二）任务分析在职学生自身特有的变量和方法可以在子类
onJobStudent 类中声明，可以将单位和职称用两个变量来表示，放在 onJobStudent 类中，同时提供一个打印的方法。
• （三）任务实施
public class onJobStudent extends Student{ String title ;// 职称 String company;// 所在单位 void printWorkMsg (){
System.out.println(" 职称 :"+title+" 单位 :"+company); }}
• 为了使用在职学生类新增加的变量和方法，修改测试程序，代码如下：public class testOnJobStudent {
public static void main(String args[]){onJobStudent zhang=new
onJobStudent();zhang.name=" 张三 ";zhang.No=20081002;zhang.company=" 广州宝杰公司 ";zhang.title=" 工程师 ";System.out.println(zhang.Info());zhang. printWorkMsg ();
}}
• 该程序输出为：
姓名：张三 学号： 20081002职称 : 工程师 单位 : 广州宝杰公司
在代码中，在职学生 zhang 是一个 onJobStudent 类的对象，他的变量 name 和 No 是从父类 Student 继承而来的，而变量 company 和title 则是自身所在的类 onJobStudent 中声明的。类似的， zhang.Info() 是调用父类 Student 定义的方法，而方法 zhang. printWorkMsg () 则是调用对象 zhang 本身所属类 onJobStudent 类所定义的方法。
Student 类和 onJobStudent 类的继承关系如图 6-3 所示。
Student 类
变量： nameNo
方 法 ： String Info （）
onJobStudent 类
变量： nameNo
方法： String Info （）
变量： companytitle
方 法 ： void printWorkMsg （）
从 父 类继 承 的变量
从 父 类继 承 的方法
自 身 变量
自 身 方法
6.1.3 子类与父类属性同名：屏蔽
【任务 6-3 】在子类中定义与父类变量同名的变量• （一）任务描述• 假设某个学校某个班的同学通讯地址都为学校，将 Student 类改进，
加入一个 address 变量表示学生所在学校地址，并给出一个初始值为“广州精英学院”，代码如下：
public class Student{String name;// 姓名int No;// 学号String address=" 广州精英学院 ";// 学校地址
String Info(){ return " 姓名： "+name+" 学号： "+No; }}
如果设计 onJobStudent类时，又定义了一个变量 address，为该学生的单位地址，并给出一个初始值为“广州工业大道 1001号”。
// 子类对父类同名变量的覆盖public class onJobStudent extends Student {
String company;// 工作单位String title; // 职称String address=" 广州工业大道 1001 号 ";// 单位地址void printAddress() {
System.out.println(" 单位地址 :" + address);}
}
假设有 onJobStudent 类的对象 zhang 时，如果访问对象 zhang 的 address 变量，得到的结果是 onJobStudent类自身定义的 address和从父类继承而来的 address呢 ?
例如有如下代码，输出将会是什么呢？
public class testStudent {public static void main(String[] args) {
onJobStudent zhang=new onJobStudent();zhang.printAddress();
}}
（二）任务分析及结论• 在 Java 中，子类继承父类后，如果定义了与父类相同的成员变量，则
在子类或子类对象被引用时，将使用子类定义的成员变量，而忽略父类定义的成员变量，即子类变量将屏蔽 (shadow) 父类同名变量。
• 所以 testStudent 类运行输出为：
单位地址 : 广州市工业大道 1001 号
结果输出了子类 onJobStudent 中定义的变量address 的地址，所以验证以下结论是正确的：如果在子类中声明了与父类相同名称的属性，则称子类的该属性屏蔽了父类中对应的属性。
6.1.4 子类与父类方法同名：覆盖
• 覆盖 , 这里是针对方法而言的。如果子类中定义方法所用的名字、返回类型和参数表和父类中方法使用的完全一样，称子类方法覆盖了父类中的方法，即子类中的成员方法将隐藏父类中的同名方法。利用方法覆盖，可以重定义父类中的方法。要注意的是，覆盖的同名方法中，子类方法不能比父类方法的访问权限更严格。例如，如果父类中方法method() 的访问权限是 public ，子类中就不能含有 private的 method() ，否则，会出现编译错误。
• 在子类中，若要使用父类中被隐藏的方法，可以使用super 关键字。
• 正是利用方法的覆盖实现了多态性。这里举例进行说明。
• 【任务 6-4 】在子类中定义与父类方法同名的方法。• （一）任务描述• 假设在 onJobStudent 类中也定义一个 String Info() 方法，能够将所有信息都返回为一个字符串类型的参数，则实现代码如下：
public class Student{String name;// 姓名int No;// 学号
String Info(){ return " 姓名： "+name+"\t 学号： "+No; }}
public class onJobStudent extends Student{ String title ;// 职称 String company;// 所在单位 String Info(){
return " 姓名： "+name+" \t 学号： "+No + "\n 职称 :"+title+"\t 单位 :"+company;
}}
那么在使用 onJobStudent 类的对象 zhang时，如果访问对象 zhang的Info方法，得到的是 onJobStudent 类 Info方法的输出还是和从父类Student类继承而来的 Info方法的输出呢 ?
例如，以下代码的输出将会是什么？
public class testStudent {public static void main(String[] args) {
onJobStudent zhang=new onJobStudent();zhang.name=" 张三 ";zhang.No=20081002;zhang.company=" 广州宝杰公司 ";zhang.title=" 工程师 ";System.out.println(zhang.Info());
}}
（二）任务分析及结论• 在 Java 中，子类继承父类后，如果定义了与父类相同的成员方法，则
在子类或子类对象的方法被引用时，将调用子类定义的成员方法，而忽略父类定义的成员方法，即子类方法将覆盖（ override ）父类同名方法。
• 所以 testStudent 类运行输出为：
姓名：张三 学号： 20081002职称 : 工程师 单位 : 广州宝杰公司
6.1.5 子类与父类的构造方法之间关系
• 在继承机制中，子类与父类关于构造方法的继承机制比较复杂，可以根据子类是否有构造方法、子类是否调用父类构造方法、父类是否只有带参数的构造方法等三种情况来区别对待，可以用图 6-4 来表示。
开始
结束
生成一个子类的对象，调用子类的构造方法B b1=new B（）；
子类有构造方法？
情景1：按子类构造方法的代码执行
情景3：语法出错！必须为子类添加构造方法，
子类构造法中显式调用了父类构造方法
父类只有带参数构造方法？
情景2：隐含的先调用父类不含参数构造方法，再执行子类构造方法定义的语句
情景4：子类调用父类无参数的构造方法，作为自身构造方法，产生子类对象
否是
是 是 否
否
在构造方法的首句显式调用父类带参数的构造方法
父类只有带参数构造方法？
否
是
此处也可以为父类显式定义一个不带参数构造方法，语法错误
可解决
【任务 6-5 】情景 1 ：子类构造方法中显式调用父类构造方法
public class Student{ String name;// 姓名 int No;// 学号 Student(String aName,int aNo){
name=aName;No=aNo;System.out.println(" 一个学生产生 , 姓名： "+this.name+"\t 学
号： "+this.No); }}public class onJobStudent extends Student{ String title ;// 职称 String company;// 所在单位 onJobStudent(String aName, int aNo,String aTitle,String aCompany) { super(aName, aNo); //显式调用父类构造函数 this.title=aTitle; this.company=aCompany; System.out.println(" 一个在职学生产生，职称 :"+this.title+" 单位： "+this.company);
}}
Super 代表父类的构造函数
//情景 1 ：子类构造方法中显式调用父类构造方法public class testStudent {
public static void main(String[] args) {onJobStudent zhang=
new onJobStudent(" 张三 ",20010909, " 工程师 "," 广州宝杰公司 ");
}}
一个学生产生 , 姓名：张三 学号： 20010909一个在职学生产生，职称 : 工程师 单位：广州宝杰公司
程序输出：
onJobStudent 类name
no
onJobStudent(String aName, int aNo,
String aTitle,String aCompany)
继承
Student 类name
noStudent(String aName,int aNo)
【任务 6-6 】情景 2 ：子类隐含调用父类不带参数构造方法
public class Student{String name;// 姓名int No;// 学号 Student(){
System.out.println(" 一个学生产生 ");}
}
public class onJobStudent extends Student{ String title ;// 职称 String company;// 所在单位 onJobStudent(){
System.out.println(" 一个在职学生产生 ");}
} 相当于有 Student （）；自动的拥有的
【任务 6-6 】情景 2 ：子类隐含调用父类不带参数构造方法
//情景 2 ：子类隐含调用父类不带参数构造方法public class testStudent {
public static void main(String[] args) {onJobStudent li=new onJobStudent();
}}
程序输出：一个学生产生
一个在职学生产生
继承
Student 类name
noStudent()
onJobStudent 类name,no
Title companyonJobStudent()
• 以上两个例子说明，父类的无参数的构造函数，无论子类是否显式调用，它都是存在于子类构造函数中并发挥作用的
【任务 6-7 】情景 3 ：父类只有带参数构造方法，子类必须显示调用class Student{ String name;// 姓名 int No;// 学号 Student(String aName,int aNo){ name=aName; No=aNo; System.out.println (" 一个学生产生 , 姓名： "+this.name+"\t 学号： "+this.No); }}public class onJobStudent extends Student{
String title ;// 职称 String company;// 所在单位
}
重点容易出错！
//情景 3 ：父类只有带参数构造方法，子类必须显示调用public class testStudent {
public static void main(String[] args) {onJobStudent li=new onJobStudent();
}}Exception in thread "main" java.lang.Error: 无法解析的编译问题：
构造函数 onJobStudent （）不可视at ch6.eg6_7.testStudent.main(testStudent.java:7)
继承
Student 类name
no Student(String aName,int aNo){
onJobStudent 类name,no
Title company
public class Student{String name;// 姓名int No;// 学号Student(){ System.out.println(" 一个学生产生 ");}
}
public class onJobStudent extends Student{ String title ;// 职称 String company;// 所在单位
}
【任务 6-8 】情景 4 ：子类无构造方法，隐含调用父类无参构造方法
//情景 4 ：子类无构造方法，隐含调用父类无参构造方法public class testStudent {
public static void main(String[] args) {onJobStudent li=new onJobStudent();
}}
一个学生产生程序输出：
继承
Student 类name
no Student()
onJobStudent 类name,no
Title company
This 表示自己本身这个类
class TestColor{ int r,g,b;
TestColor(int r,int g,int b){ this.r=r;
this.g=g; this.b=b;}
}
super 表示父类
public class onJobStudent extends Student{ String title ;// 职称 String company;// 所在单位 onJobStudent(String aName, int aNo,String aTitle,String aCompany) { super(aName, aNo); //显式调用父类构造函数 this.title=aTitle; this.company=aCompany; System.out.println(" 一个在职学生产生，职称 :"+this.title+" 单位： "+this.company); }}
public class Score {// 示例：包含两个重载方法的类int checkOnScore;// 平时考勤成绩int midTermScore;// 期中考试成绩int finalTermScore;// 期末考试成绩int designScore;// 课程设计成绩public Score(int checkOnScore, int midTermScore, int
finalTermScore,int designScore) {
super();this.checkOnScore = checkOnScore;this.midTermScore = midTermScore;this.finalTermScore = finalTermScore;this.designScore = designScore;
}
【任务 6-9 】“静态”多态
计算期末成绩的几种方法
// cPower,mPower,fPower 分别为平时考勤、期中考试、期末考试成绩比重double getResult(double cPower, double mPower, double fPower) {
return cPower * checkOnScore + mPower * midTermScore + fPower* finalTermScore;
}// dPower,fPower 分别为课程设计、期末考试成绩比重double getResult(double dPower, double fPower) {
return dPower * designScore + fPower * finalTermScore;}
}
【任务 6-9 】“静态”多态
public class TestScore { // 演示调用对象的重载方法 public static void main(String[] args) {
Score s1 = new Score(60, 70, 80, 90);// 生成一个成绩类对象System.out.println("第一种方法： " + s1.getResult(0.5, 0.5));System.out.println("第二种方法： "
+ s1.getResult(0.2, 0.3, 0.5)); }
}
第一种计算方法： 85.0第二种计算方法： 73.0
【任务 6-9 】“静态”多态
6.2.2 类型转换
• 类和类之间的类型转换只能用在父类和子类间 ,• 不能用在兄弟类 ,• 更不能用在根本不相关的两个类之间。• 类型转换的规则是：• 子类向父类转换时，属于自动类型转换；• 而父类要转换成子类时，就必须要使用强制类型转
换了。• 强制类型转换的语法就跟一般基本数据类型转换的
语法一样，用小括号运算符配合要转换成的类来做转换的操作。
public class Animal {String name;int age;
}
public class Fish extends Animal{public void swim(){
System.out.println("swim");}
}
public class test {public static void main(String[] args) {
Animal a1=new Animal();Fish f1=new Fish();Fish f2=new Fish();// 子类到父类的转换：自然转换，显式和隐式都可以a1=(Animal)f1;//显式转换a1=f1;//隐式转换// 父类到子类的转换：强制转换，一定要显式转换f2=(Fish)a1;//f2=a1;// 语法错误提示 ; 不能从 Animal 转换成 Fish
}}
public class Bird extends Animal{public void fly(){
System.out.println("fly");}
}
//兄弟类不能相互转换 public class test1 { public static void main(String[] args) {
Bird b1=new Bird();Fish f1=new Fish();Animal a1=new Animal();// 直接转换显然不行//b1=(Bird)f1;//错误提示：不能从 Fish强制转换为 Bird//f1=(Fish)b1;//错误提示：不能从 Bird强制转换为 Fish
// 通过父类 Animal 转换 , 语法可通过，运行出错！a1=b1;f1=(Fish)a1;
} }
Exception in thread "main" java.lang.ClassCastException: ch6.eg6_10.Bird
at ch6.eg6_10.test1.main(test1.java:14)
【任务 6-11 】 “运行时多态”
Student
FullTimeStudent OnJobStudent
Study （）
Study （） Study （）
【任务 6-11 】 “运行时多态”
public class Student {String name;// 姓名int No;// 学号Student(String aName, int aNo) {
name = aName;No = aNo;
}void study(){}
} public class OnJobStudent extends Student {// 在职学生OnJobStudent(String aName, int aNo) {
super(aName, aNo);}void study(){
System.out.println(this.name+" 每周末学习 10 个小时，每个学期学习 20 周 ");
}}
public class FullTimeStudent extends Student{ //全日制学生
public FullTimeStudent(String aName, int aNo) { super(aName, aNo);}void study(){ System.out.println
(this.name+" 工作日学习 20 个学时，每个学期学习 20周 ");
} }
【任务 6-11 】 “运行时多态”
任务实现// 父类对象指向不同子类对象实现运行时多态public class test {
public static void main(String[] args) {Student[] s = new Student[5];s[0] = new OnJobStudent("jack", 001);s[1] = new OnJobStudent("tom", 002);s[2] = new FullTimeStudent("zhangsan", 003);s[3] = new FullTimeStudent(" 李四 ", 004);s[4] = new FullTimeStudent("王五 ", 005);for (int i=0;i<5;i++){
s[i].study();}
}
}jack周末学习 10 个小时，每个学期学习 20周tom周末学习 10 个小时，每个学期学习 20周zhangsan 工作日学习 20 个学时，每个学期学习20周李四工作日学习 20 个学时，每个学期学习 20周王五工作日学习 20 个学时，每个学期学习 20周
【任务 6-11 】 “运行时多态”
• 可以说圆柱是一个圆吗》• 可以说球是一个圆吗？• 可以说某个圆是一个球吗？• 球的对象可以转换为圆柱类对象吗？
类值之间的转换circle
cylindar sphere
area （）
area （） area （）
课后问题
6.3 思考与练习• 一、选择题• 1. Java 语言的类间的继承关系是 ( ) 。• A) 多重的 B) 单重的 C) 线程的 D) 不能继承 • 2. 下面是有关子类继承父类构造函数的描述，其中正确的是 (
) 。• A) 如果子类没有定义构造函数，则子类无构造函数• B) 子类构造函数必须通过 super 关键字调用父类的构造函数• C) 子类必须通过 this 关键字调用父类的构造函数• D) 子类无法继承父类的构造函数• 3. 现有两个类 A 、 B ，以下描述中表示 B 继承自 A 的是 ( ) 。• A) class A extends B B) class B implements A• C) class A implements B D) class B extends A
二、填空题• 1. 子类可以继承父类的 __________ 成员。构造函数也能被
继承和重载。• 2. 如果子类中的某个变量的变量名与它的父类中的某个变量完全一样，则称子类中的这个变量 ________ 了父类的同名变量。
• 3. 属性的隐藏是指子类重新定义从父类继承来的__________ 。
• 4. 如果子类中的某个方法的名字、返回值类型和 ________与它的父类中的某个方法完全一样，则称子类中的这个方法覆盖了父类的同名方法。
• 5. 抽象、封装、 _____ 和多态是 Java 语言的四大特性。• 6. Java 仅支持类间的 ____ 重继承。
三、简答题：• 1. 有 A 类、 B 类和测试类 testAB 分别如下
定义public class A {A(){
System.out.println("a");}
}
public class B extends A{
}
public class testAB {public static void main(String args[]){
B b1=new B();}
}
请问 testAB 类的输出是什么？这说明什么问题？
• 2. 子类的成员变量能与其父类的成员变量同名吗？
• 3. 什么是方法覆盖？ • 4. 一个子类可以重新定义从父类那里继承
来的同名方法。但是，允许它们有不同类型的返回值吗？
• 5. 保留字 this 代表什么 ?
6.4 综合实训
• 实训 1 ：类的多层继承• （ 1 ）设计一个 Point 类，包含横坐标 x 和纵坐标 y ；• （ 2 ）设计一个 Circle 类，继承 Point 类，并添加 int 类型的变量
radius （半径），求面积方法 double area （）和求周长方法 double perimeter （）；
• （ 3 ）设计一个 Cylindar 类，继承 Circle 类，并添加 int 类型的变量height （高度），求体积方法 double volumn （）；
• （ 4 ）编写测试程序 test 类，实现下列功能：• 在 main 函数中生成两个点 p1(3,4) 和 p2(5,6) ；• 生成一个圆 c1 ，圆心在（ 0 ， 0 ），半径为 3 ，计算并输出圆 c1
的面积和周长；• 生成一个圆柱 cy1 ，底面的圆的圆心在（ 0 ， 0 ），半径为 3 ，高度为 4 ，计算并输出圆柱 cy1 的体积。
实训 2 ：类的重载与多态性• （ 1 ）设计一个雇员类 Employee ，该雇员
类有两种计算工资的方法：• （ 2 ）第一种：正常工作时间： 80元 /天、
加班工作时间： 100元 /天；• （ 3 ）第二种：正常工作时间： 100元 /天、
加班工作时间： 0元 /天；• （ 4 ） 某个月，有个雇员正常工作 22天，
加班工作 6天，请读者帮他计算出两种工资的结果，并输出较大的工资。
实训 3 ：覆盖与多态
• （ 1 ）设计一个圆柱体 Cylinder 类继承 Circle类，添加 int 类型变量 height （圆柱体高）并覆盖 Cirlce 类的求面积 double area （）方法；
• （ 2 ）设计一个球体 Sphere 类继承 Circle 类，并覆盖 Cirlce 类的求面积 double area （）方法；
• （ 3 ）在测试类的 main 函数中，生成两个对象，分别为一个圆柱体 cy1 和一个球 sp1 ，并分别初始化、计算并输出这两个对象的面积。
•
