重写、覆盖、重载、多态几个概念的区别分析
重写、覆盖、重载、多态几个概念的区别分析
flyings2015-01-23 09:59:40
override->重写(=覆盖)、overload->重载、polymorphism -> 多态
override是重写（覆盖）了一个方法，以实现不同的功能。一般是用于子类在继承父类时，重写（重新实现）父类中的方法。
重写（覆盖）的规则：
1、重写方法的参数列表必须完全与被重写的方法的相同,否则不能称其为重写而是重载.
2、重写方法的访问修饰符一定要大于被重写方法的访问修饰符
（public>protected>default>private）。
3、重写的方法的返回值必须和被重写的方法的返回一致；
4、重写的方法所抛出的异常必须和被重写方法的所抛出的异常一致，或者是其子类；
5、被重写的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行重写。
6、静态方法不能被重写为非静态的方法（会编译出错）。
overload是重载，一般是用于在一个类内实现若干重载的方法，这些方法的名称相同而参数形式不同。
重载的规则：
1、在使用重载时只能通过相同的方法名、不同的参数形式实现。不同的参数类型可以是不同的参数类型，不同的参数个数，不同的参数顺序（参数类型必须不一样）；
2、不能通过访问权限、返回类型、抛出的异常进行重载；
3、方法的异常类型和数目不会对重载造成影响；
多态的概念比较复杂，有多种意义的多态，一个有趣但不严谨的说法是：继承是子类使用父类的方法，而多态则是父类使用子类的方法。
一般，我们使用多态是为了避免在父类里大量重载引起代码臃肿且难于维护。
举个例子：
public class Shape
{
public static void main(String[] args){
Triangle tri = new Triangle();
System.out.println("Triangle is a type of shape? " + tri.isShape());// 继承
Shape shape = new Triangle();
System.out.println("My shape has " + shape.getSides() + " sides."); // 多态
Rectangle Rec = new Rectangle();
Shape shape2 = Rec;
System.out.println("My shape has " + shape2.getSides(Rec) + " sides."); //重载
}
public boolean isShape(){
return true;
}
public int getSides(){
return 0 ;
}
public int getSides(Triangle tri){ //重载
return 3 ;
}
public int getSides(Rectangle rec){ //重载
return 4 ;
}
}
class Triangle extends Shape
{
public int getSides() { //重写,实现多态
return 3;
}
}
class Rectangle extends Shape
{
public int getSides(int i) { //重载
return i;
}
}
注意Triangle类的方法是重写，而Rectangle类的方法是重载。对两者比较，可以发现多态对重载的优点：
如果用重载，则在父类里要对应每一个子类都重载一个取得边数的方法；
如果用多态，则父类只提供取得边数的接口，至于取得哪个形状的边数，怎样取得，在子类里各自实现(重写)。
<小结>重写，一般是子类对父类的方法重写；重载，是在一个类内，如父类内，重载几个方法名相同，但参数不同或参数类型不同的方法。
多态，就是避免父类重载过多而臃肿，只提供接口，让子类去实现(重写，实现多态)。
多态参考代码分析
1224: 多态-虚函数问题 Description 请以点类Point为基类派生出一个圆类Circle。Point类的数据成员为x、y（私有属性，存储点的横纵坐标），成员函数有构造函数Point（实现对数据成员x、y的初始化）、输出函数Display（输出点坐标）；圆类Circle的数据成员为r（私有属性，存储圆的半径，圆心的点坐标通过继承点类Point加以实现），成员函数有构造函数Circle、计算圆的面积函数Area、计算圆的周长函数Perimeter和输出函数Display，其中构造函数实现基类和圆类的数据成员的初始化，Display函数实现圆心坐标、圆的半径、圆的面积（利用Area函数实现）和圆的周长（利用Perimeter函数实现）的输出。实现Point类和Circle类的定义及成员函数。主函数的代码（不允许改动）如下： int main() { double x,y,r; cin>>x>>y>>r; //圆心的点坐标及圆的半径 Point *p; p=new Point(x,y); p->Display(); p=new Circle(x,y,r); p->Display(); return 0; } 说明：圆周率PI的取值为3.14 提示：Display应设计为虚函数 Input Output Sample Input 0 0 1 Sample Output Point(0,0) Circle's center:Point(0,0) Radius:1 Area:3.14 Perimeter:6.28 **************************************************************** #include
实验报告类的重载继承和多态
实验报告类的重载继承和多态 篇一：实验三_类的重载继承和多态_() 篇二：实验三_类的重载继承和多态 篇三：C++实验报告(类和对象重载与继承多态和模板异常和流) C++实验报告 目录 C++实验报告 ................................................ ................................................... (4) 实验一：类和对象 ................................................ ................................................... . (4) 1．................................................ ................................................... . (4) 代码 ................................................
................................................... .. (4) 运行结果 ................................................ ................................................... (5) 2.................................................. ................................................... (5) 思路： .............................................. ................................................... . (5) 代码 ................................................ ................................................... (5) 运行结果 ................................................ ...................................................
C++函数名字的隐藏：重写、重载、重定义
概要： C++中经常出现函数名字一样，但参数列表或返回值不同的函数，要搞清楚函数的正确调用关系，需理清三个概念：重写（override）、重载（overload）、重定义（redefine）。 一、三个基本概念 1、重定义（redefine）：派生类对基类的成员函数重新定义，即派生类定义了某个函数，该函数的名字与基类中的函数名字一样。 特点：（1）不在同一个作用域（分别位于基类、派生类）（2）函数的名字必须相同（3）对函数的返回值、形参列表无要求 特殊情况：若派生类定义的该函数与基类的成员函数完全一样（返回值、形参列表均相同），且基类的该函数为virtual，则属于派生类重写基类的虚函数。 作用效果：若重新定义了基类中的一个重载函数，则在派生类中，https://www.sodocs.net/doc/291042980.html,基类中该名字的函数（即其他所有重载版本）都被自动隐藏，包括同名的虚函数。 2、重载（overload）：函数名字相同，但它的形参个数或者顺序，或者类型不同，但是不能靠返回类型来判断。 特点：（1）位于同一个类中（2）函数的名字必须相同（3）形参列表不同（可能是参数个数 or 类型 or 顺序不同），返回值无要求 特殊情况：若某一个重载版本的函数前面有virtual修饰，则表示它是虚函数。但它也是属于重载的一个版本 不同的构造函数（无参构造、有参构造、拷贝构造）是重载的应用 作用效果和原理：编译器根据函数不同的参数表，将函数体与函数调用进行早绑定。重载与多态无关，只是一种语言特性，与面向对象无关。 3、重写（override）：派生类重定义基类的虚函数，即会覆盖基类的虚函 数（多态性） 特点：（1）不在同一个作用域（分别位于基类、派生类）（2）函数名、形参列表、返回值相同（3）基类的函数是virtual 特殊情况：若派生类重写的虚函数属于一个重载版本，则该重写的函数会隐藏基类中与虚函数同名的其他函数。
C#中区别多态、重载、重写的概念和语法结构
重写是指重写基类的方法，在基类中的方法必须有修饰符virtual，而在子类的方法中必须指明override。 格式： 基类中： public virtual void myMethod() { } 子类中： public override void myMethod() { } 重写以后，用基类对象和子类对象访问myMethod()方法，结果都是访问在子类中重新定义的方法，基类的方法相当于被覆盖掉了。 重载 用于在给定了参数列表和一组候选函数成员的情况下，选择一个最佳函数成员来实施调用。 public void test(int x,int y){} public void test(int x,ref int y){} public void test(int x,int y,string a){} 重载特征： I.方法名必须相同 II.参数列表必须不相同，与参数列表的顺序无关 III.返回值类型可以不相同 ========================= 但如果有泛型，就要注意了！ 多态 c#的多态性主要体现在类的继承上: 子类继承父类的时候,可能出现同名但方法定义不同的情况, 所以在子类中会将原方法覆盖,实现自身的要求. using System; class Employee { virtual public void CalculatePlay() { Console.WriteLine("Employee");
} }; class SalariedEmployee: Employee { override public void CalculatePlay() { Console.WriteLine("Salary"); } }; class PolyApp { public static void Main() { Employee baseE1 = new Employee(); baseE1.CalculatePlay(); Employee baseE2 = new SalariedEmployee(); baseE2.CalculatePlay(); SalariedEmployee s = new SalariedEmployee(); s.CalculatePlay();
继承与多态的习题
一：选择题 1. 下面有关析构函数的说法中，不正确的是( ) A．析构函数中不可包含Return语句 B．一个类中只能有一个析构函数 C．用户可定义有参析构函数 D．析构函数在对象被撤销时，被自动调用 2．派生类不可以访问基类的( ) A．Public成员B．Private成员 C．Protected成员D．Protected internel成员 3．有关sealed修饰符，描述正确的是( ) A．密封类可以被继承 B．abstract修饰符可以和sealed修饰符一起使用 C．密封类不能实例化 D．使用sealed修饰符可保证此类不能被派生 4．若想从派生类中访问基类的成员，可以使用( ) A．this关键字B．me关键字 C．base关键字D．override关键字 5．下面有关派生类的描述中，不正确的是( ) A．派生类可以继承基类的构造函数 B．派生类可以隐藏和重载基类的成员 C．派生类不能访问基类的私有成员 D．派生类只能有一个直接基类 6．C#中，继承具有( )，即A类派生B类，B类又派生C类，则C类会继承B类中的成员和A类中的成员。 A．传递性B．多态性C．单继承D．多继承 7．下面有关静态方法的描述中，错误的是( ) A．静态方法属于类，不属于实例 B．静态方法可以直接用类名调用 C．静态方法中，可以定义非静态的局部变量 D．静态方法中，可以访问实例方法 8．下面关于运算符重载的描述中，错误的是( ) A．重载的运算符仍然保持其原来的操作数个数、优先级和结合性不变 B．可以重载双目运算符，不可以重载单目运算符 C．运算符重载函数必须是public的 D．运算符重载函数必须是static的 9．下面对派生类和基类的关系的描述中，不正确的是( ) A．派生类的方法可以和基类的方法同名 B．派生类是对基类的进一步扩充 C．派生类也可作另一个派生类的基类 D．派生类继承基类的公有、保护和私有成员 10.下面关于虚方法的描述中，正确的是（） A．虚方法可以实现静态联编 B．在一个程序中，不能有同名的虚方法 C．虚方法必须是类的静态成员
java多态
Java多态 1. Java中除了static和final方法外，其他所有的方法都是运行时绑定的。private 方法都被隐式指定为final的，因此final的方法不会在运行时绑定。当在派生类中重写基类中static、final、或private方法时，实质上是创建了一个新的方法。 2.在派生类中，对于基类中的private方法，最好采用不同的名字。 3.包含抽象方法的类叫做抽象类。注意定义里面包含这样的意思，只要类中包含一个抽象方法，该类就是抽象类。抽象类在派生中就是作为基类的角色，为不同的子类提供通用的接口。 4.对象清理的顺序和创建的顺序相反，当然前提是自己想手动清理对象，因为大家都知道Java垃圾回收器。 5.在基类的构造方法中小心调用基类中被重写的方法，这里涉及到对象初始化顺序。 6.构造方法是被隐式声明为static方法。 7.用继承表达行为间的差异，用字段表达状态上的变化。 在JAVA中有两种多态是指：运行时多态和编译时多态。 关于类的多态性简介如下： 多态(polymorphism)意为一个名字可具有多种语义.在程序设计语言中,多态性是指”一种定义,多种实现”.例如,运算符+有多种含义,究竟执行哪种运算取决于参加运算的操作数类型: 1+2 //加法运算符 “1” + “2” //字符串连接运算,操作数是字符串 多态性是面向对象的核心特征之一,类的多态性提供类中成员设计的灵活性和方法执行的多样性. 1、类多态性表现 (1)方法重载 重载表现为同一个类中方法的多态性.一个类生命多个重载方法就是为一种功能提供多种实现.编译时,根据方法实际参数的数据类型\个数和次序,决定究竟应该执行重载方法中的哪一个. (2)子类重定义从父类继承来的成员 当子类从父类继承来的成员不适合子类时,子类不能删除它们,但可以重定义它们,使弗雷成员适应子类的新需求.子类重定义父类成员,同名成员在父类与子类之间表现出多态性,父类对象引用父类成员,子类对象引用子类成员,不会产生冲突和混乱. 子类可重定义父类的同名成员变量,称子类隐藏父类成员变量.子类也可以重定义父类的同名成员方法，当子类方法的参数列表与父类方法参数列表完全相同时，称为子类方法覆盖
复习重点
Java中布尔类型的常量有两种，它们是（true）和（false）。 Java中用于定义小数的关键字有两个：（float）和（double），后者精度高于前者。 在Java中定义一个字符串类型的变量str的语句是：（String str），定义一个具有10个元素的整型数组a的语句是：（int[] arr=new int[10]; 。 当声明一个数组int arr[] = new int[5]; 时，这代表这个数组所保存的变量类型是（int），数组名是（arr），数组的大小为（5），数组元素下标的使用范围是（0-4）. 异常处理是由（try）、（catch）和finally块三个关键所组成的程序块。 假设x=13，y=4，则表达式x%y != 0的值是（true），其数据类型是（boolean）。 下面程序段的执行结果是（6 5 4 3 2） int a[] = { 2, 3, 4, 5, 6 }; for (int i = a.length - 1; i >= 0; i--) System.out.print(a[i] + ""); 导入mypackage包中的所类的命令是（import mypackage.*;）。 如果将类MyClass声明为public，它的文件名称必须是（MyClass.java）才能正常编译。 Java中用于两个数相等比较的运算符是：（==），用于不相等比较的运算符是（< >）。 下列哪一个import命令可以使我们在程序中创建输入/输出流对象（import java.io.*;）. 定义一个接口必须使用的关键字是（interface ）. 分析选项中关于Java中this关键字的说法正确的是（this关键字是在对象内部指代自身的引用）. Java中，如果类C是类B的子类，类B是类A的子类，那么下面描述正确的是（C不仅继承了B中的成员，同样也继承了A中的成员). 在Java语言中，下列关于类的继承的描述，正确的是（一个类可以具有多个子类）。 在JA V A中，以下（java.util.HashMap）类的对象以键-值的方式存储对象. 在Java中,关于构造方法，下列说法错误的是(构造方法不可以重载).
c++运算符重载和多态性实验报告
实验5 运算符重载和多态性班级学号（最后两位）姓名成绩 一、实验目的 1．掌握用成员函数重载运算符的方法 2．掌握用友元函数重载运算符的方法 3．理解并掌握利用虚函数实现动态多态性和编写通用程序的方法 4．掌握纯虚函数和抽象类的使用 二、实验内容 1．复数类加减法乘除运算(用成员函数定义运算符重载)。 复数类的定义： class complex //复数类声明 { public: //外部接口 complex(double r=0.0,double i=0.0) //构造函数 {real=r,imag=i;} complex operator +(complex c2); //运算符"+"重载成员函数 complex operator - (complex c2); //运算符"-"重载成员函数 complex operator *(complex ); //运算符"*"重载成员函数 complex operator /(complex); //运算符"/"重载成员函数 complex operator =(complex c2); //运算符"="重载成员函数 void display(); //输出复数 private: //私有数据成员 double real; //复数实部 double imag; //复数虚部 }; 实验代码： #include
java重写与方法重载实例
package basetest; /** * * @author Administrator *案例分析：对于main最后一行代码有两个坑 *1.调用的是Test类的哪一个方法？ *这一步看重载 *2.对于传递的参数（son），方法体重调用的是谁的方法 *这一步看重写调用的是子类的方法 * * */ public class OverrideDemo { public static void main(String[] args) { Father father = new Son(); father.show();//运行期绑定：重写看对象（new的是谁调谁的方法） Test test = new Test(); test.test(father);//编译器绑定：重载看引用（等号前的类型是谁调谁的方法）} } class Test {
void test(Father father){ System.out.println("父型参数"); father.show(); } void test(Son son){ System.out.println("子型参数"); son.show(); } } class Father { protected void show(){ System.out.println("我是老子！"); } } class Son extends Father{ /** * Cannot reduce the visibility of the inherited method from Father 不能减少来自继承方法的可见性 子类访问权限要大于父类 */ /* void show(){ }*/ public void show(){ System.out.println("我是儿子!"); } public void show(String name){ System.out.println("我是儿子：名字是"+name); } }
继承、多态,重载、重写的区别与总结
继承、多态,重载、重写的区别与总结 李氏原则： （1）父类的引用指向子类对象。 -多态 （2）接口的引用指向实现类的实例。-接口 Polo咯， 什么是多态？它的实现机制是什么呢？重载和重写的区别在那里？这就是这一次我们要回顾的四个十分重要的概念：继承、多态、重载和重写 继承(inheritance) 简单的说，继承就是在一个现有类型的基础上，通过增加新的方法或者重定义已有方法（下面会讲到，这种方式叫重写）的方式，产生一个新的类型。继承是面向对象的三个基本特征--封装、继承、多态的其中之一，我们在使用JAVA 时编写的每一个类都是在继承，因为在JAVA语言中，https://www.sodocs.net/doc/291042980.html,ng.Object类是所有类最根本的基类（或者叫父类、超类），如果我们新定义的一个类没有明确地指定继承自哪个基类，那么JAVA就会默认为它是继承自Object类的。 我们可以把JAVA中的类分为以下三种： 类：使用class定义且不含有抽象方法的类。 抽象类：使用abstract class定义的类，它可以含有，也可以不含有抽象方法。接口：使用interface定义的类。 在这三种类型之间存在下面的继承规律： 类可以继承（extends）类，可以继承（extends）抽象类，可以继承（implements）接口。 抽象类可以继承（extends）类，可以继承（extends）抽象类，可以继承（implements）接口。 接口只能继承（extends）接口。 请注意上面三条规律中每种继承情况下使用的不同的关键字extends和implements，它们是不可以随意替换的。大家知道，一个普通类继承一个接口后，必须实现这个接口中定义的所有方法，否则就只能被定义为抽象类。我在这里之所以没有对implements关键字使用“实现”这种说法是因为从概念上来说它也是表示一种继承关系，而且对于抽象类implements接口的情况下，它并不是一定要实现这个接口定义的任何方法，因此使用继承的说法更为合理一些。 以上三条规律同时遵守下面这些约束： 类和抽象类都只能最多继承一个类，或者最多继承一个抽象类，并且这两种情况是互斥的，也就是说它们要么继承一个类，要么继承一个抽象类。 类、抽象类和接口在继承接口时，不受数量的约束，理论上可以继承无限多个接
C++ 重写重载重定义区别
C++ 重写重载重定义区别 1 Overload:是函数名相同，参数列表不同.重载只是在类的内部存在。但是不能靠返回类型来判断。 成员函数重载特征： a 相同的范围（在同一个类中） b 函数名字相同 c 参数类型、个数不同 d virtual关键字可有可无 2 Override：也叫做覆盖。重写（覆盖)是指派生类函数覆盖基类函数。子类重新定义了父类中有相同名称和参数的虚函数。函数特征相同。但是具体实现不同，主要是在继承关系中出现的。 特征是： a 不同的范围，函数分别位于基类和派生类中 b 函数的名字相同 c 参数相同 d 基类函数必须有virtual关键字（多态） 重写需要注意： 1 被重写的函数不能是static的。必须是virtual的 2 重写函数必须有相同的类型，名称和参数列表 3 重写函数的访问修饰符可以不同。尽管virtual是private的，派生类中重 写改写为public,protected也是可以的 3重定义(redefining)也叫做隐藏: 子类重新定义父类中有相同名称的非虚函数( 参数列表可以不同) 。 如果一个类，存在和父类相同的函数，那么，这个类将会覆盖其父类的方法，除非你在调用的时候，强制转换为父类类型，否则试图对子类和父类做类似重载的调用是不能成功的。 重定义(隐藏)是指派生类的函数屏蔽了与其同名的基类函数，规则如下： a 如果派生类的函数和基类的函数同名，但是参数不同，此时，不管有无virtual，基类的函数被隐藏。 b 如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有vitual关键字，此时，基类的函数被隐藏。 综上所述，总结如下： 1 成员函数重载特征： a 相同的范围（在同一个类中） b 函数名字相同 c 参数不同 d virtual关键字可有可无 2 重写（覆盖)是指派生类函数覆盖基类函数，特征是： a 不同的范围，分别位于基类和派生类中 b 函数的名字相同 c 参数相同 d 基类函数必须有virtual关键字
实验4 类的继承和多态机制
实验4 类的继承和多态机制 一、实验目的 1、掌握类的继承机制； 2、掌握子类对父类构造方法的调用； 3、掌握方法覆盖和方法重载的区别。 二、实验内容 1、定义点类Point、圆类Circle、圆柱体类Cylinder。实现继承关系。 2、定义交通工具类Vehicle，一个小车类Car。实现Car对Vehicle的继承。 三、实验步骤 1、定义点类Point、圆类Circle、圆柱体类Cylinder。实现继承关系。 设计一个表示二维平面上点的类Point，包括表示坐标位置的成员变量x和y，获取和设置x和y值的方法。 设计一个表示二维平面上圆的类Circle，它继承自类Point，还包括表示圆半径的成员变量r、获取和设置r值的方法、计算圆面积的方法。 设计一个表示圆柱体的类Cylinder,它继承自类Circle，还包括表示圆柱体高的成员h、获取和设置h的方法、计算圆柱体表面积的方法、计算圆柱体体积的方法。 建立若干个Cylinder对象，输出其轴心位置坐标、半径、高、表面积及其体积的值。 class Point{ int x; int y; ;public Point(int x,int y){ this.x =x; this.y=y; } public int getX(){ return x; } public int getY(){ return y; } } class Circle extends Point{ double r; final double PI=3.1416; public Circle(int x,int y,double m){ super(x,y); r=m; } public double getR(){ return r; } public double circlearea(){ return PI*r*r;
java多态性
Java的多态性 面向对象编程有三个特征，即封装、继承和多态。 封装隐藏了类的内部实现机制，从而可以在不影响使用者的前提下改变类的内部结构，同时保护了数据。 继承是为了重用父类代码，同时为实现多态性作准备。那么什么是多态呢？ 方法的重写、重载与动态连接构成多态性。Java之所以引入多态的概念，原因之一是它在类的继承问题上和C++不同，后者允许多继承，这确实给其带来的非常强大的功能，但是复杂的继承关系也给C++开发者带来了更大的麻烦，为了规避风险，Java只允许单继承，派生类与基类间有IS-A的关系（即“猫”is a “动物”）。这样做虽然保证了继承关系的简单明了，但是势必在功能上有很大的限制，所以，Java引入了多态性的概念以弥补这点的不足，此外，抽象类和接口也是解决单继承规定限制的重要手段。同时，多态也是面向对象编程的精髓所在。 要理解多态性，首先要知道什么是“向上转型”。 我定义了一个子类Cat，它继承了Animal类，那么后者就是前者是父类。我可以通过 Cat c = new Cat(); 实例化一个Cat的对象，这个不难理解。但当我这样定义时： Animal a = new Cat(); 这代表什么意思呢？ 很简单，它表示我定义了一个Animal类型的引用，指向新建的Cat类型的对象。由于Cat是继承自它的父类Animal，所以Animal类型的引用是可以指向Cat类型的对象的。那么这样做有什么意义呢？因为子类是对父类的一个改进和扩充，所以一般子类在功能上较父类更强大，属性较父类更独特， 定义一个父类类型的引用指向一个子类的对象既可以使用子类强大的功能，又可以抽取父类的共性。 所以，父类类型的引用可以调用父类中定义的所有属性和方法，而对于子类中定义而父类中没有的方法，它是无可奈何的；
多态和虚函数、运算符重载
(3)单击标准工作栏的Save按钮，将文件保存到指定地点，并命名。 (4)编译运行。 3、输入并运行程序Ex_Complex的具体步骤如下。 (1) 选择“文件” “关闭工作区间”，关闭原来的项目。 (2) 单击标准工具栏上的“New Text File”按钮，在新打开的文档窗口中输入下列程序代码： #include 五、分析与体会： 1、象程序设计多态性是面向对象程序设计的重要特征之一，他与封装性和继承 性构成了面向对的三大特征。所谓多态性，是指不同类型的对象接受相同的消息是产生不同的行为。这里的消息主要是指对类的成员函数的调用，而不同的行为是指成员函数的不同实现。如：函数重载就是多态的典型例子。2、此程序中定义了一个抽象类CShape，包含纯虚函数Area和SetData，Area用于计算各个形状的面积，SetData用于重设各个形状的大小。程序代码中虚函数Area和SetData是通过在基类函数的前面加上virtual关键字来实现的。程序中ppShape是定义的基类CShape的指针，通过语句ppShape[0]=newTriangle(triWidth,triHeight);ppShape[1]=new(rcWidth,rcHeight); ppShape[2]=new CCircle(r);是将ppShape[0]、ppShape[1]和ppShape[2]分别获得对派生类CTriangle、CRect和CCircle的成员函数的调用，因而语句ppShape[n]->SetData(f1,f2);根据n值的不同调用不同的形状类的area函数，例 【转】C#中继承实现父类方法、重写、重载 继承是派生类（）去实现（重写 方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写(Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。 初次见到这两个单词并没有什么特别的感觉，但是时间长了，却发现书上一会儿用overri de，一会儿又用overload，搞得我的迷迷糊。于是就做了个总结，希望能对和我一样对这两个概念模糊不清的网友有一个帮助。 override为覆盖又叫重写，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现，在接口中一般只是对方法进行了声明，而我们在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，我们在继承中也可能会在子类覆盖父类中的方法。在覆盖要注意以下的几点： 1、重写方法的参数列表必须完全与被重写的方法的相同,否则不能称其为重写而是重载. 2、重写方法的访问修饰符一定要大于被重写方法的访问修饰符（public>protected>d efault>private）。 3、重写的方法的返回值必须和被重写的方法的返回一致； 4、重写的方法所抛出的异常必须和被重写方法的所抛出的异常一致，或者是其子类； 5、被重写的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行重写。 6、静态方法不能被重写为非静态的方法（会编译出错）。（也就是说重载后的方法要是static方法） overload对我们来说可能比较熟悉，可以翻译为重载，它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。在使用重载要注意以下的几点： 1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int, fl oat)，但是不能为fun(int, int)）； 2、不能通过访问权限、返回类型、抛出的异常进行重载； 3、方法的异常类型和数目不会对重载造成影响； 下面是对override和overload的测试程序，其中注释中的内容都是会产生编译错误的代码，我们将注释去掉，看看在编译时会产生什么效果。 // 对overload测试的文件：OverloadTest.java public class OverloadTest { // 下面几个方法用来验证可以通过定义不同的参数类型和参数的数目进行方法重载。 public void fun(){ System.out.println("method fun in OverloadTest, no parameter"); 第13卷第1期广州航海高等专科学校学报 Vol .13 No .1 2005年6月 JOURNAL OF G UANGZ HOU MAR I TI M E COLLEGE Jun .2005 文章编号:1009-8526(2005)01-0055-03 C++语言中多态性的分析 江勇驰 (广州航海高等专科学校交通运输管理系,广东广州510725) 摘 要:通过分析C++语言多态性的各种形式、特征及其在程序设计中的应用,说明多态性是对相似问题求解的有效方法. 关键词:C++;多态性;面向对象;虚函数中图分类号:TP311.1 文献标识码:A 收稿日期:2005-03-10 作者简介:江勇驰(1972-),男,助理馆员,主要从事自动化与计算机的实验教学和管理. C++语言具有数据封装、继承及多态性三大特征[1] ,多态性同时考虑了类的数据封装与继承关系的设计,是C++最重要的特征.在程序中多态性是指同一符号或名字在不同情况下代表不同但相似的功能[2] ,是对相似问题的一种求解方法.本文主要分析C++语言的多态性支持在程序设计中的应用. 1 实现形式及其应用 在C++面向对象程序设计中,实现多态性有两 种基本形式:编译时多态性和运行时多态性[3] .编译时多态性是指在程序编译阶段即可确定下来的多态性,包括强制多态和重载多态两种形式.运行时多态性是指必须等到程序动态运行时才可确定的多态性,主要通过继承结合动态绑定获得,分别体现在包含多态与类型参数化多态两方面. 1.1 强制多态 当表达式中存在不同类型的操作数时,为对此表达式进行求值,编译程序需要对其中的部分操作数强制进行类型转换,以保证运算符两边的操作数类型一致,但体现出来的却是完成了不同类型操作数间的运算,这就是C++中的强制多态性.C++中,“1+2”表示整数的加法,“1.0+2.0”表示浮点数的相加,而“1.0+2”需要作类型转换,实际进行浮点数加法,但却表示整数与浮点数的相加.这两种运算的内部实现是不同的,而且效率相差很大,不便用不同的符号表达.同一个运算符“+”可以同时具有不 同但相似的运算含义,体现的就是强制多态性 [3] . C++中规定了基本数据类型之间的转换规则:如果 运算符两边的操作数类型运算不一致,则总是将取值范围的最大值较小的类型转换为取值范围的最大值较大的类型,取值范围从大到小分别是:l ong double,double,fl oat,unsigned l ong,l ong,unsigned 和int .正是由于这种多态性,才简化了程序设计,可以 按相同的逻辑处理各种数据的加法.不过C ++中,强制多态性是有限的,不能用这一方法去解决许多类似问题.重载多态提供了另外一种途径. 1.2 重载多态 重载多态主要通过使用重载机制获得,包括函数重载和运算符重载两大类. 运算符重载允许重新定义C ++语言已有的运算符,以一种更加自然的方式使用自己定义的类类型.例如,加法运算符“+”表示整数或浮点数的加法,如果用户定义了一个复数类Comp lex,在类定义中对加法运算符“+”进行了重载,定义实现复数相加的操作Co mp lex operat or +(const Comp lex&oth 2er ){...},那么使用复数类声明两个对象Comp lex obj1,obj2;后,就可以直接使用obj1+obj2表示对 复数求和的操作,使得程序语言更接近习惯用法.C++语言中颇具典型的例子就是插入符“<<”和 提取符“>>”的重载.在C 语言中,利用库函数 p rintf ()输出或scanf ()输入时需要用参数指明输出或输入的数据类型方可正确输出或输入,而在C++ 1. 父类：public virtual string ToString(){return "a";} 子类：public override string ToString(){return "b";} 2. 同一类中或父子关系类中皆可： public string ToString(){return "a";} public string ToString(int id){return id.ToString();} override是用于重写基类的虚方法,这样在派生类中提供一个新的方法 重载是提供了一种机制, 相同函数名通过不同的返回值类型以及参数来表来区分的机制 很本质的区别就是看函数特征：覆写（Override）的两个函数的函数特征相同，重载（Overload）的两个函数的函数名虽然相同，但函数特征不同。 函数特征包括函数名，参数的类型和个数。 Override 是在继承的时候，如果你写的函数与要继承的函数函数特征相同，那么，加上这个关键字，在使用这个子类的这个函数的时候就看不见父类（或超类）的函数了，它被覆盖掉了。 比如：Derived继承了Base，Base里面有void A(int a) 那么如果你Derived里面觉得A写得不好或不适合这个类，你想重新再写一遍A里的代码，那么就写override void A(int a)这样，原来的那个函数就被你新写的这个覆盖掉了。Overload 是重载，就是说函数名相同，函数特征不同，系统会根据你提供的参数来调相应的函数。 比如：void A(int a)和void A(int a,int b) 如果你用的是A(1)那么调的是第一个，如果是A(1,1)那么调的是第二个。 ================================================= 1. override ----------- 使用override 修饰符来修改方法、属性、索引器或事件。重写方法提供从基类继承的成员的新实现。由重写声明重写的方法称为重写基方法。重写基方法必须与重写方法具有相同的签名。 不能重写非虚方法或静态方法。重写基方法必须是虚拟的、抽象的或重写的。 也就是说，用override 修饰符重写的基类中的方法必须是virtual, abstract 或override 方法。 2. 重载 ------- 当类包含两个名称相同但签名不同的方法时发生方法重载。 使用重载方法的指南: a. 用方法重载来提供在语义上完成相同功能的不同方法。 多态 0.英语单词 1.为什么使用多态 1)问题的由来 需求变更 宠物系统中添加主人给宠物喂食功能，具体需求如下： ?给Dog喂食，其健康值增加3，输出吃饱的信息 ?给Penguin喂食，其健康值增加5，输出吃饱的信息 分析 1)给抽象类Pet增加抽象方法eat()方法； 2)让Dog类重写Pet类的eat()方法，实现狗狗吃饭功能； 3)让Penguin类重写Pet类的eat()方法，实现企鹅吃饭功能 4)创建主人类Master,添加feed(Dog dog)方法，调用Dog类的eat()方法，实现狗狗的 喂养；添加feed(Penguin penguin)方法，调用Penguin类的eat()方法，实现企鹅的喂 养。 5)创建测试类Test，在类中创建主人、狗狗和企鹅对象，调用相应方法实现主人喂养 宠物的功能 实例1：Pet.java Dog.java Penguin.java Master.java Test.java 从实例的运行结果看，我们已经顺利实现了主人给宠物喂食的功能，但是，如果主人又领养了一只猫或更多的宠物，该如何实现给宠物喂食呢？ 当然你可以添加一个Cat类，让其继承Pet类，重写eat()方法；然后在Master类中重载feed()方法，添加一个feed(Cat cat)方法。可是，如果添加更多的宠物呢，这样做的缺点是：代码频繁修改（每次都要修改Master类，添加feed()的重载方法），可扩展性、可维护性差（如果领养的宠物过多，Master类中就会有很多重载的feed()方法）。 2)怎么解决问题 如果能实现如下效果就好了：Master类中只有一个feed()方法，可以实现多有宠物的喂食，不管领养多少宠物，都不用修改Master类源码。 答案是肯定的，通过多态实现该效果。转载C#中继承实现父类方法、重写、重载
重载和重写
C++语言中多态性的分析
C#重载和覆写区别
4.多态