C++快速入门--12--抽象类和接口模拟

初探抽象类

什么是抽象类？含有纯虚函数的类为抽象类，什么是纯虚函数？即virtual void fun() = 0;这样的函数即为纯虚函数。

class Figer{
public:
    virtual int getArea() = 0;
};

class Circle:public Firger{
public:
    Circle(int a,int b){
        this->a = a;
        this->b = b;
    }
    virtual int getArea(){
        return 3.14 * this->a * this->b;
    }
private:
    int a,b;
};

class Square:public Figer{
public:
    Square(int a,int b){
        this->a = a;
        this->b = b;
    }
    virtual int getArea(){
        return a*b;
    }
private:
    int a,b;
};

void printArea(Figer & figer){
    cout<<getArea()<<endl;
}

int main(){
    Circle c(1,2);
    Square s(1,2);
    printArea(c);
    printArea(s);
    return 0;
}

有了抽象类之后，我们就可以面向接口编程，我们可以先定义一套抽象类模板，然后再去实现它。实现每个模块的不需要关系别人是怎么实现的，因为利用C++的多态性，我们只需要通过模板类指向子类对象即可
例如上面的printArea()方法，Square类和Circle类可以是两个不同的人写的，他们不需要关系对方是怎么实现的，都只需要将参数传递到printArea即可完。

使用抽象类模拟java接口

在C++你不能直接定义一个接口，但是你可以通过抽象类模拟接口。

class Interface1 {
public:
    virtual int add(int a, int b) = 0;
    virtual void print() = 0;
};

class Interface2 {
public:
    virtual int mult(int a,int b) = 0;
    virtual void print() = 0;
};

class Parent {
protected:
    int a;
    Parent(int a) {
        this->a = a;
    }
    virtual int getA() {
        return this->a;
    }
};

class Child :public Parent,public Interface1,public Interface2{
public:
    Child(int a):Parent(a) {
        this->a = 2;
    }
    virtual int add(int a,int b) {
        return a + b;
    }
    virtual int mult(int a,int b) { 
        return a * b;
    }
    virtual void print() {
        cout << this->a << endl;
    }   
    virtual int getA() {
        return this->a;
    }
};  

int main() {
    Interface1 * c1 = new Child(1);
    Interface2 * c2 = new Child(2);
    cout << c1->add(1, 2) << endl;
    cout << c2->mult(1, 2) << endl;
    c1->print();
    delete (Child *)c1;
    delete (Child *)c2;
    system("pause");
}

你会发现，这里的Interface1和Interface2就像java中一个接口，它没有自己的实现，而是定义了一套模板，交给子类去实现，java接口与抽象类的区别主要在于，接口可以实现多个，而抽象类只能被继承一次，而在C++中的多继承，就可以不用担心这个抽象类只能被继承一次。