【补 4/20】面向对象中的多态

面向对象中的多态

面向对象的三个基本特征

封装、继承、多态

什么是多态？

简单点说多态就是：

一个接口 多个方法（实现）

再具体一点就是：把子类型的指针赋值给父类的指针。

多态需要的体现需要依赖继承，子类重新定义父类的方法。下面以比较典型的几个面向对象语言作为例子讲一下各个语言是怎么实现。

多态还依赖的是动态绑定。

1.C++ 通过虚函数

代码如下：

#include<iostream>

using namespace std;

class A

{

public:

void foo()

{

printf("1\n");

}

virtual void fun()

{

printf("2\n");

}

};

class B : public A

{

public:

void foo()

{

printf("3\n");

}

void fun()

{

printf("4\n");

}

};

int main(void)

{

A a;

B b;

A *p = &a;

p->foo();

p->fun();

p = &b;

p->foo();

p->fun();

return 0;

}

这个是个很经典的例子了，代码网上扒了一段哈哈哈哈。 p 首先是指向 A 的基类指针，所以第一次打印的是 1 ， 2，第二次的时候指向的是一个 B 的对象，虽然还是 A 的指针，但真正的实例对象是 A 的子类 B，并且fun是虚函数，所以这里打印的是 1， 4。

具体的原理如下：

c++:在一个类中声明了虚函数，在给这个类中对象分配内存的时候，会有一个虚表指针，指向虚函数列表，其实就是一堆的虚函数地址。C ++ 中是创建的过程中，是先执行父类初始化，最后再初始化自己，析构则相反，先析构自己，再析构父类。这样初始化的时候虚函数表就是子类的表。

当我们把父类指针指向子类对象时，指针先通过虚表指针，查询虚函数列表，如果目前指向的虚函数表存在的话，换句话说就是子类重写了这个虚函数，如果没有，那么继续在父类的普通方法中查询。

其实父类指针指向子类对象，计算机其实会把指向的东西当做父类对象，所以只会查询父类的普通方法，这里也说明了为什么父类对象强转到子类的时候，调用子类方法会报错，因为根本就找不到。

Object-C – 直接重写（Runtime）

例子代码

TRACE(@"%@", NSStringFromClass([self class]));

TRACE(@"%@", NSStringFromClass([super class]));

上面的那段代码打印什么？ 都是当前的 Class 。理解了上面那个，多态就迎仍而解了！结合下 Runtime 的知识去理解，OC 的每个对象都有个 isa 指针，通过这个来访问变量和函数。

那么当一个父类指针指向子类的时候，这个对象的 isa 其实还是子类啊！当然执行的方法肯定是子类的方法了。

Java 通过继承和接口

Java实现多态有三个必要条件：继承、重写、向上转型。

Java 的多态实现方式其实和 C++ 很像，Java 中有方法表的存在，都是用来实现方法的动态绑定的，其起到的作用和方法表很像。

下面这是继承和接口的实现：

interface Walk
{
public void move();
}

class Pet implements Walk

{
public void say(){ System.out.println("Pet say"); }

public void move(){ System.out.println("Pet move"); }
}

class Dog extends Pet implements Walk

{
public void say(){ System.out.println("Dog say"); }

public void move(){ System.out.println("Dog move"); }

}

public static void main(String[] args)
{
Pet p1 = new Pet();
Pet p2 = new Dog();
p1.say(); //Pet say

p2.say(); // Dog say

Walk w1 = new Pet(); // Pet walk

Walk w2 = new Dog(); // Dog walk

}