Java 和 C++ 语法之间的区别

main 方法

Java

//java 的函数必须写在类里
class HelloWorld{
    public static void main(String args[]){
        System.out.println( "Hello, World" );
    }
}

C++

//C++ 的函数可以写在任意地方 没有限制
int main( int argc, char* argv[])
{
    printf( "Hello, world" );
}

编译

Java

// 编译成 HelloWorld.class
javac HelloWorld.java
//直接运行HelloWorld.java 中的main 方法
java HelloWorld

C++

//编译生产helloworld
g++ helloworld.cpp -o helloworld
//运行
./helloworld

注释

Java 和 C++ 注释的方法都是一样的分别为行注释// 和块注释/* */。

类的声明

大部分是一样的但是C++ 需要分号结尾而Java 则不需要

Java

1
2
3

class Foo{

}

C++

1
2
3

class Foo{

};

函数的声明

大部分一样，在Java中函数必须定义在类中，并且可以使用 public ,private,protected 作为前缀,而在C++ 中函数可以单独定义(比如一个cpp 文件中就一个函数).

构造函数

构造函数基本一致都是类的名字为构造函数名。但是C++ 中还有个析构函数这个函数的名称与类的名称是完全相同的,只是在前面加了个波浪号（~）作为前缀,它不会返回任何值，也不能带有任何参数。析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。

静态方法

Java 是通过类名.来调用静态方法的

C++ 是通过类名::来调用静态方法的

Java

class HelloWorld{
    public static void hello(){//声明
        //helloworld....
    }
}

//调用
HelloWorld.hello();

C++

class HelloWorld
{
    public:
    static void hello(){
        //helloworld....
    }
};
//调用
HelloWorld::hello();

对象的声明

Java

1 2	//直接在堆(heap)上分配内存 HelloWorld helloWorld = new HelloWorld();

C++

//在堆栈(stack)上
HelloWorld helloworld;

//或者在堆(heap)上
HelloWorld *helloworld = new HelloWorld;

访问对象中的属性

Java

1
2
3

HelloWorld helloWorld = new HelloWorld();
//Java 中 使用. 来调用对象中的属性
helloWorld.my_field;

C++

// 基于堆栈的对象的需要用.来访问对象中的属性
HelloWorld helloworld;
helloworld.my_field;

//使用指针时使用箭头运算符（->）来访问类的字段
HelloWorld *helloworld = new HelloWorld;
helloworld->my_field;

引用(References)和指针(pointers)

Java

1
2
3

//Java 中的引用是可变的 并且只存储对象的地址。 Java 中没有指针
HelloWorld helloWorld;
helloWorld.hello();//会报空指针异常

C++

1
2
3

//引用是不可变的,指针是灵活的
int x = 7,y = 6;
int& z = x;

继承

Java 只能单继承,C++ 可以多继承(对这个比较头疼，还有环形继承更搞不懂什么鬼。有点难以理解，有兴趣的可以去找找资料)

Java

//java 的继承使用关键字 extends(当然java 中的对象默认都是继承Object 对象的)
class HelloWorld extends Object{
    ...
}

C++

//C++ 使用 : 表示继承
class HelloWorld : public Foo
{
    ...
};

访问修饰符

Java

//对所有类可见。
public void print();
//在同一类内可见。
private void print();
// 对同一包内的类和所有子类可见。
protected void print();
//默认修饰符(default) 在同一包内可见。
void print();

C++

//类的外部是可访问,跟Java类似
public:
    void print();
//私有成员变量或函数在类的外部是不可访问的，甚至是不可查看的
private:
    void print();
//默认情况下，类的所有成员都是私有的
void print();
//保护成员变量或函数与私有成员十分相似，但有一点不同，保护成员在派生类（即子类）中是可访问的
protected:
    void print();

抽象类

Java

//java 可以明确制定为抽象类 子类必须实现print() 函数
abstract class HelloWorld{
    public abstract void print();
}
//或者你可以定义个接口
interface HelloWorld{
    public void print();
}
//然后你可以实现这个接口
class HelloWorlImp implements HelloWorld{
    public void print(){
        ...
    }
}

C++

//只需要定义一个纯虚函数
class HelloWorld
{
    public:
        virtual void print()=0;
}

关于纯虚函数和虚函数有什么区别可以点这里看看http://www.runoob.com/w3cnote/cpp-virtual-functions.html

内存管理

都是通过new 来分配内存的,C++ 需要自己来管理内存释放，Java 则不需要管，有垃圾回收

布尔类型的定义

Java

1	boolean foo;

C++

bool foo;

常量定义

Java

1	final int x = 8;

C++

1	const int x = 8;

异常

Java

void print() throw IOException{
    ...
}

try{
    print();
}catch(IOException e){
    ...
}

C++

void print(){
    throw "Exception!!!";
}

try{
    print();
}catch(...){//使用省略号表示让 catch 块能够处理 try 块抛出的任何类型的异常
    ...
}

数组

Java

1 2	//直接定义使用不用管回收问题 int [] x = new int[10];

C++

int x[10];
//或者
int *x = new x[10];
//用x 然后释放调
delete[] x;

集合和迭代

Java

ArrayList list = new ArrayList();
Iterator iterator = list.iterator();
while(iterator.hasNext()){
    System.out.println( itr.next() );
}
//或者
for(Object o: list){
    System.out.println(o);
}

C++

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

暂时补充到这，如发现有问题请联系我哈！