抽象类、虚函数、纯虚函数、接口、多态、继承（多位置转载外加自己的一点代码）

抽象类、虚函数、纯虚函数、接口、多态、继承

转载地址：http://hi.baidu.com/futantan/item/7bba8be289ae2612595dd82b

抽象类：

不能实例化。

可以在抽象类中定义抽象方法，以供派生类写具体方法。

派生类也可以保留抽象方法，但该类必须为抽象类。

也可以在抽象类中写非抽象方法。

例子：

抽象类

public abstract class AbstractClass
{
	public abstract string GetName(string Name);

	public string GetNameByID(string Name)
	{
		return Name;
	}
}

派生类

public class UserClass:AbstractClass
{
	public override string GetName(string Name)
	{
		return Name + "nihao.";
	}
}

虚方法：

通过在基类中定义虚方法(virtual)，在子类中，可以通过override进行派生重写。

例子

基类

public class VirtualClass
{
	public virtual string GetName(string Name)
	{
		return Name;
	}
}

子类

public class UserClass2:VirtualClass
{
	public override string GetName(string Name)
	{
		//return base.GetName(Name);
		return "Hello." + Name;
	}
}

接口：

接口即契约。用于规定一种规则由大家遵守。允许多继承.而继承类只允许单继承.

定义接口

public interface UserInterface
{
	void UserLogin(string UserName,string Password);
	bool Login(out string exInfo);
}

使用接口

public class UserClass : UserInterface
{
	#region UserInterface 成员

	public void UserLogin(string UserName, string Password)
	{
		throw new Exception("The method or operation is not implemented.");
	}

	public bool Login(out string exInfo)
	{
		throw new Exception("The method or operation is not implemented.");
	}

	#endregion
}

说明：

多态是面向对象编程的三大特性之一。

接口和虚函数是多态的表现形式。

在需要多态的情境下:

如果类中方法可以确定下来，而以后可能改变方法的用途，使用虚函数较好。

如果类中方法不确定，用途也不确定。只能确定格式,那么使用接口，以方便需要的类进行继承。进行扩展。

抽象类不能多态。抽象类是用于在开发初期不清楚或者不确定后续方法细则的情况下使用。

虚函数是一个已经定义好的函数，可以直接使用。

接口只是定义契约，没有具体实现。必须继承后实现才能使用。

接口本质上仍然被标记为.class,同时提供abstract virtual 方法的Method，因此接口其实本质上可以看作是一个定义了抽象方法的类，该类仅提供了方法的定义，而没有方法的实现，其功能由接口的实现类来完成。

虚函数可以在抽象类和非抽象类中定义，而抽象方法必须在抽象类中定义。

抽象类中的非抽象方法，在派生的类中，不能重写。

 

抽象类实现了一部分方法，还留了一些方法要求继承他的类去实现

接口就是定义了一些接口，但完全没有实现，要求实现接口的那些类实现

C#的虚函数也可以有自己的实现的，同时继承的类可以完全重写虚函数的方法。

 

 

虚函数与纯虚函数

使用虚函数，我们可以灵活的进行动态绑定，当然是以一定的开销为代价。 如果父类的函数（方法）根本没有必要或者无法实现，完全要依赖子类去实现的话，可以把此函数（方法）设为virtual 函数名=0 我们把这样的函数（方法）称为纯虚函数。
也就是说，虚函数 ，子类可以不重写，直接继承父类 的方法来使用，也可以重写
但是 纯虚函数是子类是必须重写了才可以使用

覆盖：
在基类中定义了一个非虚拟函数，然后在派生类中又定义了一个同名同参数同返回类型的函数，这就是覆盖了。在派生类对象上直接调用这个函数名，只会调用派生类中的那个。
重载：
在基类中定义了一个非虚拟函数，然后在派生类中定义一个同名，但是具有不同的参数表的函数，这就是重载。在派生类对象上调用这几个函数时，用不同的参数会调用到不同的函数，有可能会直接调用到基类中的那个。
多态：
在基类中定义了一个虚拟函数，然后在派生类中又定义一个同名，同参数表的函数，这就是多态。多态是这3种情况中唯一采用动态绑定技术的一种情况。也就是说，通过一个基类指针来操作对象，如果对象是基类对象，就会调用基类中的那个函数，如果对象实际是派生类对象，就会调用派声雷中的那个函数，调用哪个函数并不由函数的参数表决定，而是由函数的实际类型决定。

原始地址：http://hi.baidu.com/_sherry_liu/item/ed282c7354ff4f43ef1e5385

C++的虚函数和JAVA的抽象函数

