Java讲义与实例第三章继承和多态

继承的优点
继承的优点
代码的可重用性
可以轻松地自定义 子类 设计应用程序变 得更加简单
父类的属性和方 法可用于子类
继承的使用原则
在现实生活中,我们能发现 在现实生活中 我们能发现 很多类似的现象
人 类 女人 类
父类
男人 类
父类/ 父类/子类 是相对的 青蛙 类 美女 类
帅哥 类
哥斯拉 类
子类
• 如果两个对象预计具有共同的行为和特征，那么使用继承设计 继承的使用原则 他们的种类是比较好的 . • 对于不同的特征和行为,在子类里可以重新定义 • 允许同一父类的不同子类具有相同的行为(至少行为共享),但具 体的实现方式不同－－多态
继承的由来
父类
子类
子类
public class Father {
继承的由来
//房产 房产 public int house; class Boy extends Father { //乐于助人 乐于助人 //有女朋友 有女朋友 puቤተ መጻሕፍቲ ባይዱlic void help(){ int girlFriend;帮助他人 System.out.println("帮助他人 帮助他人"); //爱国人士 爱国人士 } public class Daughter public void patriotic(){ extends Father { System.out.println("大儿子爱国 曾经是一名军人 大儿子爱国 曾经是一名军人"); } //有男朋友 有男朋友 } int boyFriend; //爱漂亮public static void main(String[] 爱漂亮 public void{ args) loveBbeautiful(){ 各个子类里的相同特征和行为已经被放在了 System.out.println("小女爱打扮，爱漂亮 小女爱打扮， Boy boy=new 小女爱打扮 爱漂亮"); Boy(); 父类里,一般不需要再实现了 我们只需要在女 父类里 一般不需要再实现了.我们只需要在女 一般不需要再实现了 我们只需要在 } //继承父类，也乐于帮人 继承父类， 继承父类 儿和儿子里实现它们的不同之处 boy.help(); public static void main(String[] args) { } Daughter daughter=new Daughter(); //继承父类，也乐于帮人 继承父类， 继承父类 } daughter.help(); } }

1. 理解继承的概念及其在Java中的应用。

2. 掌握如何使用extends关键字来实现继承。

3. 理解多态的概念及其在Java中的应用。

4. 掌握如何使用implements关键字来实现多态。

5. 能够运用继承和多态编写更加灵活和可扩展的Java程序。

二、教学内容1. 继承的概念和作用引入继承的概念，解释其作用和意义。

通过实例演示继承的效果。

2. 使用extends关键字实现继承介绍extends关键字的用法。

示例演示如何使用extends实现继承。

3. 多态的概念和作用引入多态的概念，解释其作用和意义。

通过实例演示多态的效果。

4. 使用implements关键字实现多态介绍implements关键字的用法。

示例演示如何使用implements实现多态。

5. 继承和多态的联合使用解释继承和多态联合使用的效果。

通过实例演示继承和多态的联合使用。

1. 采用案例教学法，通过具体的实例来讲解继承和多态的概念和使用方法。

2. 使用互动式教学法，鼓励学生积极参与讨论和提问，以加深对知识点的理解。

3. 使用代码演示和调试，让学生直观地看到继承和多态的效果。

四、教学步骤1. 引入继承的概念，解释其作用和意义。

2. 介绍extends关键字的用法，并通过示例演示如何使用extends实现继承。

3. 引入多态的概念，解释其作用和意义。

4. 介绍implements关键字的用法，并通过示例演示如何使用implements实现多态。

5. 示例演示继承和多态的联合使用。

五、教学评估1. 课堂练习：要求学生编写简单的Java程序，运用继承和多态来实现特定的功能。

2. 课后作业：布置相关的编程作业，要求学生运用继承和多态来解决实际问题。

3. 课堂讨论：鼓励学生积极参与讨论，提问和解答问题，以评估学生对知识点的理解程度。

六、教学内容（续）6. 继承和多态的应用场景分析实际编程场景中继承和多态的运用。

通过案例展示继承和多态如何提高代码的可复用性和可维护性。

static
//静态初始化块
{ 静态成员变量的初始化;
} 【例3.2】封装的日期类。
态成员变量 MyDate.thisYear 2009
静态成员变量 MyDate.thisYear 2009
实例成员 实变 例量 成员d变 1.y量eard1d.1y.emarondt1h.mdo1n.dthayd1.day
System.out.println(“d1:”+d1+“d2:”+d2+” d1==d2?”+
(d1==d2)+”,d1.equals(d2)?”+(d1.equals(d2)));
}
}
3.1.2 对象
4. 对象的引用模型
实例 year month day
year month day
d1
000
d1 2009 7 16
《Java程序设计实用教程(第3版)》
3.1.2 对象
一个对象的生命周期是： 创建→运行→消亡。
1. 声明对象
类 对象 MyDate d;
2. 创建实例
对象 = new 类的构造方法([参数列表])
d=new MyDate()；或 MyDate d=new MyDate()；
《Java程序设计实用教程(第3版)》
(d) 修改d2实例的成员 变量值，影响d1对象
3.1.2 对象
5. 对象的关系运算与比较相等
d1
2009 7 16
d2
9 7 16
MyDate d2 = d1; (a) 两个对象引用一个实例，
MyDate d2 = new MyDate(); d2.set(d1);
{

一、访问控制符（1）类的访问权限：①公共访问权限（public）。

②包访问权限。

（2）成员的访问权限① public② private③ protected④默认包访问★结论：public 包访问protected p 相同包中的非子类中被访问YES YES YES相同包中的子类中被访问YES YES YES不同包中的非子类中被访问YES NO NO不同包中的子类中被访问YES NO NO二、继承（一）Java中继承的实现① extends关键字例题：class Person {String name;int age;void walk(){System.out.println("会走路");}}class Student extends Person{String no;void takeLessons(){System.out.println("我喜欢所有的课程");}}（二）构造方法在继承中的作用①若子类没有定义构造方法，创建对象时将无条件的调用父类的无参构造方法。

②对于父类的有参构造方法，子类可以在自己的构造方法中使用关键字super来调用它，但super语句必须是子的第一条语句。

③子类在自己的构造方法中如果没有使用super明确调用父类的构造方法，则在创建对象时，将自动先执行父类方法，然后再执行自己定义的构造方法。

例题：class Parent{String my;public Parent(String x){my=x;}}public class SubClassextendsParent{public static voidmain(String[] args){}}（三）子类的继承性①子类和父类在同一包中的继承性：例题：②子类和父类不在同一个包中的继承性：例题：★结论：public 包访问protected p 可被相同包中的子类继承后直接访问YES YES YES可被不同包中的子类继承后直接访问YES NO YES（四）变量的继承和隐藏例题：class Parent{int a=3;int m=2;}public class SubClass extends Parent{int a=4;int b=1;public static voidmain(String[] args){SubClass my=new SubClass();System.out.println("a="+my.a+",b="+my.b+",m="+my.m);}}三、多态性①方法的重载例题：public classA{int x=0;void test(int x){System.out.println("test(int):"+x);}void test(long x){System.out.println("test(long):"+x);}void test(double x){System.out.println("test(double):"+x);}public static void main(String[] args){Aa1=new A();a1.test(5.0);a1.test(5);}}★方法的覆盖例题：class A{int x=0;voidtest(int x){System.out.println("inA.test(int):"+x);}voidtest(long x){System.out.println("inA.test(long):"+x);}voidtest(double x){System.out.println("inA.test(double):"+x);}}public class B extends A{voidtest(int x){System.out.println("inB.test(int)"+x);}voidtest(String x,int y){System.out.println("inB.test(String,int):"+x+","+y);}publicstatic void main(String[] args){B b1=new B();b1.test("abcd",10);b1.test(5);b1.test(5.0);}}②运行时刻多态例题：class Animal{voidcry(){}}class Cat extends Animal{voidcry(){System.out.println("喵喵...");}}class Dog extends Animal{voidcry(){System.out.println("汪汪...");}}public class TestCry{publicstatic void main(String[] args){Animal a=new Cat();a.cry();a=new Dog();a.cry();}}四、this和super（一）关键字this关键字this表示“当前对象”。

• •
预习检查 举例说明在什么样的情况下， 举例说明在什么样的情况下，需要使用到 继承？ 继承？ 在Java程序中，多态性带给我们的好处是 程序中， 程序中 什么？ 什么？
本章任务
• 使用继承提高代码的复用性
– 我们编写的代码要精简也就是编写一次，并 我们编写的代码要精简也就是编写一次， 且只编写一次。 且只编写一次。这是我们在做面向对象编程 时非常重要的原则。 时非常重要的原则。
}
private String name; // 教员姓名 private String name; // 教员姓名 private String school; // 所在中心 private String school; // 所在中心 public DotNetTeacher(String myName, public JavaTeacher(String myName, String mySchool) { String mySchool) { name = myName; name = myName; school = mySchool; school = mySchool; } } public void giveLession(){ System.out.println("启动 Visual public void giveLession(){ 启动 System.out.println("启动 Eclipse"); 启动 Studio 2005"); System.out.println("知识点讲解 知识点讲解"); 知识点讲解 System.out.println("知识点讲解 知识点讲解"); 知识点讲解 System.out.println("总结提问 总结提问"); 总结提问 System.out.println("总结提问 总结提问"); 总结提问 } } public void introduction() { public void introduction() { System.out.println("大家好！我是 大家好！ 大家好 我是" System.out.println("大家好！我是 大家好！ 大家好 我是" + school + "的" + name + "."); 的 + school + "的" + name + "."); 的 } } } 代码存在重复，违背了“ 代码存在重复，违背了“write once, only once”的原则 ”

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的封装，继承和多态类和对象类类声明 { 成员变量的声明； 成员方法的声明及实现； }声明类：[修饰符] class 类<泛型> [extends 父类] [implements 接口列表]声明成员变量：[修饰符]数据类型 变量[=表达式]{,变量[=表达式]}成员方法声明：[修饰符]返回值类型 方法（[形式参数列表]）[throws 异常类列表]{语句序列；[return[返回值]]； }重载：一个类中可以有多个同名的成员方法，前提是参数列表不同，称为类的成员方法重载，重载的多个方法为一种功能提供多种实现。

