C++、Java语法差异对照表

// free-floating function
int main( int argc, char* argv[])
{
    printf( "Hello, world" );
}

// every function must be part of a class; the main function for a particular
// class file is invoked when java <class> is run (so you can have one
// main function per class--useful for writing unit tests for a class)
class HelloWorld
{
    public static void main(String args[])
    {
        System.out.println( "Hello, World" );
    }
}

    // compile as
    g++ foo.cc -o outfile
    // run with
    ./outfile

    // compile classes in foo.java to <classname>.class
    javac foo.java 

    // run by invoking static main method in <classname>
    java <classname>

    class Bar {};

    class Bar {}

class Foo 
{
    static private int x;
    // static initialization block
    { x = 5; }
}

class MyClass
{
    public:
    static doStuff();
};

// now it's used like this
MyClass::doStuff();

class MyClass
{
    public static doStuff()
    {
        // do stuff
    }
}

// now it's used like this
MyClass.doStuff();

    // on the stack
    myClass x;

    // or on the heap
    myClass *x = new myClass;

    // always allocated on the heap (also, always need parens for constructor)
    myClass x = new myClass();

myClass x;
x.my_field; // ok

myClass x = new MyClass;
x->my_field; // ok

myClass x = new MyClass();
x.my_field; // ok

    // references are immutable, use pointers for more flexibility
    int bar = 7, qux = 6;
    int& foo = bar;

    // references are mutable and store addresses only to objects; there are
    // no raw pointers
    myClass x;
    x.foo(); // error, x is a null ``pointer''

    // note that you always use . to access a field

    class Foo : public Bar
    { ... };

    class Foo extends Bar
    { ... }

    public:
        void foo();
        void bar();

    public void foo();
    public void bar();

    virtual int foo(); // or, non-virtually as simply int foo();

    // functions are virtual by default; use final to prevent overriding
    int foo(); // or, final int foo();

    // just need to include a pure virtual function
    class Bar { public: virtual void foo() = 0; };

    // syntax allows you to be explicit!
    abstract class Bar { public abstract void foo(); }

    // or you might even want to specify an interface
    interface Bar { public void foo(); }

    // and later, have a class implement the interface:
    class Chocolate implements Bar
    {
        public void foo() { /* do something */ }
    }

    // initialize pointer to NULL
    int *x = NULL;

    // the compiler will catch the use of uninitialized references, but if you
    // need to initialize a reference so it's known to be invalid, assign null
    myClass x = null;

bool foo;

boolean foo;

    const int x = 7;

    final int x = 7;

int foo() throw (IOException)

int foo() throws IOException

    int x[10];
    // or 
    int *x = new x[10];
    // use x, then reclaim memory
    delete[] x;

    int[] x = new int[10];
    // use x, memory reclaimed by the garbage collector or returned to the
    // system at the end of the program's lifetime

    vector myVec;
    for ( vector<int>::iterator itr = myVec.begin();
          itr != myVec.end();
          ++itr )
    {
        cout << *itr;
    }

    ArrayList myArrayList = new ArrayList();
    Iterator itr = myArrayList.iterator();
    while ( itr.hasNext() )
    {
        System.out.println( itr.next() );
    }

    // or, in Java 5
    ArrayList myArrayList = new ArrayList();
    for( Object o : myArrayList ) {
        System.out.println( o );
    }