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”); } }
JAVA继承与多态
2024年4月3日星期三
Java程序设计
10
2024年4月3日星期三
Java程序设计
// file name：ShapeClass.java
import java.util.*;
public class ShapeClass {
// 几何图元类
private ColorClass color;
4
2024年4月3日星期三
Java程序设计 EmployeeClass类与ManagerClass类的关系图
5
2024年4月3日星期三
Java程序设计
// file name：EmployeeClass.java
public class EmployeeClass {
// 雇员类
private String name;
}
}
11
2024年4月3日星期三
Java程序设计
// file name：RectangleClass.java
public class RectangleClass extends ShapeClass { // 矩形类
private int length;
// 长
private int width;
// 颜色属性
private Point place; // 位置属性
public ShapeClass() {
color = new ColorClass();
place = new Point();
}
public ShapeClass(ColorClass color, Point place){
}
12
2024年4月3日星期三
第七章面向对象的Java实现继承和多态精品PPT课件
• 掌握继承 • 掌握super关键字 • 掌握多态
本章目标
5
生活中的继承 2-1
• 生活中，继承的例子随处可见
动物
谁是父类？ 谁是子类？ 能说出继承的特点吗？
食草动物
食肉动物
继承需要符合的关系：is-a，父类更通用、子类更具体
6
生活中的继承 2-2
• 子类具有父类的一般特性（包括属性和行为）， 以及自身特殊的特性
}
}
}
9
代码存在重复，违背了}“write once, only once”的原则
为什么需要继承 4-3
• 如何改进？有没有可能建立继承关系，让子类自动继承父 类的属性和方法？
Java教员是教员吗？ .NET教员是教员吗？
教员
姓名 所在中心
授课 自我介绍
Java教员 .NET教员
10
public class Teacher {
} 使用继承，可以有效实现代码复用
11
如何实现继承 3-1
• 在Java语言中，用extends关键字来表示一个类 继承了另一个类，例如：
public class JavaTeacher2 extends Teacher { //其余代码省略
}
• 在父类中只定义一些通用的属性与方法，例如：
public class Teacher { private String name; // 教员姓名 private String school; // 所在中心 public Teacher(String myName, String mySchool) { //初始化属性值 } public void giveLesson() { //授课方法的具体实现 } public void introduction() { //自我介绍方法的具体实现 }
java继承知识点总结
java继承知识点总结在Java编程语言中，继承是一种重要的面向对象编程的概念。
通过继承，一个类可以继承另一个类的属性和方法。
这使得代码可以更加灵活和可复用。
在这篇文章中，我们将介绍Java中继承的基本概念、语法和用法。
一、继承的基本概念继承是面向对象编程的一个重要特性。
它允许一个类（子类）继承另一个类（父类）的属性和方法。
通过继承，子类可以重用父类的成员变量和方法，同时也可以添加自己的新成员变量和方法。
这使得代码更加灵活和可维护。
在Java中，继承是通过关键字 extends 来实现的。
当一个类继承另一个类时，子类将继承父类的成员变量和方法，同时也可以重写父类的方法。
继承是Java中面向对象编程的基石，通常用于实现代码的重用和抽象。
二、继承的语法在Java中，通过关键字 extends 来实现继承。
例如：```javaclass Animal {String name;public void eat() {System.out.println("Animal is eating");}}class Dog extends Animal {public void bark() {System.out.println("Dog is barking");}}```在上面的例子中，类 Dog 继承了类 Animal。
这意味着，Dog 类将拥有 Animal 类的成员变量和方法。
同时，Dog 类也可以定义自己的成员变量和方法。
三、继承的特点在Java中，继承具有以下几个特点：1. 子类可以继承父类的成员变量和方法通过继承，子类可以访问父类的成员变量和方法。
这使得代码更加灵活和可复用。
2. 子类可以重写父类的方法子类可以重写父类的方法，以实现自己的特定逻辑。
这使得继承可以实现多态，使代码更加灵活和可扩展。
3. 子类可以添加自己的成员变量和方法通过继承，子类可以添加自己的成员变量和方法。
java继承与多态实验报告总结 -回复
java继承与多态实验报告总结-回复
Java的继承和多态机制是其面向对象特性中非常重要的一部分，深入理解和熟练应用这两个机制对于Java程序设计是至关重要的。
在进行本次实验之前，我们首先需要清楚Java继承和多态机制的概念和基本用法，下面对实验内容和结果进行总结。
实验内容：
本次实验主要涉及Java的继承和多态机制，并通过实践的方式加深对这两个机制的理解。
具体来说，本次实验包含以下部分：
1.构建一个简单的继承结构
2.掌握多态的实现方式
3.探索Java的抽象类和接口
4.了解Java中的重载和重写
5.熟练掌握Java继承和多态在实际编程中的运用
实验结果：
通过本次实验，我对Java的继承和多态机制有了更深入的理解。
在实践过程中，我发现继承可以简化我们的代码实现，通过重写父类方法可以实现子类的特定需求。
而多态可以大大减轻代码的复杂度，提高代码的可扩展性和可复用性，使得程序的设计更加灵活。
在实验过程中，我还学习了Java的抽象类和接口，发现它们在Java程序设计中的应用非常广泛，可以通过它们实现对多态的更加深入的理解与应用，同时也可以提高代码的可维护性和代码的可读性。
总的来说，通过本次实验，我对Java的继承和多态机制有了更加深入的理解，也更加熟练地掌握了这两个机制在实践中的应用，有助于我后续Java程序设计的实践和工作。
Java中封装、继承、多态的理解
Java中封装、继承、多态的理解Java中的继承、封装、多态继承的理解：1、继承是⾯向对象的三⼤特征之⼀，也是实现代码复⽤的重要⼿段。
Java的继承具有单继承的特点，每个⼦类只有⼀个直接⽗类。
2、Java的继承通过extends关键字来实现，实现继承的类被称为⼦类，被继承的类称为⽗类(有的也称其为基类、超类)，⽗类和⼦类的关系，是⼀种⼀般和特殊的关系。
就像是⽔果和苹果的关系，苹果继承了⽔果，苹果是⽔果的⼦类，⽔果是苹果的⽗类，则苹果是⼀种特殊的⽔果。
3、Java使⽤extends作为继承的关键字，extends关键字在英⽂是扩展的意思，⽽不是继承。
为什么国内把extends翻译成继承呢？除了与历史原因有关外，把extends翻译成为继承也是有其道理的：⼦类扩展⽗类，将可以获得⽗类的全部属性和⽅法，这与汉语中得继承（⼦辈从⽗辈那⾥获得⼀笔财富成为继承）具有很好的类似性。
值得指出的是：Java的⼦类不能获得⽗类的构造器。
4、实例：class BaseClass{public double weight;public void info() {System.out.println("我的体重是"+weight+"千克");}}public class ExtendsDemo001 extends BaseClass {public static void main(String[] args) {//创建ExtendsDemo001对象ExtendsDemo001 ed = new ExtendsDemo001();//ExtendsDemo001本⾝没有weight属性，但是ExtendsDemo001的⽗类有weight属性，也可以访问ExtendsDemo001对象的属性ed.weight = 56;//调⽤ExtendsDemo001对象的info()⽅法();}}打印结果为：我的体重是56.0千克5、Java类只能有⼀个⽗类。
java教程第7章 继承和多态
}
7.4.5 接口作为方法的参数
n 接口可以作为某个方法的参数，使用该方法时，传递的是实现了该 接口的某个类的对象，如： class Test{ public void fun(Dancable b) { b.jump(); } public static void main(String[] args) { Test t = new Test(); Person p = new Person(); t.fun(p); } }
7.4.2 接口的作用
n 接口的使用弥补了Java单亲继承的缺点； n 类的继承：类继承类—单继承
接口：类实现接口—多实现 接口继承接口—多继承
n 有关系的类才能实现同一个抽象类，无关 系的类不可能有同一个父类，但无关的类 可以有同一个接口；
n 接口的使用使得项目中多个程序员可以并 行开发。
ቤተ መጻሕፍቲ ባይዱ
7.4.3 接口的声明
7.5 多态 7.5.1 多态的概念
n 可以把替代原则变换为继承机制：我们可以 将某个对象看成为所属类的实例，也可以看 成是其超类的实例。例如：Animal a = new Fish();
n 多态，是指多种表现形式。是允许将父对象 设置成为和一个或多个它的子对象相等的技 术，赋值之后，父对象就可以根据当前赋值 给它的子对象的特性以不同的方式运作；简 单的说，就是允许将子类类型赋值给父类类 型。
7.2.2 定义子类的构造方法
JAVA继承与多态
JAVA继承与多态第⼀节、继承⼀、继承的概念、格式、特点（⼀）继承的概念：1、继承是多态的前提，如果没有继承，就没有多态。
2、继承解决的主要问题是：共性抽取。
3、⾯向对象的三⼤特征：封装性、继承性、多态性。
（⼆）继承的格式⽗类的格式：（即普通类）public class ⽗类名称 {// ...}⼦类的格式：public class ⼦类名称 extends ⽗类名称 {// ...}（三）继承的三个特点(单继承、多层继承、相对继承)1、Java只⽀持单继承，不⽀持多继承。
2、Java⽀持多层继承(继承体系)。
3、⼦类和⽗类是⼀种相对的概念。
⼆、继承中的变量（⼀）成员变量的访问(直接、间接)在⽗⼦类的继承关系当中，如果成员变量重名，则创建⼦类对象时，访问有两种⽅式：1、直接通过⼦类对象访问成员变量：等号【左边】是谁，就优先⽤谁，没有则向上找。
2、间接通过成员⽅法访问成员变量：该⽅法【属于】谁，就优先⽤谁，没有则向上找。
（⼆）⼦类⽅法中重名的三种变量区分(局部、本成、⽗成)1、局部变量：直接写局员变量名2、本类的成员变量： this.成员变量名3、⽗类的成员变量： super.成员变量名三、继承中的⽅法（⼀）成员⽅法-覆盖重写1、访问：在⽗⼦类的继承关系当中，创建⼦类对象，访问成员⽅法的规则：创建的对象是谁，就优先⽤谁，如果没有则向上找。
注意事项：⽆论是成员⽅法还是成员变量，如果没有都是向上找⽗类，绝对不会向下找⼦类的。
重写（Override）：⽅法的名称⼀样，参数列表【也⼀样】。
覆盖、覆写。
重载（Overload）：⽅法的名称⼀样，参数列表【不⼀样】。
2、重写（Override）概念：重写要求两同两⼩⼀⼤原则：⽅法名相同，参数类型相同，⼦类返回类型⼩于等于⽗类⽅法返回类型，⼦类抛出异常⼩于等于⽗类⽅法抛出异常，⼦类访问权限⼤于等于⽗类⽅法访问权限。
（1）必须保证⽗⼦类之间⽅法的名称相同，参数列表也相同。
java继承与多态全解
4.3.2 覆盖实现多态性
在覆盖实现多态性的方式中，子类重定义父类方法，此时方 法的名字、参数个数、类型、顺序完全一样，那么如何区别 这些同名的不同方法呢？
由于这些方法是存在于一个类层次构造的不同类中的，在调 用方法时只需要指明调用哪个类〔或对象〕的方法，就很容 易把它们区分开来，其调用形式为：
例如，IP 的计费，假设建立IP_Phone类的对象my，其调用
来自继承父类
Telephone的5个根 本域
double monthFee;
来自继承父类Fixed_Telephone
boolean longdistanceService; boolean internationalService;
子类Ordinary_phone类中声明的域
4.2.2 域的继承与隐藏
❖何时选择继承? ❖一个很好的经历：“B是一个A吗?〞 ❖假如是那么让B做A的子类.
4.1.2 类的层次
❖ Java语言中类的是有严格的层次构造的。 ❖ 除Object类之外，每个类都继承惟一的父类。这种继承性
性质使得类的层次构造形成了如下图的一种树状构造。 ❖ Object类定义和实现了Java系统所需要的众多类的共同行
A.data_a=3
}
}
B.data_a=5
4.2.2 域的继承与隐藏
电话类
剩余金额、电话号码 计费方式、查询余额
固定电话
座机费 计费方式
普通电话
是否接通长途 剩余金额 计费方式
隐藏父类的剩余金额
4.2.3 方法的继承与覆盖
1. 方法的继承
父类的非私有方法可以被子类所继承。根据方法的继承关系，
4.1.1 继承的概念
一个父类可以同时拥有多个子类，而每一个子类那么是对公 共域和方法在功能、内涵方面的扩展和延伸。 父类、子类间的关系具有： ·共享性 即子类可以共享父类的公共域和方法。 ·差异性 即子类和父类一定会存在某些差异，否那么就应该 是同一个类。 ·层次性 即由Java规定的单继承性，每个类都处于继承关系 中的某一个层面。
Java上第七章 继承和多态
间的关系，熟练使用继承 创建类。 • 理解多态的含义，能够通过编码体现出 动态绑定。 • 熟练运用类型转换的功能。
类与类之间的关系
在现实世界中，很多类之间是有关系的， 主要有下列三种。 • is a ：继承关系 • has a ：聚合关系 • use a ：依赖关系
Instanceof运算符
语法： 对象变量 instanceof 类名 上面的语法是一个表达式，返回值是布尔 型。其意义是：如果运算符左侧的变量是运 算符右侧的类的一个实例，则表达式的值为 true，否则为false。 注意：只有存在继承关系的类和对象之间 才可以使用instanceof运算符进行检查判断。
谢 谢！
多态 – 3
多态：一种对象多种形态。 范例解析： Person p1 = new Student("wang",20,100); Person p2 = new Person("zhao",22); p1.walk(); //调用Student类中的walk方法 p2.walk(); //调用Person类中的walk方法
继承 - 3
Java规定，一个子类只能有一个父类，叫 做单一继承，Java不支持多重继承。 注意：如果定义类时不写extends关键声明 继承关系，则系统默认继承Object类。 Object类是java中最上层的根类。
继承 - 4
定义子类成员变量时，有三种可能： 1、没有定义子类特殊成员。 2、定义与父类同名成员。 3、定义子类特有成员。 练习：为Student类中加入一个学生特有的 属性。
继承 - 5
定义子类构造方法时用super调用超类构造 方法，当构造方法第一句不是用this调用本 类其它的构造方法，或者不是用super调用超 类的构造方法，则系统会默认调用super()。 练习：为Student类中加入两个构造方法。
- 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的使用必须有继承关系。