重载方法之间必须以不同的参数列表（数据类型、参数个数、参数次序）来区别。

例如，MyDate 类可声明多个重载的set()方法如下: void set(int y,int m, int d)void set(int m, int d) //重载方法，参数个数不同void set(int d) void set(MyDate date)//重载方法，参数的数据类型不同对象对象声明：类 对象构造实例：对象 = new 类的构造方法（[实际参数列表]）引用对象的成员变量和调用成员方法：对象.成员变量 对象.成员方法([实际参数列表])类的封装性构造与析构类的构造方法用于创建类的一个实例并对实例的成员变量进行初始化一个类可声明多个构造方法对成员变量进行不同需求的初始化，构造方法不需要写返回值类型，因为它返回的就是该类的一个实例。

例：MyDate类声明以下构造方法:public MyDate(int year, int month, int day)// 声明构造方法，方法名同类名，初始化成员变量 {set(year, month day);// 调用 set()方法，为成员变量赋值}使用new运算符调用指定类的构造方法，实际参数列表必须符合构造方法声明。

例如:MyDate d1 = new MyDate(2017,10,1);//创建实例并初始化成员变量当一个类没有声明构造方法时，Java 自动为该类提供一个无参数的默认构造方法对象的引用与运算this引用访问本类的成员变量和成员方法：this.成员变量，this.成员方法([实际参数列表])调用本类重载的构造方法：this([实际参数列表])访问控制类的访问控制权限公有和(public)和缺省类中成员4级访问控制权限及范围声明set()和get()方法存取对象的属性例：public void set(int year, int month, int day) //设置日期值 public void set(MyDate date)//设置日期值，重载 public int getYear()//获得年份 public int getMonth()// 获得月份 public int getDay()//获得当月日期静态成员定义及访问格式使用关键字static声明的成员称为静态成员在类内部，可直接访问静态成员，省略类名。

