第7课件 封装、继承和多态(4学时 19-22)
Java核心逻辑第7章_封装、继承、多态
Pet pet = new Dog();
实现多态的两种形式
▪ 使用父类作为方法形参实现多态 ▪ 使用父类作为方法返回值实现多态
如何实现多态
实现多态的两个要素 自动类型转换
第三十六页，编辑于星期四：十点 三十四分。
使用多态优化主人给宠物喂食
使用多态
public class Master {
问题
▪ 如果再领养XXX宠物，就需要给XXX喂食，怎么办？
✓ 添加XXX类，继承Pet类，实现吃食方法 ✓ 修改Master类，添加给XXX喂食的方法
第三十三页，编辑于星期四：十点 三十四分。
为什么使用多态
主人类
public class Master {
public void feed( Dog dog ) { dog.eat();
super()思考题
第十九页，编辑于星期四：十点 三十四分。
super()总结
每一个子类的构造方法在没有显示调用super()系统都会提 供一个默认的super()
super() 书写在第一行 可以在子类构造方法中显示调用super(),完成对特定父类构
造方法的调用 ✓super不能访问父类的private成员
第七页，编辑于星期四：十点 三十四分。
封装练习
需求说明
▪ 使用封装描述宠物信息，小猫和企鹅 ▪ 小猫：昵称、健康值、亲密度、种类和自身信息显示
▪ 企鹅：昵称、健康值、亲密度、性别和自身信息显示
第八页，编辑于星期四：十点 三十四分。
分析代码
Dog - name:String - health:int - love:int - strain:String + print():void + getName():String + getHealth ():int + getLove():int + getStrain:String + Dog()
第7章-单继承与多态PPT幻灯片
AlarmClock类中的成员函数ShowTime()覆盖了基类Clock中的
同名成员函数ShowTime()。
9
7.1.2 派生类实现
(3) 添加新成员 派生类在继承基类成员的基础之上，根据派生类的
实际需要，增加一些新的数据成员和函数成员，以描 述某些新的属性和行为。如：AlarmClock添加了数 据成员AH、AM、OpenAlarm, 成员函数SetAlarm()、 SwitchAlarm()。
类以另一个类对象做数据成员，成为组合。组合描述的 是整体与部分的关系，类与类之间体现的是“is a part of”， 即如果在逻辑上A是B的一部分（is a part of），则允许A和其 他数据成员组合为B。例如：发动机、车轮、电池、车门、方 向盘、底盘都是小汽车的一部分，它们组合成汽车。而不能 说发动机是汽车的一种。
7 class Circle :public Point
8{
9 private:
10
double radius; //半径
11 public:
12
Circle(double R, int X, int Y):Point(X,Y)
13
{
14
radius=R;
15
}
类名
16
double area() //求面积
什么时候使用继承，什么时候使用组合，要根据 问题类与类之间的具体关系，顺其自然，权衡考虑。
例：p354
13
7. 1.4继承的方式p389
7.1.4 公有继承
公有方式继承的特点： ① 基类的公有成员在派生类中仍然为公有成员，可以由派
生类对象和派生类成员函数直接访问。 ② 基类的私有成员在派生类中，无论是派生类的成员还是派
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
c#ppt05-面向对象编程(二)继承封装和多态PPT教学课件
分别使用了自己 和父类的方法。
8
class parent
{ two two1= new two(); one one1 = two1; one one2 = new one(); //m1指向m2实例 two1.y(); one1.y(); one2.y();
Console.ReadLine();
class two : one {
} }
public override void y() //重写同名方法
class Student: Person
{ string school;
int score; }
子类比父类多了两个成员： school、score。
3、域的隐藏：子类重新定义一个从父类中继承的域变量，但通 常会被认为是一个糟糕的设计。
class A{ public int a; }
使用new修饰符来 隐藏父类的同名成
2020/12/10
7
方法重载举例
class parent { public int add( int x,int y ) { return(x+y); } }
class child : parent {
public int add(int x, int y, int z) { return (x + y + z); } public static void Main() {
2020/12/10
继承与多态课件ppt
• 类的对象成员与类的一般数据成员的构造顺序？
先构造类的对象成员，再构造一般数据成员(执 行类自身的构造函数体)。
• 构造顺序与析构顺序的关系？
二者顺序相反：先构造者，后析构。
继承
多继承：一个类从多个基类派生，这样的继
承结构称为多继承
Father
int leg; int body; Public: …… };
Class teacher:public human { string name; h1 Public: …… };
• 派生类对象的空间占用≥基类对象的空间占用
继承
类内的访问控制：派生类是否能访问所有基类 成员？
对于基类的私有成员，派生类不能直接访问 protected的作用：只能让子类访问而不能让
• 练习2：设计一个虚基类base，包含姓名和 年龄私有数据成员以及相关的成员函数， 由它派生出领导类leader，包含职务和部门 私有数据成员以及相关的成员函数。再由 base派 生出工程师类engineer，包含职称 和专业私有数据成员以及相关的成员函数。 然后由leader和engineer类派生出主任工程 师类chairman。采用一些数据进行测试。
派生类（子类）
human teacher
通常有关系：子类 is a 父类
继承
Inheritance
继承
继承
Student
Employee
GradStudent
Manager
Fig.1 单重继承
Vehicle
Father
Mather
Car Coupe Fig.2 多层继承
Child
Fig.3 多重继承
《Java知识点总结系列》第七章——封装、继承、多态篇
面向对象的三大特性封装继承多态知识点预览封装的概念继承的概念访问修饰符方法的覆盖（Override）super关键字多态的概念强制类型转换与instanceof关键字封装的概念1. 什么是封装通过边界将内部组成部分与外部分开2. 封装的好处a) 提高一个物体内部组成部分的安全性b) 向外部屏蔽物体内部组成部分的差异私有访问修饰符private2个方法获得设置3. 封装的内容a) 属性----->必须b) 方法根据需要封装c) 方法声明公开方法实现封装 ------->思想继承的概念1. 什么是继承2. 继承的语法a) extends关键字;b) 继承的好处：提高代码的复用性3. 子类对象的扩展4. Java语言中继承的特点a) Java语言中继承是单继承（最多有一个直接父类）b) Java中单继承的好处几何拓扑：树状结构较简单易于实现5. 继承关系在内存中的表现形式JVM开辟连续的存储空间（父类、子类）6. 对象的创建过程\new Dog();a) 分配空间（父类对象空间子类对象空间）b)初始化属性递归的构造父类对象调用构造方法c) 初始化属性d) 调用构造方法Java中的访问修饰符1. 什么是Java中的访问修饰符式privatepublicdefaultprotected2. Java中的访问修饰符方法的覆盖（Override）1. 什么是方法的覆盖子类对从父类继承的方法重新实现2. 方法覆盖的要求a) 子类覆盖方法的访问修饰符范围必须大于或者等于父类对应方法的访问修饰符范围b) 子类覆盖方法的返回值类型必须和父类方法一致c) 覆盖方法的参数必须和父类方法一致super关键字1. super代表父类对象a) super.属性子类、父类出现同名，子类中访问父类属性b) super();在付了构造方法中调用父类构造方法2.super()总结a) 每一个子类的构造方法没有显示调用super()，系统都会提供一个默认的super();（子类编译完后编译器默认加上super()，调用无参构造）b) super()书写在第一行;c) 可以在父类构造方法红枣年糕显示调用super()实现对特定父类构造方法的调用。
封装继承多态
JAVA封装,继承,多态2013-03-10 18:34:32| 分类：默认分类| 标签：|举报|字号大中小订阅1、封装封装:把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。
是软件设计模块化、软件复用和软件维护的一个基础。
属性的封装:java中类的属性的访问权限的默认值不是private，要想隐藏该属性，需加private（私有）修饰符，来限制只能够在类的内部进行访问。
对于类中的私有属性，必须对其给出一对方法（getXxx(),setXxx()）访问私有属性，保证对私有属性的操作的安全性。
方法的封装:对于方法的封装，对外部可调用的方法声明为public,而对外隐藏的数据操作则需要声明为private,封装会使方法实现的改变对架构的影响最小化。
完全的封装，类的属性全部私有化，并且提供一对方法（getXxx(),setXxx()）来访问属性。
2、继承继承，是对有着共同特性的多类事物，进行再抽象成一个类。
这个类就是多类事物的父类。
父类的意义在于抽取多类事物的共性。
java中的继承要使用extends关键字，并且java中只允许单继承，也就是一个类只能有一个父类。
是继承关系呈树状，体现了java的简单性。
子类只能继承在父类中可以访问的属性和方法（实际上父类中私有的属性和方法也会被继承但子类中无法访问而已）。
访问控制修饰符:（可以修饰属性和方法）private修饰符，表示只有本类内部可以访问。
default修饰符，方法不加修饰符，会默认为default，表示在同一个包中可以访问，父子类在同一包中，子类可以继承父类的相应内容。
（可以修饰类）protected（保护）修饰符，表示同一包中可以访问，不同包的子类也可以访问继承。
public修饰符，表示公开，在任何地方都可以访问。
（可以修饰类）修饰符的权限是由上而下逐渐变宽的。
继承的意义，在于子类可以在父类的基础之上对父类的功能进行发展,继承可以使系统的耦合性降低，也就是使对象间的联系变得松散，使多类对象间的联系可以用其父类对象代替。
《继承和多态》PPT课件
public class InheritDemo3 extends SuperClass{
float a =4f; public void print(){
int a =5; super.print(); System.out.println("InheritDemo2" System.out.println(a); System.out.println(this.a); System.out.println(super.a); } public static void main(String args[]){ InheritDemo3 id3 = new InheritDemo3(); id3.print(); } }
精选PPT
6
多态的概念
多态是指在一棵继承树中的类可以有多个同名但不同方法体 以及不同形参的方法。
两种情况：
➢ 覆盖：在子类中直接定义和父类同样的属性和方法，但重 新编写了方法体，即子类与父类方法的星参与返回值都相 同，而内部处理不同，这种方法在使用过程中，Java虚拟 机会根据调用这个方法的类来确定哪个方法被调用
return super.a;
Father x=new Father();
}}
Son y=new Son();
System.out.println("a of son is :" +y.a);
System.out.println("a of son's super is :" +y.getA());
Cleanser.main(arg); }
}
精选PPT
13
• 特殊引用:this和super
第七章类的封装、多态和继承
// 定义类的protected 方法，通过创建对象来引用此方法
class Max7_5{
private int x,y;
protected int play(int s,int t)
{ int m; x=s;
使用 protected定
y=t;
义的成员变量
m=(x>y)?x/y:y/x; return m; }
public class Account7_3
{
public String name;
public String address; public double balance; public void display() { System.out.print(" name:");
这里创建了一个包其 名字叫bag，并且将编 译后的 Account7_3.class 文
System.out.println(name);
件装入包中
System.out.print(" Address:");
System.out.println( address);
System.out.print(" balance:");
System.out.println( balance);
}
}
//使用import引入已经定义的，属性为public的 Account7_3类 ，引用其方法
import bag.Account7_3 ;
//引用公共类Account7_3
public class Useraccount7_3
{
public static void main(String args[])
面向对象编程二继承封装和多态
c1.add(4,5);
}
可编辑ppt
7
方法隐藏举例
class parent
{ public int add( int x,int y )
{ return(x+y); }
class child:parent
{ new public int add(int x,int y)
{Console.WriteLine(“two_x”);}
two_x
public override void y( )//重写同名方法
two_y
{ Console.WriteLine(“two_y”);}
可编辑ppt
two_y
9
4.3.2 类的封装
类的封装改变了用户传统的使用数据和代码的方式，它将方 法和数据包含在一起构成一个独立的单元，可以通过设定单元 内各个成员的的特性来控制对成员的访问。比如将一个字段定 义为private，就可以防止外界直接访问这个字段。 封装一个类由两种做法： 1）为一个私有类定义公共读方法和写方法； 2）使用属性，用set和get访问器。
{ string school;
int score; } 子类比父类多了两个成员： school、score。
3、域的隐藏：子类重新定义一个从父类中继承的域变量。
class A{ public int a; } class B:A { new public int a;}
可编辑ppt
使用new修饰符来
可编辑ppt
10
public class Student
{ private string studentname;
public string getstudentname( )
《继承与多态》课件
可读性和复用性，减少代码冗余。
总结
4
继承和多态是面向对象编程中重要的 思想和方法，对于软件开发具有重要
意义。
多态可以通过方法重写和方法重载来实现， 使不同的对象可以对同一方法表现出不同 的行为。
3 多态的好处
4 多态的注意事项
多态提高了代码的灵活性和可扩展性，使 代码更易于维护和扩展。
在使用多态时，需要注意方法的参数类型 和返回值类型，以避免类型错误导致的运 行时错误。
三、继承与多态的实例
实例介绍
通过一个学校的班级管理系统实例，演示继承和 多态的实际应用。
《继承与多态》PPT课件
本课程介绍继承与多态的概念和应用。通过丰富的实例和实践演示，帮助学 生深入理解这些重要的面向对象编程概念。
一、继承
什么是继承
继承是面向对象编程中的重要概念，允许子 类继承父类的属性和方法。
继承的实现方式
继承可以通过使用关键字extends将子类与父 类联系起来，形成继承关系。
实例演示
展示如何通过继承和多态处理学生和老师的不同 操作，并实现班级管理的各项功能。
四、总结
1
继承与多态的异同
继承和多态都是面向对象编程的核心
适用场景
2
概念，但它们的实现方式和应用场景 有所不同。
继承适用于父子类之间的继承关系，
而多态适用于处理不同对象的同一操
作。
3
使用技巧
合理应用继承和多态可以提高代码的
继承的好处
通过继承，子类可以重用父类的代码，提高 开发效率，并实现代码的复用。
继承的注意事项
在继承中，需要注意继承层级、构造函数的 调用以及方法重写等问题，以确保正确的继 承操作。
二、多态
封装、继承、多态详解
封装、继承、多态详解封装、继承、多态（1）封装 封装，也就是把客观事物封装成抽象的类，并且类可以把⾃⼰的数据和⽅法只让可信的类或者对象操作，对不可信的进⾏信息隐藏。
（2）继承 继承是指这样⼀种能⼒：它可以使⽤现有类的所有功能，并在⽆需重新编写原来的类的情况下对这些功能进⾏扩展。
继承现有类 + 扩展继承概念的实现⽅式有三类：实现继承、接⼝继承和可视继承。
实现继承是指使⽤基类的属性和⽅法⽽⽆需额外编码的能⼒；接⼝继承是指仅使⽤属性和⽅法的名称、但是⼦类必须提供实现的能⼒；可视继承是指⼦窗体（类）使⽤基窗体（类）的外观和实现代码的能⼒。
（3）多态 多态性（polymorphisn）是允许你将⽗对象设置成为和⼀个或更多的他的⼦对象相等的技术，赋值之后，⽗对象就可以根据当前赋值给它的⼦对象的特性以不同的⽅式运作。
简单的说，就是⼀句话：允许将⼦类类型的指针赋值给⽗类类型的指针。
多态的作⽤：1.隐藏实现细节，使得代码能够模块化；扩展代码模块，实现代码重⽤；2.接⼝重⽤：为了类在继承和派⽣的时候，保证使⽤家族中任⼀类的实例的某⼀属性时的正确调⽤。
重载(overload)，是指允许存在多个同名函数，⽽这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。
重载的实现是：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数。
在编译期间就已经确定了，是静态的（记住：是静态）。
也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态⽆关！ 结论就是：重载只是⼀种语⾔特性，与多态⽆关，与⾯向对象也⽆关！ 覆盖(重写(override))，是指⼦类重新定义⽗类的虚函数的做法。
真正和多态相关的是“覆盖”。
当⼦类重新定义了⽗类的虚函数后，⽗类指针根据赋给它的不同的⼦类指针，动态（记住：是动态！）的调⽤属于⼦类的该函数，这样的函数调⽤在编译期间是⽆法确定的（调⽤的⼦类的虚函数的地址⽆法给出）。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
第七讲义面向对象——类
几种设计模式：
1. 当创建一个对象，若不想让对象的内容（私有成员变量）发生变化，则需要满足以下条件
(1) 所有数据域都是私有的;(2)没有修改方法setMethod;(3)没有一个访问器方法会返回一个指向可变数据域的引用。
不可变类/对象例如：String类
2. 为了防止用户创建某个类的对象，则应该定义该类的私有构造方法。
例如：Math类
3. 当只允许某个类只能创建一个实例时，称为单例模式。
一、类的封装
方法的抽象;类的抽象;(将方法的实现和使用分开| 将类的实现和使用分开)
类的用户&类的开发者
二、类的继承和多态（2个学时）
继承是java在软件重用方面最重要的特征。
能有效避免代码冗余，使系统易于理解和维护、子类继承于父类，UML图表示，次类——超类，或继承类—基类。
当子类继承父类的时候，子类可以继承父类的所有成员跟方法，继承下来不代表可以访问，要访问得看访问控制规则。
私有属性也可以继承，不过根据访问控制规则，私有属性虽继承下来却不可以访问的，只有通过public的方法访问继承下来的私有属性。
B继承A类，C继承B类。
A类中的私有属性，到了C会怎么样，能继承、访问吗？答案是：如果A中的属性有增加setget方法，可以访问的。
举例
public class A {
private int a;
public int getA(){
return a;
}
public void setA(int a){
this.a=a;
}
}
public class B extends A{
private int b;
public int getB() {
return b;
}
public void setB(int b) {
this.b = b;
}
}
public class C extends B {
private int c;
public int getC() {
return c;
}
public void setC(int c) {
this.c = c;
}
}
那么当C c1=new C（）时。
c1可以使用setA（）getA（）访问控制从A类中继承来的私
有属性a；
由于构造方法是用来构造类的实例，它不同于属性和方法，其子类是不继承父类的构造方法，
只能通过super从子类构造方法中调用。
构造方法可以调用重载的构造方法或其父类的构造方法（必须作为第一条语句），若没有显式
调用它们任何一个，则编译器会把super();作为构造方法的第一条语句，调用父类无参构造方法.
若想override一个方法，则需要使用与其父类方法相同的签名.另外实例方法只有当其是可
见的时候，才能被覆盖。
静态方法与实例方法一样可以继承，但静态方法不能被覆盖，若父类定义
的方法在子类中定义了，则父类中的静态方法被隐藏。
Java中所有的类都直接或间接继承于Object。
若没有显式指定父类，则缺省Object父类覆盖override同重载overload的区别：
Java语言的extends是不支持多重继承的，其多重继承是通过interface来实现的。
是
不支持
举例：构造方法链
举例：父类子类继承了父类的。
举例：父类和子类的访问权限关系
思考：对于父类的私有成员，子类是否已经继承，或者是否只能继承父类的可视成员？
子类可以覆盖父类的protected方法，并把它的可见性改为public，但子类不能削弱谷类
中定义的方法的可访问性。
关键字this :指向调用对象本身的引用名
关键字super :指向该类的父类的
Java面向对象关键字
成员变量限定词的含义：
•static: 静态变量（类变量）
•final: 常量；transient: 暂时性变量，用于对象存档，用于对象的串行化
•volatile: 贡献变量，用于并发线程的共享
方法的实现也包括两部分内容：方法声明和方法体。
方法声明
方法声明中的限定词的含义：
•static: 类方法，可通过类名直接调用
•abstract: 抽象方法，没有方法体
•final: 方法不能被重写
•native: 集成其它语言的代码
•synchronized: 控制多个并发线程的访问
方法声明包括方法名、返回类型和外部参数。
其中参数的类型可以是简单数据类型，也可以是复合数据类型（又称引用数据类型）。
对于简单数据类型来说，java实现的是值传递，方法接收参数的值，但不能改变这些参数的值。
如果要改变参数的值，则用引用数据类型，因为引用数据类型传递给方法的是数据在内存中的地址，方法中对数据的操作可以改变数据的值。
方法体
方法体是对方法的实现，它包括局部变量的声明以及所有合法的Java指令。
方法体中声明的局部变量的作用域在该方法内部。
若局部变量与类的成员变量同名，则类的成员变量被隐藏。
为了区别参数和类的成员变量，我们必须使用this。
this用在一个方法中引用当前对象，它的值是调用该方法的对象。
返回值须与返回类型一致，或者完全相同，或是其子类。
当返回类型是接口时，返回值必须实现该接口。
构造方法
•构造方法是一个特殊的方法。
Java 中的每个类都有构造方法，用来初始化该类的一个对象。
•构造方法具有和类名相同的名称，而且不返回任何数据类型。
•重载经常用于构造方法。
•构造方法只能由new运算符调用
封装
封装性就是尽可能的隐藏对象内部细节，对外形成一道边界，只保留有限的接口和方法与外界进行交互。
封装的原则是使对象以外的部分不能随意的访问和操作对象的内部属性，从而避免了外界对对象内部属性的破坏。
可以通过对类的成员设置一定的访问权限，实现类中成员的信息隐藏。
•private：类中限定为private的成员，只能被这个类本身访问。
如果一个类的构造方法声明为private,则其它类不能生成该类的一个实例。
•default：类中不加任何访问权限限定的成员属于缺省的（default）访问状态，可以被这个类本身和同一个包中的类所访问。
•protected：类中限定为protected的成员，可以被这个类本身、它的子类（包括同一个包中以及不同包中的子类）和同一个包中的所有其他的类访问。
•public：类中限定为public的成员，可以被所有的类访问。
继承
子类的对象拥有父类的全部属性与方法，称作子类对父类的继承。
•Java中父类可以拥有多个子类，但是子类只能继承一个父类，称为单继承。
•继承实现了代码的复用。
•Java中所有的类都是通过直接或间接地继承ng.Object类得到的。
•子类不能继承父类中访问权限为private的成员变量和方法。
•子类可以重写父类的方法，即命名与父类同名的成员变量。
Java中通过super来实现对父类成员的访问，super用来引用当前对象的父类。
super 的使用有三种情况：
•访问父类被隐藏的成员变量，如：super.variable;
•调用父类中被重写的方法，如：super.Method([paramlist]),super()调用父类构造方法;
•调用父类的构造函数，如：super([paramlist]);
多态
对象的多态性是指在父类中定义的属性或方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为。
这使得同一个属性或方法在父类及其各个子类中
具有不同的语义。
例如："几何图形"的"绘图"方法，"椭圆"和"多边形"都是"几何图"的子类，其"绘图"方法功能不同。
Java的多态性体现在两个方面：由方法重载实现的静态多态性（编译时多态）和方法重写实现的动态多态性（运行时多态）。
•编译时多态：在编译阶段，具体调用哪个被重载的方法，编译器会根据参数的不同来静态确定调用相应的方法。
•运行时多态：由于子类继承了父类所有的属性（私有的除外），所以子类对象可以作为父类对象使用。
程序中凡是使用父类对象的地方，都可以用子类对象来代替。
一个对象可以通过引用子类的实例来调用子类的方法。
重载（Overloading）
•方法重载是让类以统一的方式处理不同数据类型的手段。
•一个类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。
调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法。
•返回值类型可以相同也可以不相同，无法以返回型别作为重载函数的区分标准。
覆盖或重写（Overriding）
•子类对父类的方法进行重新编写。
如果在子类中的方法与其父类有相同的的方法名、返回类型和参数表，我们说该方法被重写 (Overriding)。
•如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。
•子类函数的访问修饰权限不能低于父类的。