将用不到的dll和jar去掉,只保留下面的文件
将rt.jar中不需要的classes删掉。
以前有篇文章是写给Delphi程序增加对Pax JavaScript的支持
今天研究了一下给Java程序增加对 Ruby 的支持
目前可以通过 Apache的 BSF(Bean Script Framework)
和Sun的 Java Scripting(javax.script)
Continue reading “Java程序中引入JRuby”
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 关键词以支持动态绑定
总体来说
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包中的文件变得既多又不好管理