4.7 多
态
• 前面介绍继承与覆盖以及强制类型转换时都曾提及“多态”的概 念.。多态性（Polymorphism）在实际中的含义就是不同的对象有 相同的轮廓或形态，但具体执行的过程却大相径庭。例如，驾驶员 在开车时都知道“遇到红灯时刹车”，这与驾驶员驾驶的是什么型 号的车无关，所有的车都具有相同的轮廓或形态的刹车。 • 多态有两种用法：重载、覆盖。 • 在Java开发中，基于继承的多态就是指对象功能的调用者用超类的 引用来进行方法调用。这样，可以提高灵活性，因为用超类的引用 能调用各种不同的子类实现，就像汽车驾驶员可以开各种不同的汽 车一样。 • 简单来理解，多态就是“一个名称多个含义”，比如我们常说哺乳 动物会发出“叫”声，然后又会说狗会“叫”，猫会“叫”
4.1.1 超类、子类
• 被继承的类一般称为“超类”或“父类”，继承的类称为 “子类”。当子类继承超类时，不需声明该类继承了的已定 义的超类的实例变量和方法,子类体内只需写出新增的变量 和方法即可。超类、子类是继承中非常重要的概念，它们形 象地描述了继承的层次关系。 • 继承节省了定义新类的大量工作，可以方便地重用代码。例 如，把汽车作为父类，当创建汽车的子类轿车时，品牌、价 格、最高时速等属性会自动地被定义，调用刹车方法时会自 动调用在汽车类中定义的刹车方法。但一个子类不必非要使 用继承下来的属性和方法，一个子类可以选择覆盖已有的属 性和方法，或添加新的属性和方法。
多态性
例如,Student是Person的子类,
• 编译时多态性
Person p1 = new Person("李小明",21); //对象获得本类的实例，对象与其获得的实例类型一致 Student s1 = new Student("王大伟",19); p1.print(); //编译时多态性，执行Person类的方法 s1.print(); //编译时多态性，执行Student类覆盖的方法

