【外文翻译】C++和 Java 语法差异对照表，可以贴在电脑旁

首先是两件大事-主要功能以及如何编译它，然后有很多微小差异。

main function

C++

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

Java

// 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" );
    }
}

编译

C++

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

Java

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

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

注释

两种语言相同（//和/ * * /都可以）

类的声明

几乎相同，但是Java不需要分号

C++

    class Bar {};

Java

    class Bar {}

方法声明

相同，除了在Java中，必须始终是类的一部分，并且可以以public / private / protected开头

构造函数和析构函数

构造函数在两者（类名）中具有相同的语法，Java没有与析构函数完全等效的语法

静态成员函数和变量

与方法声明相同，但是Java提供了一个_静态_初始化_块_来初始化静态变量（而不是将定义加入源代码文件中）：

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

确定静态方法和命名空间的作用域

C++

如果您有一个类并希望引用一个静态方法，则使用Class :: method形式。

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

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

Java

Java中的所有作用域都使用。再次，就像访问一个类的分段一样，它也更常规一些：

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

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

对象声明

C++

    // on the stack
    myClass x;

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

Java

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

访问对象字段

C++

如果您使用的是基于常规的对象，则可以使用点来访问其细分：

myClass x;
x.my_field; // ok

但是在使用指针时，您可以使用箭头运算符（->）访问类的细分：

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

Java

您始终使用引用（至少指针，请参见下一段），因此始终使用点：

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

引用与指针

C++

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

Java

    // 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

继承

C++

    class Foo : public Bar
    { ... };

Java

    class Foo extends Bar
    { ... }

访问修饰符

C++

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

Java

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

虚函数

C++

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

Java

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

抽象类

C++

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

Java

    // 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 */ }
    }

内存管理

大致相同--u new_2;allocates，但在Java中没有_delete_，因为它有垃圾回收。

null的区别

C++

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

Java

    // 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;

Boolean类型

Java有点冗长：必须编写boolean而不仅仅是bool。

C++

bool foo;

Java

boolean foo;

Const-ness

C++

    const int x = 7;

Java

    final int x = 7;

抛出异常

C++

int foo() throw (IOException)

Java

int foo() throws IOException

数组

C++

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

Java

    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

集合与迭代

C++

迭代器是类的成员。范围的开始是.begin（），结束是 < container> .end（）。使用 ++ 运算符前进，并使用 * 进行访问。

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

Java

迭代器只是一个接口。范围的开始是.iterator，然后使用 itr.hasNext（）检查是否在结尾处。您可以使用 itr.next（）（在 C ++ 中使用 ++ 和 * 的组合）获得下一个元素。

    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 );
    }

---

===myJavaKeKeArticleKeyId:202011110003===

作者：Alex Allain

来源链接：

https://www.cprogramming.com/tutorial/java/syntax-differences-java-c++.html