简单整理了各种语言多态性的相关内容以及部分高级特性。
－－－－－－－－－－－－－－－－－－－－－－－－－
Delphi
－－－－－－－－－－－－－－－－－－－－－－－－－
【重载】
加overload
【虚基类】
delphi不支持多继承，所以没有虚基类这一说。
【虚函数】
父类的虚函数定义有两种方式：
(1)procedure Draw; virtual;
(2)procedure Draw; dynamic；
两者基本是一样的，前者速度优化，后者容量优化。
子类用override覆盖就行了：
procedure Draw; override；
【纯虚函数】
父类定义如下
procedure fly(); virtual; abstract;
子类使用如下：
procedure fly(); override;
【抽象类】
不清楚DELPHI有没有这个概念，印象中好像没有提及过。
【接口】
IFoo=interface
['{2137BF60-AA33-11D0-A9BF-9A4537A42701}']
function F1:Integer;
end;
IBar=interface
['{2137BF61-AA33-11D0-A9BF-9A4537A42701}']
function F1:Interger;
end;
【属性】
TMyObject=class
private:
SomeValue:Integer;
procedure SetSomeValue(AValue:Integer);
public:
property Value:Integer read SomeValue write SetSomeValue;
end;
procedure TMyObject.SetSomeValue(AValue:Integer);
begin
if SomeValue<>AValue then
SomeValue:=AValue;
end;
－－－－－－－－－－－－－－－－－－－－－－
C++
－－－－－－－－－－－－－－－－－－－－－－
【重载】
定义同名不同参的函数就行了，没有专门的关键字。
【虚基类】
多继承时用virtual关键字声明继承方式，避免基类中同类成员的多拷贝。
class A //定义基类A
{
A(int i){} //基类构造函数，有一个参数
…
};
classB:virtual public A //A作为B的虚基类
{
B(int n):A(n){} //B类构造函数，在初始化表中对虚基类初始化
…
};
classC:virtual public A //A作为C的虚基类
{
C(int n):A(n){} //C类构造函数，在初始化表中对虚基类初始化
…
};
classD:publicB，publicC //类D的构造函数，在初始化表中对所有基类初始化
{
D(int n):A(n)，B(n)，C(n){}
…
}
【虚函数】
在父类中用virtual声明函数，并实现函数的定义；
在子类中重载此函数，可以实现动态联编。
父类包含虚函数：
class Point
{
public:
Point(double i,double j) {x=i;y=j;}
virtual double Area() const {return 0.0;}
private:
double x,y;
};
子类中覆盖虚函数：
class Rectangle:public Point
{
public:
Rectangle(double i,double j,double k,double 1);
virtual double Area() const { return w*h;}
private:
double w,h;
};
调用这个函数实现动态联编：
void fun(Point &s)
{
cout<<s.Area()<<endl;
}
【纯虚函数】
用关键字virtual声明的函数，并且不实现函数的定义。
例如下面的类中定义了两个纯虚函数，
class point
{
public:
point(int i=0,int j=0) {x0=i;y0=j;}
virtual void set()=0;
virtual void draw()=0;
protected:
int x0,y0;
};
【抽象类】
称带有纯虚函数的类为抽象类，只能作为基类。
抽象类是一种特殊的类，它是为了抽象和设计的目的而建立的，它处于继承层次结构的较上层，抽象类是不能定义对象的，在实际中为了强调一个类是抽象类，可将该类的构造函数说明为保护的访问控制权限。
class Shape
{
public:
virtual float area() const{return 0.0;}
virtual float volume() const{return 0.0;}
virtual void shapeName() const =0;
};
子类中若不重载父类中的函数，则子类也是抽象类。
【接口】
形式上就是把抽象类中的class换成interface，可以从其他接口继承，当然最主要的被别的类继承。
如COM中常用的IUnknown接口声明如下：
interface IUnknown{
virtual HRESULT STDMETHODCALLTYPE
QueryInterface(REFIID riid,void **ppv)=0;
virtual ULONG STDMETHODCALLTYPE AddRef(void)=0;
virtual ULOND STDMETHODCALLTYPE Release(vod)=0;
};
C++中一般用抽象类来实现接口。
【属性】
标准C++中没这东东。
－－－－－－－－－－－－－－－－－－－－－－－－－－
C#
－－－－－－－－－－－－－－－－－－－－－－－－－－
【重载】
定义同名不同参的函数就行了，没有专门的关键字，和C++一样。
【虚基类】
单继承下不流行这玩意。
【虚函数】
在父类中用virtual声明函数，并实现函数的定义；
public virtual bool SQLExe(bool b)
{
return true;
}
在子类中用override覆盖此函数，可以实现动态联编。
【纯虚函数】
用关键字abstract声明的函数，并且不实现函数的定义，必须存在于抽象类中。
public abstract bool f();
在子类中用override覆盖此函数。
【抽象类】
用abstract声明，父类中可包含虚函数声明，并不实现虚函数的定义，只能作为基类。
public abstract class cl
{
public cl(){}
public abstract bool f();
}
【接口】
和类定义类似，用interface说明。
[attributes] [modifiers] interface identifier [:base-list] {interface-body}[;]
1、attributes（可选）：附加的定义性信息。
2、modifiers（可选）： 允许使用的修饰符有 new 和四个访问修饰符。
分别是：new、public、protected、internal、 private。
在一个接口定义中同一修饰符不允许出现多次，new 修饰符只能出现在嵌套接口中，表示覆盖了继承而来的同名成员。
public, protected, internal, and private 修饰符定义了对接口的访问权限。
3、指示器和事件。
4、identifier：接口名称。
5、base-list（可选）:包含一个或多个显式基接口的列表，接口间由逗号分隔。
6、interface-body：对接口成员的定义。
7、接口可以是命名空间或类的成员，并且可以包含下列成员的签名： 方法、属性、索引器 。
8、一个接口可从一个或多个基接口继承。
允许实现多个接口
例如一个带事件的接口定义如下：
public delegate void StringListEvent(IStringList sender);
public interface IStringList
{
void Add(string s);
int Count { get; }
event StringListEvent Changed;
string this[int index] { get; set; }
}
【属性】
private int myheight;
public int MyHeight
{
get{
return this.myheight;
}
set
{
this.myheight = value;
}
}
－－－－－－－－－－－－－－－－－－－－－－－－－－
JAVA
－－－－－－－－－－－－－－－－－－－－－－－－－－
【重载】
函数同名不同参就行了。
【虚基类】
单继承不流行这玩意！
【虚函数】
没有这个概念，java自动实现了动态联编，不信你试试！
【纯虚函数】
在JAVA里叫抽象函数，不叫纯虚函数，必须定义在抽象类里面，而且没有方法体。例如：
abstract class Demo ｛
abstract void method1();
abstract void method2();
…
｝
【抽象类】
abstract class Demo ｛
abstract void method1();
abstract void method2();
…
｝
【接口】
知道有了抽象类，为什么还要接口吗？因为java是单继承，但是接口可以继承多个！
实现多数设计模式的关键技术：
interface Demo {
void method1();
void method2();
…
}
【final类】
final类不能被继承
如果你认为一个类的定义已经很完美，不需要再生成它的子类，这时也应把它修饰为final类
final class classname{...}