C++中具备两种虚拟函数：虚函数和纯虚函数。跟JAVA相比，虚函数相当于JAVA中的普通函数，而纯虚函数则为JAVA中的抽象函数。
C++的虚函数是在函数前加上virtual修饰符，主要用于多态（见最后的解释）。函数具有函数体，只是为了表明该函数调用是动态的，根据实例化对象而来（C++）。而JAVA中默认就是这种方式。
纯虚函数和抽象函数都没有函数体，纯虚函数是在虚函数声明上后面加上“=0”，如“virtual void showmember()=0; ”，声明了纯虚函数的，此类不用使用任何修饰符即成为了抽象类。
参考：http://zhidao.baidu.com/question/5790744.html
覆盖：
在基类中定义了一个非虚拟函数，然后在派生类中又定义了一个同名同参数同返回类型的函数，这就是覆盖了。在派生类对象上直接调用这个函数名，只会调用派生类中的那个。
重载：
在基类中定义了一个非虚拟函数，然后在派生类中定义一个同名，但是具有不同的参数表的函数，这就是重载。在派生类对象上调用这几个函数时，用不同的参数会调用到不同的函数，有可能会直接调用到基类中的那个。
多态：
在基类中定义了一个虚拟函数，然后在派生类中又定义一个同名，同参数表的函数，这就是多态。多态是这3种情况中唯一采用动态绑定技术的一种情况。也就是说，通过一个基类指针来操作对象，如果对象是基类对象，就会调用基类中的那个函数，如果对象实际是派生类对象，就会调用派声类中的那个函数，调用哪个函数并不由函数的参数表决定，而是由函数的实际类型决定。
 
C++之虚函数与纯虚函数的使用方法
 
1． 虚函数和纯虚函数可以定义在同一个类(class)中，含有纯虚函数的类被称为抽象类（abstract class），而只含有虚函数的类（class）不能被称为抽象类（abstract class）。

2． 虚函数可以被直接使用，也可以被子类（sub class）重载以后以多态的形式调用，而纯虚函数必须在子类（sub class）中实现该函数才可以使用，因为纯虚函数在基类（base class）
只有声明而没有定义。

3． 虚函数和纯虚函数都可以在子类（sub class）中被重载，以多态的形式被调用。

4． 虚函数和纯虚函数通常存在于抽象基类（abstract base class -ABC）之中，被继承的子类重载，目的是提供一个统一的接口。

5． 虚函数的定义形式：virtual {method body}
纯虚函数的定义形式：virtual { } = 0;
在虚函数和纯虚函数的定义中不能有static标识符，原因很简单，被static修饰的函数在编译时候要求前期bind,然而虚函数却是动态绑定（run-time bind），而且被两者修饰的函数生命周期（life recycle）也不一样。
6.如果一个类中含有纯虚函数，那么任何试图对该类进行实例化的语句都将导致错误的产生，因为抽象基类（ABC）是不能被直接调用的。必须被子类继承重载以后，根据要求调用其子类的方法。

以下为一个简单的虚函数和纯虚寒数的使用演示，目的是抛砖引玉！

#include <>
//father class
class Virtualbase
{
	public:
	virtual void Demon()= 0; //prue virtual function
	virtual void Base() {cout<<"this is farther class"<<endl};
}

//sub class
class SubVirtual :public Virtualbase
{
	public:
	void Demon() { cout<<" this is SubVirtual!"<<endl};
	void Base() { cout<<"this is subclass Base"<};
}
/* instance class and sample */
int main()
{
	Virtualbase* inst = new SubVirtual(); //multstate pointer
	inst->Demon();
	inst->Base();
}
虚函数和纯虚函数区别观点一：类里声明为虚函数的话,这个函数是实现的，哪怕是空实现，它的作用就是为了能让这个函数在它的子类里面可以被重载，这样的话，这样编译器就可以使用后期绑定来达到多态了纯虚函数只是一个接口，是个函数的声明而已，它要留到子类里去实现。
class A{
	protected:
	void foo();//普通类函数
	virtual void foo1();//虚函数
	virtual void foo2() = 0;//纯虚函数
}
观点二：
虚函数在子类里面也可以不重载的；但纯虚必须在子类去实现，这就像Java的接口一样。通常我们把很多函数加上virtual，是一个好的习惯，虽然牺牲了一些性能，但是增加了面向对象的多态性，因为你很难预料到父类里面的这个函数不在子类里面不去修改它的实现

观点三：
虚函数的类用于“实作继承”，继承接口的同时也继承了父类的实现。当然我们也可以完成自己的实现。纯虚函数的类用于“介面继承”，主要用于通信协议方面。关注的是接口的统一性，实现由子类完成。一般来说，介面类中只有纯虚函数的。
观点四：
带纯虚函数的类叫虚基类，这种基类不能直接生成对象，（否则会出现错误！）而只有被继承，并重写其虚函数后，才能使用。这样的类也叫抽象类。虚函数是为了继承接口和默认行为
纯虚函数只是继承接口，行为必须重新定义。

举例子：

#include <iostream>
using namespace std;

class base{
public:
	virtual void play(){
		cout <<"base"<<endl;
	}
	virtual void doing()=0;//包含了纯虚函数，相当于抽象函数，子类如果想使用，必须将其实现后才能使用
};

class A:public base{
public:
	A(){}
	void play(){
		cout <<"A"<<endl;
	}
	//void doing(){}//父类包含了纯虚函数，相当于抽象函数，子类A如果想new，必须将其实现后才能使用，此时没有实现，不可以base *c1 = new A();
};

class B:public A{
public:
	B(){}
	void play(){
		cout <<"B"<<endl;
	}
	void doing(){};//此时实现了，可以base *c1 = new B();
};

int main()
{
	base *c1 = new B();
	c1->play();

	return 0;
}