2015.6.17--java第七章继承和多态章总结
第七章 面向对象的Java实现-继承和多态
Java教员
.NET教员
10
为什么需要继承 4-4
public class JavaTeacher2 extends Teacher { public JavaTeacher2(String myName, String mySchool) { super(myName, mySchool); 子类自动继承父类的属 } 性和方法，子类中不再 public void giveLesson(){ 存在重复代码 System.out.println("启动 Eclipse"); super.giveLesson(); } } public class DotNetTeacher2 extends Teacher { public DotNetTeacher2(String myName, String mySchool) { super(myName, mySchool); } public void giveLesson(){ System.out.println("启动 Visual Studio .NET"); super.giveLesson(); } } 使用继承，可以有效实现代码复用
4
本章目标
掌握继承 掌握super关键字 掌握多态
5
生活中的继承 2-1
生活中，继承的例子随处可见
动物 谁是父类？ 谁是子类？ 能说出继承的特点吗？
食草动物
食肉动物
继承需要符合的关系：is-a，父类更通用、子类更具体
6
生活中的继承 2-2
子类具有父类的一般特性（包括属性和行为）， 以及自身特殊的特性
可以接收子类类型 public class HQ3 { public void judge(Teacher t){ t.introduction(); t.giveLesson(); 根据实际创建的对象 } 类型调用相应方法 大家好！我是北京中心的李明. 启动 Eclipse 知识点讲解 总结提问
对java多态和继承的总结
25. }
26.
27. public int getprice() {
28. return 20000
29. }
30. }
31.
32. // 汽车出售店
33. public class carshop {
抽象类可以继承（extends）普通类，可以继承（extends）抽象类，可以继承（implements）接口。
接口只能继承（extends）接口。
请注意上面三条规律中每种继承情况下使用的不同的关键字extends和implements，它们是不可以随意替换的。大家知道，一个普通类继承一个接 口后，必须这个接口中定义的所有方法，否则就只能被定义为抽象类。我在这里之所以没有对implements关键字使用“实现”这种说法是因为从概念上来 说它也是表示一种继承关系，而且对于抽象类implements接口的情况下，它并不是一定要实现这个接口定义的任何方法，因此使用继承的说法更为合理一 些。
java代码 复制代码
1. // 桑塔纳汽车
2. class santana implements car {
3. public string getname() {
4. return " santana"
5. }
6.
7. public int getprice() {
7. // other code
8. }
9. }
10.
11. class parent {
12. public void method() {
13. // do something here
Java课件第七讲继承与多态.ppt
public static void main(String args[]){ UniversityWorld univers=new UniversityWorld("同济大学 ","上海","中国"); System.out.println("大学："+name+" 城市："+city+" 国 籍："+country); } }
例：SuperTest.java
（二）方法重载
在Java中，可以在同一个类中定义多个同 名的方法；在方法重载时，根据方法参 数的个数、类型、顺序来决定采用哪个 方法。 • 例: void f() {…} void f(long number) {…} • 例：UniversityWorldCity.java
（二）接口的定义
• 声明格式：
[接口修饰符] interface 接口名 [extends 父接口名] { …//方法的原型定义或静态常数 } 注意：与抽象类一样，接口不需要构造函数；接口 的继承与类一样，但接口的父类也必须是接口。
例： interface Booksale { void show(); void sale(); void replay(); }
例：
class Game { public void Play() { System.out.println("Play a game."); } } class BoardGame extends Game { public void Play() { System.out.println("Play a board game."); } } public class Chess extends BoardGame { public void Play() { System.out.println("Play a chessversityWorld2.java
Java的继承,封装,多态
Java中的继承、封装、多态Java中的继承、封装、多态本博客包含以下内容，博主是菜鸟，正在努力学习中，如有错误或不足，欢迎交流讨论。
1.基本定义2.初始化和类的加载3.final关键字4.类之间的关系5.向上转型6.多态的缺陷7.构造器和多态1、基本定义继承：在创建一个新类（子类、导出类）时，使用extends关键字表明它派生于一个已经存在的类（父类、基类、超类），导出类会获得基类的所有域和方法，但并不是一定能直接访问，和访问权限控制有关。
和组合相比，继承是隐式的放置基类子对象封装：封装即将成员变量或者方法的具体实现隐藏起来，对用户提供接口的形式来访问，用户不需要知道具体有什么以及怎么现实，只需要知道如何使用。
若是将一个类的字段和某些方法封装起来不让用户直接访问字段或者方法，只提供类似接口的方式访问，对用户来说，此类可以看做一种抽象数据类型，比如stack多态:有称动态绑定、后期绑定或运行时绑定。
首先明确下什么是绑定：将方法调用同一个方法主体关联起来。
若在程序执行前进行绑定，叫做前期绑定，由编译器和连接程序实现，比如C都是前期绑定；动态绑定，即在程序执行前不知道对象的类型（所属的类到底是基类还是导出类），但是在运行时根据方法调用机制能找到方法调用的正确类型从而进行绑定。
故后面需要学习运行时类型信息。
2、初始化和类的加载当创建导出类对象时，该对象实际上包含了一个基类子对象，是隐式的，而不是直接显式地用基类创建对象。
从上述来看，调用导出类的构造器创建对象是需要调用基类构造器的，而导出类可能会依赖基类对象，导出类只能访问自己的成员，不能访问基类的成员（一般是private的），故创建导出类对象的第一步是调用基类的构造器，若是继承层次较多，则从根类开始调用。
如果导出类构造器没有显式地（通过super关键字）调用基类的构造器，则会自动地调用基类的默认构造器（无参的构造器），若基类构造器是有参数的，导出类构造器又没有显式的调用基类构造器，则Java编译器将报错。
JAVA7_继承和多态
8.1.2 创建子类对象
• Java语言规定子类不能继承父类的构造方 法，但是必须在子类的构造方法中调用父 类的构造方法。
• 关键字super可以用来调用父类的构造方法， 其使用方式如下：
– super(); //调用父类的无参构造方法 – super(参数); //调用父类的有参构造方法
8.1.1 使用继承
• 面向对象程序设计中根据子类可以继承父类的数量分为多 继承和单继承两种，Java语言只支持单继承，即一个子类 只能继承一个父类。
• 子类是基于父类创建的，它可以继承父类的部分数据域和 方法，在访问修饰符的作用下，子类对父类数据域和方法 的继承受到以下一些限制。
– （1）子类与父类在同一包的情况。子类可以继承父类中除private 成员以外的所有成员，继承来的成员的可访问性保持不变。
继承和多态
学习目标
• 本章将学习面向对象程序设计的继承和多 态。使用继承可以在已有类的基础上构造 新类，是类重用的体现。多态在继承的基 础上实现，可以使提高程序的灵活性和可 扩展性。
Java程序设计
2
8.1 继承
• 类之间的继承关系是现实世界客观事物之 间分类关系的直接模拟，如飞机、汽车和 火车均属于交通工具，这三个类可以继承 交通工具类的属性和方法，并扩展自己特 有的属性和方法。
8.1.5 对象类型转换与instanceof运算符
• 除基本数据类型可以进行类型转换外， Java语言也允许对象引用变量进行类型转 换，转换规则如下：
– （1）自动类型转换 引用类型的自动类型转换也称为隐式类型
转换或向上类型转换。在继承关系中，父类的 引用变量可以直接引用其任一子类的对象。 – （2）强制类型转换
java继承和多态
继承中的上转型对象
• 假设A 类是B 类的父类, class B extends A {…… } 当我们用子类创建一个对象,并把这个对象的引用放到父类的对 象中时，称这个父类对象a,是子类对象b的上转型对象。 • 例如：
A a; A a=new B();或 A a; B b=new B(); a=b;
定义具有覆盖（重写）特征的成员方法时，通常有下面两种形式： 定义具有覆盖（重写）特征的成员方法时，通常有下面两种形式：
1.在子类定义的成员方法中，首先调用父类中 被覆盖的成员方法，再添加一些操作语句， 这种形式可以达到对父类被覆盖成员 方法的功能给予补充、增强。 2.在子类定义的成员方法中，没有调用父类中 被覆盖的成员方法，而是全新的语句组，这 种形式可以达到对父类被覆盖成员方法的全 部覆盖。当子类对象的某项操作与父类对象 相应的操作过程完全不同时，常常采取这种 方式实现。
•
例子： 例子：
• •
• • • • • • • • • • • • • • • • • •
//建一个A类 class A{ //成员变量 其中num是实参 int num=0; //成员方法,其中 i 是型参 public A(int i){ //输入int型文件输出下面 System.out.println("aaaaaaaaaaaaaaaaaaa"); System.out.println("i= "+i); //把输入的i赋值给成员变量num num=i; } } //B继承A class B extends A{ int num=0; //成员方法B. public B(){ //继承类A的方法.因为B继承了A必然继承了A的特性.所以输入int值10令方法实现.
java继承与多态
java继承与多态继承继承：可以让⼦类继承⽗类，这样⼦类会继承⽗类所有的属性和⽅法。
然⽽在Java中是不允许有多继承的，即⼀个⼦类只能继承⼀个⽗类，不能同时继承多个⽗类。
如果⼀个类还需要另外⼀个类的⽅法，可以让⽗类去继承需要的类。
但Java中⽀持多重继承，即⼀个⼦类也可以做为其他类的⽗类。
Object类：是Java中的祖宗类，当⼀个类在代码层⾯没有去继承任何的⽗类，那这个类默认会继承object类。
继承的重写（覆盖）：⼦类继承⽗类以后，可以获取到⽗类的所有⽅法（包含被private修饰的⽅法，只是访问不到），如果⽗类的⽅法功能不能满⾜⼦类的需求，那么⼦类可以根据需求对这个⽅法进⾏重写。
Super关键字：⼦类继承⽗类后，⼦类可以通过super关键字去指向⽗类的元素（属性，构造⽅法，普通⽅法）。
如果是指向⽗类的构造⽅法：super()如果是指向⼦类的构造⽅法：this()注：像super(),this()这样的表达式只能存在于构造⽅法中，且只能出现⼀次。
如果是指向⽗类的普通⽅法：super.⽅法名称()如果是指向⽗类的属性：super.属性名称()构造⽅法的继承：在继承时，当⼦类⽤到默认的⽆参构造⽅法时，⽗类必须要有⽆参构造⽅法，不然⼦类的构造⽅法就会报错。
因为⼦类继承⽗类之后，获取到了⽗类的内容（属性/字段），⽽这些内容在使⽤之前必须先初始化，⼦类如果在没有⾃定义构造⽅法的情况下默认会有⼀个⽆参构造⽅法，其中第⼀⾏默认会有⼀个super()，所以必须先调⽤⽗类的构造函数进⾏内容的初始化。
所以⽗类必须要有⼀个⽆参构造⽅法。
⼦类直接继承得到的属性⽆法直接获取，可以通过⽗类的get和set⽅法来获取和修改属性。
public class Animal {private String name;private int age;private String hobby;public Animal(){}public Animal(String name, int age, String hobby) { = name;this.age = age;this.hobby = hobby;}}public class Dog extends Animal {public Dog(String name, int age, String hobby) {super(name, age, hobby);}}⽅法重写与⽅法重载的区别：⽅法重写override：⽅法重写是指⼦类在继承了⽗类之后需要对⽗类的⼀些⽅法进⾏修改，以适应程序需求，因此在⼦类中重写⽗类中原有的⽅法。
Java第6讲 继承与多态
}
}
类的继承和派生
定义一个Fish类
鱼本身也是动物,它也有吃、睡觉、呼吸行为， 希望它从动物类继承状态和行为。
class { } Fish extends Animal
替换（向上转型）
二、替换
考察父类的类型与子类的类型之间关系，发现： 子类实例必须拥有父类的所有数据成员。 子类实例必须至少通过继承，实现父类所定义的所 有功能。 这样，在某种条件下，如果用子类实例替换父类实例 将会发现子类实例可以完全模拟父类的行为。
继承图
被继承数据 （private） 被继承数据 (public和protected)
基类A
从基类继承数据 (除private在B中不可见,其它都可见) 自己新增加部分
派生类B
类的继承访问特性
基类中的private成员在派生类中都是不可见的，即该 派生类的方法成员不能直接访问基类中的私有成员。
public class A { private int m_a; public int m_b; protected int m_c; public A() { m_a=3; m_b=4; m_c=5; } public int getA() { return m_a; } } public class B extends A { public void showData() { //error System.out.println(m_a); //ok System.out.println(m_b); System.out.println(m_c); //ok System.out.println(GetA()); } }
class { Fish extends Animal public void breathe() { System.out.println(“fish bubble”); } }
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
第七章继承和多态
1.继承的作用：
它是面向对象的三大特征之一，可以解决编程代码冗余的问题，是实现代码重用的重要手段之一。
继承是软件可重用性的一种表现，新类可以在不增加自身代码的情况下，通过从现有的类中继承其属性和方法，来充实自身内容，这种表现或行为就称为继承。
这个时候新类称为子类，现有的类称为父类。
它最基本的作用就是：使得代码可重用，增加软件的可扩充性。
2.继承的语法：
[访问修饰符] class <SubClass> extends<SuperClass>;
a.通过extends实现继承subclass 是子类后者是父类。
b.如果访问修饰符是public，那么该类在整个项目可见。
不写访问修饰符，该类只在当前包可见。
c.子类可以从父类中继承，public和protected修饰的属性和方法，不论子类和父类是否在同一个包里。
d.子类还可以继承默认访问修饰符修饰的属性和方法，但是子类和父类必须在同一个包里。
E.子类无法继承父类的构造方法。
3.多重继承关系的初始化顺序：
父类属性>>父类构造方法>>子类属性>>子类构造方法。
4.实例化子类对象：
A.创建该类的对象。
B.创建该类的子类的对象。
C.子类在实例化时，会首先执行父类的构造方法，然后才执行子类的构造方法。
5.子类继承父类时，构造方法的调用规则如下：
a.如果子类的构造方法中没有通过super显式调用父类的有参构造方法，也没有通过this显式调用自身的其他构造方法，则系统默认先调用父类的无参构造方法，在这种情况下是否写入super语句，效果是一样的。
b.如果子类的构造方法中通过super显式调用父类的有参构造方法，那么将执行父类相应的构造方法，而不执行父类的无参构造方法。
c.如果子类的构造方法中通过this显式调用自身的其他构造
方法，在相应构造方法中应用以上两条规则。
注意：如果存在多级继承关系，在创建一个子类对象时，以上规则会多次向更高一级父类应用，一直执行到顶级父类object类的无参构造方法为止。
注意：在类没有提供任何构造方法时，系统会提供无参的方法体为空的默认构造方法，一旦提供了自定义构造方法，系统将不会提供这个默认的构造方法，如果要使用它，程序员必须手动添加。
6.object类
它是所有类的父类。
在java中所有的java类都直接或间接的继承了ng.object类。
在定义一个类时，没有使用extends关键字，也就是没有显式地继承某个类，那么这个直接继承object类，所有对象都继承这个类的方法。
Object类定义大量的可被继承的方法。
7.继承中的方法重写。
A.子类可以根据需求对从父类继承的方法进行重写，这称为方法的重写或方法的覆盖（overriding）。
B.如果子类从父类中继承的方法不能满足子类的需求，可以在子类中对父类的同名方法进行重写（覆盖）。
8.继承中方法重写的要求
a.重写方法与被重写方法必须具有相同的方法名（和方法重写一样）
b.重写方法与被重写方法必须具有相同的参数列表（不一样）
c.重写方法的返回值类型和被重写方法的返回值类型相同。
（不一样）
d.重写方法不能缩小被重写方法的访问权限。
e.在继承父类方法的基础上只能修改返回值类型和方法体内容。
9.重载（overloading）和重写（overriding）的区别。
A.重载涉及同一个类中的同名方法，要求方法名相同，参数列表不同，与返回值类型无关。
B.重写涉及的是子类和父类之间的同名方法，要求方法名相同，参数列表相同，返回值类型相同。
10.多态
a.多态一词的通常含义是指能够呈现出多种不同的形式或形态。
在程序设计中，它意味着一个特定类型的变量可以引用不同类型的对象。
并且能够自动地调用引用的对象的方法。
也就是根据作用到的不同对象类型，响应不同的操作。
方法
重写是实现多态的基础。
b./*Dog dog =new Dog();
dog.toHospital();
Bird bird =new Bird();
bird.toHospital();*/
Pet pet;
pet=new Dog();
pet.toHospital();
pet=new Bird();
pet.toHospital();
这两段代码的执行结果一样（page179），虽然定义的是Pet 类，但是实际执行的时候是Pet子类的方法，这里的代码就体现了多态性。
多态意味着在一次方法调用中是根据包含的对象的实际类型（即实际的子类对象）来决定应该调用哪个方法。
而不是用来储存对象引用的变量的类型来决定的。
当调用一个方法时，为了得到多态的操作，这个方法即要是父类中声明过的，也必须是子类中重写过的方法。
11.向上转型
a.定义：子类到父类的转换成为向上转型。
将一个父类的引用指向一个子类对象，称为向上转型，自动
进行类型转换。
此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法，而不是父类的方法。
此时同过父类引用变量无法调用子类特有的方法。
b.语法：<父类型><引用变量名>=new <子类型>();
int i=5;
double di=5;
把int型常量或变量的值赋值给double型变量，可以自动进行类型转换。
double d2=3.14;
int a=(int) d2;
把double型常量或变量的值赋值给int型变量，须进行强制转换。
实际上在引用数据类型的子类和父类之间也存在这类型转换问题。
如：
Pet pet=new Dog();子类到父类的转换
pet.toHospital();会调用Dog类的toHospital()方法，而不是Pet类的toHospital()方法体现了多态。
12.向下转型
A.定义：当向上转型发生后，将无法调用子类特有的方法。
但是如果需要调用子类特有的方法时，可以通过把父类在转换为子类来实现。
B.将一个指向子类对象的父类引用赋给一个子类的引用，即父类类型转换为子类类型，称为向下转型，此时必须进行强制类型转换。
C.语法：<子类型><子类引用变量>=(子类型)<父类引用变量>
Dog dog =(Dog) pet;
dog.catchingFlyDisc();Dog特有的接飞盘方法.
13.instanceof运算符
在向下转型的过程中，如果没有转化为真实子类类型，会出现类型转换异常。
Page181
Pet pet=new Dog();
pet.toHospital();
Bird bird=(Bird) pet;将pet转换为Bird类型会出错。
A.使用instanceof时，对象的类型必须和instanceof后面的参数所指定的类在继承上有上下级关系。
否则会出现编译错误。
Instanceof通常和强制类型转换结合使用。
14.多态的应用。
A.可替换性：多态对已存在的代码具有可替换性。
B.可扩充性：增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作，实际上新增子类更容易获得多态功能。
C.借口性：多态是父类向子类提供类一个共同接口，由子类完善或
者覆盖来实现。
D.灵活性：多态在应用中体现了灵活多样的操作，提高了使用效率。
E.简化性：多态简化了对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。
15.使用父类作为方法的形参。
A.这个方法是java中实现和使用多态的主要方式。
(page182)
父类作为方法形参，所有子类对象都可以作为实参。
(chapter07.ketang03.pet)
16.使用父类作为方法返回值：
使用父类作为方法返回值也是java中实现和使用多态的主要形式。
Page183,(chapter07.ketang0)
掌握继承的优点和实现*****
掌握子类重写父类方法*****
掌握继承下构造方法的执行**********
掌握抽象类和抽象方法的使用*****
掌握final修饰属性、方法和类*****
多态：多种表现形态
多态；父类引用指向子类对象。
Person类型是person的编译类型。
Soldier类型是p的运行时类型。
1.转型
A.向上转型：子类类型转换成父类类型
B.向下转型instanceof：父类类型转换成子类类型，强转。
2.多态的使用
2.1父类作为方法形参
2.2父类作为方法返回值类型。
3.向下转型要转换成真实子类。
Instanceof前边放的是变量后边放的是一个类，可以判断变量是否属于这个类。
结果是布尔类型。
Instanceof的使用必须有继承关系。