9
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日星期三

stu.setAge(30) ;//从Person继承而来
stu.setSchool("清华大学") ;//自己定义的方法
System.out.println("姓名：" + stu.getName()) ;
System.out.println("年龄：" + stu.getAge()) ;
System.out.println("学校：" + stu.getSchool()) ;
int sno;
String department;
}
public class TestStudent {
public static void main(String[] args) {
Student st=new Student();
="张三";
st.age=18;
st.sex='男';
StudentA obj2 =new StudentA("张三",18,1); //调用有参构造方法创建对象
obj1.pprint(); //调用父类的成员方法
obj1.sprint(); //调用子类的成员方法
obj2.pprint(); //调用父类的成员方法
obj2.sprint(); //调用子类的成员方法
class Student{
System.out.println("class:Person:"+" Name:"++" age:"+this.age);
}
}
class StudentA extends PersonA {

《Java面向对象程序设计-继承和多态》教案一、教学目标：1. 理解继承的概念及其在Java中的应用。

2. 掌握如何使用extends关键字来实现继承。

3. 理解多态的概念及其在Java中的应用。

4. 掌握如何使用implements关键字来实现多态。

5. 能够运用继承和多态编写更简洁、易维护的Java代码。

二、教学内容：1. 继承的概念和原理2. extends关键字的用法3. 多态的概念和原理4. implements关键字的用法5. 继承和多态的应用案例三、教学方法：1. 讲授：讲解继承和多态的基本概念、原理和用法。

2. 演示：通过示例代码展示继承和多态的应用。

3. 练习：让学生动手编写代码，加深对继承和多态的理解。

4. 讨论：分组讨论实际应用场景中如何使用继承和多态，分享心得。

四、教学准备：1. 讲义：提供详细的继承和多态概念、用法讲解。

2. 示例代码：准备继承和多态的示例代码。

3. 编程环境：确保学生能够使用IDE（如Eclipse、IntelliJ IDEA等）或文本编辑器进行代码编写。

五、教学步骤：1. 引入：简要介绍继承和多态的概念，激发学生的兴趣。

2. 讲解：详细讲解继承和多态的原理、用法，并通过示例代码进行演示。

3. 练习：布置练习题，让学生动手编写代码，巩固所学内容。

4. 讨论：组织学生分组讨论实际应用场景中如何使用继承和多态，分享心得。

5. 总结：回顾本节课所学内容，强调重点知识点。

6. 作业：布置课后作业，巩固所学知识。

六、教学评估：1. 课堂互动：观察学生在课堂上的参与程度，了解他们对继承和多态的理解程度。

2. 练习作业：评估学生的练习作业，检查他们对继承和多态的掌握情况。

3. 课后反馈：收集学生的课后反馈，了解他们对课堂内容的满意度和建议。

七、教学拓展：1. 深入讲解Java中的继承和多态的其他高级特性，如接口、抽象类、动态绑定等。

2. 通过案例分析，让学生了解继承和多态在实际项目中的应用和优势。

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类只能有⼀个⽗类。

一、教学目标1. 理解继承的概念及其在Java中的实现。

2. 掌握如何使用继承来复用代码和实现接口。

3. 理解多态的概念及其在Java中的应用。

4. 掌握如何通过方法重写和接口实现来实现多态。

5. 能够运用继承和多态编写更加灵活和可扩展的Java程序。

二、教学内容1. 继承的概念和原理定义：继承是面向对象编程中的一种关系，允许一个类（子类）继承另一个类（父类）的属性和方法。

作用：实现代码复用，减少重复代码。

2. Java中的继承语法：class 子类extends 父类示例：通过一个简单的继承例子来展示如何使用继承。

3. 访问修饰符公共（public）、默认（default）、私有（private）和受保护（protected）修饰符在继承中的作用。

示例：演示不同修饰符对继承的影响。

4. 方法重写（Overriding）概念：子类重写父类中的方法。

规则：方法名、参数列表和返回类型必须与父类中的方法相同。

示例：通过一个例子展示如何重写方法，并解释其意义。

5. 多态的概念定义：多态允许一个接口具有多个不同的实现。

类型：编译时多态（静态多态）和运行时多态（动态多态）。

三、教学方法1. 讲授法：讲解继承和多态的基本概念。

2. 示例法：通过具体的代码示例来展示继承和多态的应用。

3. 互动提问：鼓励学生提问，并针对学生的疑问进行解答。

4. 练习法：提供练习题，让学生通过编写代码来加深对知识点的理解。

四、教学步骤1. 引入：通过一个现实生活中的例子（如交通工具）来引出继承的概念。

2. 讲解：详细讲解继承的语法和规则，并通过代码示例展示如何实现继承。

3. 演示：通过示例解释访问修饰符在继承中的作用。

4. 讲解：介绍方法重写的概念和规则，并通过示例展示如何重写方法。

5. 引入：通过一个图形绘制例子引入多态的概念。

6. 讲解：详细讲解多态的原理和应用，并通过代码示例展示多态的实现。

五、教学评估1. 课堂提问：通过提问了解学生对继承和多态的理解程度。

一切类的“祖先”——Object
在Java 中，所有的Java类都直接或间接地继承了ng.Object类
public class MyObject { //… } public class MyObect extends Object { //… }
学习java API文档了解下面内容： object类，它是所有类的根点，所有类从它继承。 equals，两空值进行比较永远返回 false。 Java中对 String类 中的 equals方法进行了重写。
转型规则
父类的引用变量可以指向一个子类的对象，但不可以 访问子类中新增加的成员(方法和变量)； 父类对象不能操作子类声明定义的成员变量；也不能 使用子类声明定义的方法。 父类对象可以调用子类重写的实例方法。 父类对象可以调用子类继承的成员变量和隐藏的成员 变量。 可以将对象的父类对象再强制转换到一个子类对象， 这时，该子类对象又具备了子类所有属性和功能 如果子类重写了父类中的类方法，通过父类对象引用 的是父类中的类方法
继承与方法重写
子类自动继承父类的属性和方法，子类中可以定义特定的属性和方法
public class Teacher { private String name; // 教师姓名 private String center;// 所在单位 public Teacher (String myName, String myCenter) { //初始化属性值 } public void giveLesson() { //授课方法的具体实现 } public void introduction() { //自我介绍方法的具体实现 } } public class SoftwareTeacher extends Teacher public SoftwareTeacher(String myName, String myCenter) { super(myName, myCenter); } public void giveLesson(){ System.out.println(“使用电脑授课"); super.giveLesson(); } }

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）必须保证⽗⼦类之间⽅法的名称相同，参数列表也相同。