如何通过父类引用“调用”子类所独有的方法

最近看书，看到向上引用的情况：派生类引用或指针转换为基类引用或指针被称为向上强制转换。

BrassPlus dilly("Annie Dill",493222,2000);

Brass *pb = &dilly；

Brass &rb = dilly；

在这里想到，经过向上转换的基类对象能否调用子类中的独有的成员函数呢？

首先，我们能否用父类调用子类的方法呢？

多态。如果说父类中有这个属性跟方法，子类有重写过，那么调用的是子类中的属性跟方法。如果父类中没有这个属性跟方法，那么子类调用就会出错。如果父类有这个属性跟方法，而子类没有，则调用的是父类的属性跟方法。

疑问：Animal cat = new Cat(); //向上转型。

父类引用指向子类对象，该引用不能再访问子类新增加的成员，那么这样和直接new一个父类实例（Animal a = new Animal()）有什么区别？
1、当父类是抽象类或是接口时，不能实例化时，只能运用多态，向上转型。
2、普通类中，可以在子类中重写父类中的方法，这样就可以访问子类中的重写方法。或者：Cat c = (Cat)cat; 向下转型，再访问子类中新增加的成员。

所以，举个为什么不new一个父类的实例：

你写了一个飞机游戏，画面里出现什么类型飞机是随机决定的，你的代码里也就不可能用一个具体飞机类型来操作。
所以，往往是随机生成各种类型飞机，他们有共同的父类，你的代码就可以用父类指针来控制行为。比如中弹后的能量损失多少之类，每种飞机可能不同。

Eg: List是接口，ArrayList是List的实现类。

至于为什么是写成List list = new ArrayList() 而不是 ArrayList arrayList = new ArrayList 有如下的原因：

1.接口有什么好处，这种定义方式就有什么好处
当然你可以用 ArrayList list = new ArrayList；

但是一般不这么用

2 .设计模式中有对依赖倒置原则。程序要尽量依赖于抽象，不依赖于具体。
从Java语法上，这种方式是使用接口引用指向具体实现。

比如，你若希望用LinkedList的实现来替代ArrayList的话，只需改动一行即可：
List list = new LinkedList()；
而程序中的其它部分不需要改动，这样比较灵活

这个如果你想把存储结构该为LinkedList的时候，只要把List list ＝ new ArrayList 改为list ＝ new LinkedList 而其他的所有的都不需要改动。这也是一种很好的设计模式.一个接口有多种实现,当你想换一种实现方式时,你需要做的改动很小.

假设你开始用 ArrayList alist = new ArrayList , 这下你有的改了，特别是如果你使用了 ArrayList特有的方法和属性。如果没有特别需求的话,最好使用List list = new LinkedList(); ,便于程序代码的重构. 这就是面向接口编程的好处

3 面向接口编程

4 提高程序宽展性,以后修改维护好些

ArrayList不是继承List接口，是实现了List接口。

你写成ArrayList arrayList = new ArrayList();这样不会有任何问题。

和List list = new ArrayList();相比这2个写是有区别的。arrayList是一个ArrayList对象，它可以使用ArrayList的所有方法。

List是接口，它是不可以被实例化的（接口是个抽象类），所以必须以它的实现类去实例化它。list对象虽然也是被实例化为ArrayList但是它实际是List对象，list只能使用ArrayList中已经实现了的List接口中的方法，ArrayList中那些自己的、没有在List接口定义的方法是不可以被访问到的。

我们说，用接口去做是有它的好处的，如果你把类型定义成ArrayList(也就是一个具体的实现类)那么你就只能接收这一种类型的数据了，如果你要是定义为List那么你不仅可以接收ArrayList的对象还可以接收LinkedList的对象，这样你的程序就灵活了。

然后，我们看下如何强制实现父类调用子类的方法。

该做法的意义何在，姑且不论。今天我们主要关注该功能的实现，至少在实现的思路上是对面向对象思想的一次深入理解。

首先一点，父类引用是无法调用子类独有的方法（不仅无法访问，而且是不可见的），结论是显然的，不然该方法就不作为子类所独有了，不然子类就没有任何的独特之处了（隐私空间），也就丧失了子类存在的意义。

// C++
class Base
{

};

class Derived :public Base
{
public:
    void foo() {}
};

int main(int, char**)
{
    Base* pBase = new Derived;
    pBase->foo();
                        // class “Base” 没有成员 “foo”
    return 0;
}

解决方案是，在父类中声明一个虚函数用以向下类型转换，在父类中给出其接口实现（否则会出现链接错误），在子类中自然给出其真正实现。

class Derived;  
                    // 前置声明
class Base
{
public:
    virtual Derived& downcast() { return *(Derived* )NULL; }
    virtual const Derived& downcast() const { return *(Derived* )NULL; }
};

class Derived :public Base
{
public:
    Derived& downcast() { return *this; }
    const Derived& downcast() const { return *this;}
    void foo(){ }
};

注意，因为在父类Base要用到子类Derived类的声明，我们需要在父类的定义之前，对子类进行前置声明（forward declaration）。

int main(int, char**)
{
    Base* pBase = new Derived;
    pBase->downcast().foo();
                            // 通过
    return 0;
}

在论坛看到的其他的方法：

1. ATL 里的用法，有时间可以看一下 <深入解析 ATL> 附录

#include <stdio.h>
 
template <typename T>
class A
{
public:
    A()
    {
        T *pT = (T *) this;
        pT->speek();
    }
};
 
class B    :    public A<B>
{
public:
    void speek()
    {
        printf("OK\n");
    }
};
 
int main()
{
    B b;
    return 0;
}

2.B “is a” A 同时 A “has a” B

#include <iostream>
using namespace std;
 
class B;
 
class A
{
private:
    B* b;
public:
    A(){};
    A(B* b);
    void fun();
};
 
class B : public A
{
public:
    B(){};
    void speek()
    {
        printf("OK\n");
    }
};
 
A::A(B* b)
{
    this->b = b;
}
 
void A::fun()
{
    b->speek();
}
 
int main()
{
    A a(new B);
    a.fun();
 
    return 0;
}

参考：https://bbs.csdn.net/topics/390171765