/* 运行时动态绑定被调过程的“虚拟方法”(virtual method)机制是实现多态的关键技术。C++、Java和C#作为三种主流的支持对面向对象的程序设计语言,自然都提供了这种动态的方法绑定机制,但当“虚拟”(virtual)和“私有”(private)碰在一起时,这几种语言在处理上却有所不同,本文的故事就是从一段小程序说起的: 我们来看下面这段短小的C++程序:*/ // Test.cpp #include <iostream> using namespace std; class Base { public: void f(){ g(); } private: virtual void g(){ cout << "Hi, MorningStar! I am g() of Base!." << endl; } }; class Derived : public Base { private: virtual void g(){ cout << "Hi, MorningStar! I am g() of Derived." << endl; } };int main() { Base *pB = new Derived(); pB->f(); delete pB; return 0; }/* 程序很简单,我们在基类“Base”中,通过公有方法f调用了虚拟的私有方法g,而继承自Base的Derived类中覆写(override)了私有的方法g。 先不考虑其他,语法上有问题吗?没有;编译能通过吗?能。那运行结果是什么呢?既然编译能通过,那么结果也就能猜到了,应该是: Hi, MorningStar! I am g() of Derived.在Java中,没有“virtual”这么个关键字,默认就是virtual,不可被覆写的才需要加关键字“final”。Java中,对已被覆写的方法如果想调用其父类的方法,则需通过特殊的关键字“super”调用。好了,不多说Java语法了,我们看下面一段类似的Java程序:*/ class Base{ public void f(){ g(); } private void g(){ System.out.println("Hi, MorningStar! I am g() of Base."); } }public class Derived extends Base { private void g(){ System.out.println("Hi, MorningStar! I am g() of Derived."); } public static void main(String[] args) { Base b = new Derived(); b.f(); } }/* 结果为: Hi, MorningStar!, I am g() of Base. 由此可见,C++语言中仅仅分别规定了public,protected和private三者的访问控制问题和virtual方法的动态绑定问题,而对于他们的组合,没加任何限制,换句话说,前后是两种无关的机制,访问控制专门负责访问权限的问题,不管方法是不是虚拟;而虚拟只管延迟绑定的问题,不管公有、保护还是私有。 然而,从面向对象的角度考虑,基类中私有的东西对外界、对继承类都是不可见的,继承类根本不应该知道基类中任何私有的东西,于是继承、覆写也应无从谈起才对,即使方法重名,那也应该仅仅看作一种巧合,Java就是这么做的。 在Java中,private天生就是final的,所以,在Java中,我们讨论继承和多态都是针对类的对外接口,包括puclic方法、protected方法和默认的friendly方法,而private是不被纳入考量的,从某种意义上,Java中的private方法纯粹是为方法而方法,是一种组织代码使之更清晰,更易维护的手段而已。 但如果仅从语法语义上考虑,而不是从面向对象的理论上考虑,或许C++更厚道一些——既然没有限制,那么private也可以virtual,既然可以virtual,那也就应该享受virtual级的待遇。而Java也没什么virtual不virtual,没有任何语法痕迹便闷声地规定:public/protected/friendly的是这样,而private的是那样。*/
/*
运行时动态绑定被调过程的“虚拟方法”(virtual method)机制是实现多态的关键技术。C++、Java和C#作为三种主流的支持对面向对象的程序设计语言,自然都提供了这种动态的方法绑定机制,但当“虚拟”(virtual)和“私有”(private)碰在一起时,这几种语言在处理上却有所不同,本文的故事就是从一段小程序说起的:
我们来看下面这段短小的C++程序:*/
// Test.cpp
#include <iostream>
using namespace std;
class Base
{
public:
void f(){
g();
}
private:
virtual void g(){
cout << "Hi, MorningStar! I am g() of Base!." << endl;
}
};
class Derived : public Base
{
private:
virtual void g(){
cout << "Hi, MorningStar! I am g() of Derived." << endl;
}
};int main()
{
Base *pB = new Derived();
pB->f();
delete pB;
return 0;
}/*
程序很简单,我们在基类“Base”中,通过公有方法f调用了虚拟的私有方法g,而继承自Base的Derived类中覆写(override)了私有的方法g。
先不考虑其他,语法上有问题吗?没有;编译能通过吗?能。那运行结果是什么呢?既然编译能通过,那么结果也就能猜到了,应该是:
Hi, MorningStar! I am g() of Derived.在Java中,没有“virtual”这么个关键字,默认就是virtual,不可被覆写的才需要加关键字“final”。Java中,对已被覆写的方法如果想调用其父类的方法,则需通过特殊的关键字“super”调用。好了,不多说Java语法了,我们看下面一段类似的Java程序:*/
class Base{
public void f(){
g();
}
private void g(){
System.out.println("Hi, MorningStar! I am g() of Base.");
}
}public class Derived extends Base {
private void g(){
System.out.println("Hi, MorningStar! I am g() of Derived.");
}
public static void main(String[] args) {
Base b = new Derived();
b.f();
}
}/*
结果为:
Hi, MorningStar!, I am g() of Base.
由此可见,C++语言中仅仅分别规定了public,protected和private三者的访问控制问题和virtual方法的动态绑定问题,而对于他们的组合,没加任何限制,换句话说,前后是两种无关的机制,访问控制专门负责访问权限的问题,不管方法是不是虚拟;而虚拟只管延迟绑定的问题,不管公有、保护还是私有。
然而,从面向对象的角度考虑,基类中私有的东西对外界、对继承类都是不可见的,继承类根本不应该知道基类中任何私有的东西,于是继承、覆写也应无从谈起才对,即使方法重名,那也应该仅仅看作一种巧合,Java就是这么做的。
在Java中,private天生就是final的,所以,在Java中,我们讨论继承和多态都是针对类的对外接口,包括puclic方法、protected方法和默认的friendly方法,而private是不被纳入考量的,从某种意义上,Java中的private方法纯粹是为方法而方法,是一种组织代码使之更清晰,更易维护的手段而已。
但如果仅从语法语义上考虑,而不是从面向对象的理论上考虑,或许C++更厚道一些——既然没有限制,那么private也可以virtual,既然可以virtual,那也就应该享受virtual级的待遇。而Java也没什么virtual不virtual,没有任何语法痕迹便闷声地规定:public/protected/friendly的是这样,而private的是那样。*/
class A
{
...
class B:A
{
...
}
}