Category: Java

C++、Java类方法绑定方式对比

c++,java 动态绑定和静态绑定的对比

/* a.cpp */
#include <iostream>
using namespace std;
class Base
{
    public:
        virtual void method1(){cout<<"Base Method1"<<endl;};
        method2(){cout<<"Base Method2"<<endl;};
};
class Derived:public Base
{
    public:
        void method1(){cout<<"Derived Method1"<<endl;}
        void method2(){cout<<"Derived Method2"<<endl;}
};
int main(int argc,char** argv)
{
    Base *b = new Derived();
    b->method1();
    b->method2();
    delete b;
    return 0;
}

Output:

Derived Method1
Base Method2

/* A.java */
class A
{
    public void method1(){
        System.out.println("Base method1");
    }
    public void method2(){
        System.out.println("Base method2");
    }
    public static void main(String[] args){
        A a = new B();
        a.method1();
        a.method2();
    }
};
/* B.java */
class B extends A
{
    public void method1(){
        System.out.println("Derived method1");
    }
    public void method2(){
        System.out.println("Derived method2");
    }
}

Output:

Derived method1
Derived method2

从上面的对比中可以看出

c++中要覆盖父类的方法，必须再父类的被覆盖的方法前加virtual,即将改方法声明为虚函数，这样c++编译器会产生一个虚函数表

java中如果子类中的方法名和参数列表与父类中的相同，则父类的方法自动被覆盖，不需要做而外的声明

java中默认是动态绑定或叫晚绑定，所以java中要引入 final 关键词以禁止默认的动态绑定

c++中默认是静态绑定或叫早绑定，所以c++要引入 virtual 关键词以支持动态绑定

C++、Java、Delphi类继承的对比

总体来说

  • c++: 完全的控制,极大的灵活性,灵活带来的复杂
  • java:比c++"保守",虚拟机风格的体系结构
  • delphi:很保守

inclusion/using clause

#include <iostream>
using namespace std;

import java.io.*;

uses windows,system,sysutils;

inheritance
class Child:[public | protected | private] Fahter,public Mother{
            ...
}

C++是这三种语言中继承最为复杂的.
分为 public,protected,private继承,同时支持真正的多继承

public继承(又称类型继承)和java的继承一样,保持父类的访问控制

protected继承将父类public成员改变为protected的

private继承(又称实现继承)不直接支持父类的公有接口,而提供自己的公有接口

所以private继承中,子类将父类中原先的protected成员和public成员都置为private的
所以原则上private继承中的子类应该是继承树中的叶节点,它只有private和public成员而
没有protected成员.它不应该再被继承,类似于Java中的final class

class Child extends Father implements IInterface{
            ...
}

TChild = class(TFather,IInterfacedObject)
            ...
end;

java 和 delphi 的继承相似,都是单继承同时可以实现多个接口

Access Control/Organization

class Foo{
   private:
    int i;
             int j;
             void f();
   protected: 
             int k;
   public: 
             int o;
}

class Foo /* extends Object */ {
  private
             int i;
             int j;
             void f(){...};
   protected
             int k;
   public
             int o;
}

TFoo = class(TObject)
   private 
             i:Integer;
             j:Integer;
   protected
             k:Integer;
   public
             o:Integer;
   publicshed
   property
             Tag:Integer read i write i;
end;

如果不给出访问控制,
c++默认是private
java默认是包内可见的
delphi默认是public的(单元内可见?)

c++的访问控制和代码管理最为丰富:
可以通过#include包含c/cpp头文件,提供向c的兼容
同时可以使用名字空间防止名字冲突,并且像c一样将代码分为头文件和实现文件
同时丰富性也带来了复杂性.使得c++的文件组织没有java和delphi清晰

java提供了松散的代码组织方式–包(package),而delphi提供了单元的代码组织方法
这两种组织方法相似,都是给了我们一个存放一组相关类的地方.而这个地方,在java中
是一个文件系统上的文件夹,在delphi中是一个单元文件
相比之下,我还是喜欢Delphi的组织方法:当类很多的时候java包中的文件变得既多又不好管理

Scroll to top