抽象问题

Java

abstract class A{

    private int data;

    public A(int data){    // 不可以直接实例化（产生对象）
        this.data = data;
    }

    // 只有抽象类有抽象方法
    public abstract void test();    // 继承中必须被重写（“紧邻”继承关系）

    public void print() { // 可选择性多态
        System.out.println(data);
    }

    public final void finalTest(){
        System.out.println("finalTest");
    }
}
class B extends A{
    public B(int data) {    
        super(data);
    }

    @Override
    public void test() { // “紧邻”继承层次结构中，必须实现

    }

    @Override  
    public void print() {  // 可重写可不重写
    }
}
class C extends B{  // 这里B已经不是抽象类，犯法 test() 也不是抽象方法了。
    public C(int data) {
        super(data);
    }
} 

C++

class A{
    int data;
public:
    A(int data){
        this->data = data;
    }

    virtual void test() = 0;    // 存虚函数定义抽象类  (必须被实现)

    virtual void print(){  // 可以选择多态性
        printf("The data value: %d\n", data);
    }

    void staticTest(){  // 相当于Java中的 final void finalTest()，不具有多态属性
        printf("static binding method!\n");
    }
};

class B : public A{
public:
    B(int data): A(data) {}
    void test(){
        printf("B implements the virtual method of A\n");
    }

    void print(){   // 可重写可不重写
        printf("Override the method print() of A");
    }

};

class C : public B{
public:
    C(int data): B(data){}

    // B 已经非抽象类
    // 不用非实现方法 test()不可
};


int main(){
    A *p_a = new C(10);
    p_a->test();
    p_a->print();
    p_a->staticTest();
    delete p_a;
}