class Base
{
    public static void say( String s )
    {
        System.out.println( s );
    }

    public void sayHello()
    {
        say( "Base.sayHello says..." );
        say( "Base hello" );
    }

    public Base()
    {
        sayHello();
    }
}

class Derived
    extends Base
{
    private String[] myWords;   // = new String[]{ "Derived", "hello" };

    public void sayHello()
    {
        say( "Derived.sayHello says..." );
        say( myWords[0] + " " + myWords[1] );
    }

    Derived()
    {
        myWords = new String[]{ "Derived", "hello" };
    }
}

class ConsCallDemo
{
    public static void main( String[] args )
    {
        Derived o = new Derived();
    }
}

Derived.sayHello says...
Exception in thread "main" java.lang.NullPointerException
        at Derived.sayHello(conscall.java:28)
        at Base.(conscall.java:16)
        at Derived.(conscall.java:32)
        at ConsCallDemo.main(conscall.java:41)

C++通过在施工和销毁期间积极调整物体类型来防止这一问题。 在C++中,标的为Base>, 标的为Base. 因此,在<代码>Base内,不论实际的瞬时状态,只要物体从<代码>Base上调,即可发出。

举例来说,仅仅将 Java法翻译成C++:

#include <iostream>
#include <string>
#include <vector>
using namespace std;

void say( string const& s )
{
    cout << s << endl;
}

class Base
{
public:
    virtual void sayHello() const
    {
        say( "Base::sayHello says..." );
        say( "Base hello" );
    }

    Base()
    {
        sayHello();
    }
};

class Derived
    : Base
{
private:
    vector< string >    words_;

public:
    void sayHello() const
    {
        say( "Derived::sayHello says..." );
        say( words_[0] + " " + words_[1] );
    }

    Derived()
    {
        words_.push_back( "Derived" );
        words_.push_back( "hello" );
    }
};

int main()
{
    Derived o;
}

产出:

Base::sayHello says...
Base hello

在C++中取得“in 预期效应”的一种方式,这也表明如何在 Java(适当)做到这一点:

#include <iostream>
#include <string>
#include <vector>
#include <boost/shared_ptr.hpp>
using namespace std;

void say( string const& s )
{
    cout << s << endl;
}

class Base
{
protected:
    struct Greeter
    {
        typedef boost::shared_ptr< Greeter >    Ptr;

        virtual void sayHello() const
        {
            say( "Base::sayHello says..." );
            say( "Base hello" );
        }
    };

private:
    Greeter::Ptr    greeter_;

public:
    void sayHello() const
    {
        greeter_->sayHello();
    }

    Base( Greeter::Ptr greeter = Greeter::Ptr( new Greeter ) )
        : greeter_( greeter )
    {
        sayHello();
    }
};

class Derived
    : Base
{
protected:
    struct Greeter
        : Base::Greeter
    {
        vector< string >    words_;

        virtual void sayHello() const
        {
            say( "Derived::sayHello says..." );
            say( words_[0] + " " + words_[1] );
        }

        Greeter()
        {
            words_.push_back( "Derived" );
            words_.push_back( "hello" );
        }
    };

public:
    Derived()
        : Base( Greeter::Ptr( new Greeter ) )
    {}
};

int main()
{
    Derived o;
}

产出:

Derived::sayHello says...
Derived hello

关于你的其他要点,在此讨论得太多。 了解C++0x支持比C++98更切合实际的初始化。 而且,你第7点的正式方面有点争议,但对此有缺陷的报告(如《附加说明的参考手册》所述,在标准C++中不允许它,但显然打算在标准C98中允许它,但措辞只是自成不变的。

Cheers & hth.,

约7:

In Java, I cannot make a public function of the base class private in the derived class. I was shocked to see that in C++ is OK and even useful.

如果你能够隐藏一种不会保证你方法的超流层方法,则不能由用户使用。 人们总是可以向上下流,并称出这一方法,因为 Java的所有非静态方法都是作为C++的虚拟方法,实际上将称作你的子级方法。

它将采用静态方法,但我认为,压倒一切的静态方法是一种良好做法。

The need to hide methods in subclasses usually means bad design, but if you really need to, you should throw an exception. The down side of this is that it s runtime, but when a call occurs it WILL crash. Whereas in C++, if you hide a method but cast to the parent class, if its virtual the method will actually get called and if it s statically linked the parent class method will get called, both are probably not what you want.