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

main 方法

Java

//java 的函数必须写在类里
class HelloWorld{
public static void main(String args[]){
System.out.println( "Hello, World" );
}
}
//java 的函数必须写在类里
classHelloWorld{
publicstaticvoidmain(Stringargs[]){
System.out.println("Hello, World");
}
}
C++
//C++ 的函数可以写在任意地方 没有限制
int main( int argc, char* argv[])
{
printf( "Hello, world" );
}
//C++ 的函数可以写在任意地方 没有限制
intmain(intargc,char*argv[])
{
printf("Hello, world");
}
编译
Java
// 编译成 HelloWorld.class
javac HelloWorld.java
//直接运行HelloWorld.java 中的main 方法
java HelloWorld
// 编译成 HelloWorld.class
javacHelloWorld.java
//直接运行HelloWorld.java 中的main 方法
javaHelloWorld
C++
//编译生产helloworld
g++ helloworld.cpp -o helloworld
//运行
./helloworld
//编译生产helloworld
g++helloworld.cpp-ohelloworld
//运行
./helloworld
注释
Java 和 C++ 注释的方法都是一样的分别为行注释// 和块注释/* */。
类的声明
大部分是一样的但是C++ 需要分号结尾而Java 则不需要
Java
class Foo{
classFoo{
}
C++
class Foo{
};
classFoo{
};

函数的声明

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

构造函数

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

静态方法

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

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

Java

class HelloWorld{
public static void hello(){//声明
//helloworld....
}
}
//调用
HelloWorld.hello();
classHelloWorld{
publicstaticvoidhello(){//声明
//helloworld....
}
}
//调用
HelloWorld.hello();
C++
class HelloWorld
{
public:
static void hello(){
//helloworld....
}
};
//调用
HelloWorld::hello();
classHelloWorld
{
public:
staticvoidhello(){
//helloworld....
}
};
//调用
HelloWorld::hello();
对象的声明
Java
//直接在堆(heap)上分配内存
HelloWorld helloWorld = new HelloWorld();
//直接在堆(heap)上分配内存
HelloWorldhelloWorld=newHelloWorld();
C++
//在堆栈(stack)上
HelloWorld helloworld;
//或者在堆(heap)上
HelloWorld *helloworld = new HelloWorld;
//在堆栈(stack)上
HelloWorldhelloworld;
//或者在堆(heap)上
HelloWorld*helloworld=newHelloWorld;
访问对象中的属性
Java
HelloWorld helloWorld = new HelloWorld();
//Java 中 使用. 来调用对象中的属性
helloWorld.my_field;
HelloWorldhelloWorld=newHelloWorld();
//Java 中 使用. 来调用对象中的属性
helloWorld.my_field;
C++
// 基于堆栈的对象的需要用.来访问对象中的属性
HelloWorld helloworld;
helloworld.my_field;
//使用指针时使用箭头运算符(->)来访问类的字段
HelloWorld *helloworld = new HelloWorld;
helloworld->my_field;
// 基于堆栈的对象的需要用.来访问对象中的属性
HelloWorldhelloworld;
helloworld.my_field;
//使用指针时使用箭头运算符(->)来访问类的字段
HelloWorld*helloworld=newHelloWorld;
helloworld->my_field;
引用(References)和指针(pointers)
Java
//Java 中的引用是可变的 并且只存储对象的地址。 Java 中没有指针
HelloWorld helloWorld;
helloWorld.hello();//会报空指针异常
//Java 中的引用是可变的 并且只存储对象的地址。 Java 中没有指针
HelloWorldhelloWorld;
helloWorld.hello();//会报空指针异常
C++
//引用是不可变的,指针是灵活的
int x = 7,y = 6;
int& z = x;
//引用是不可变的,指针是灵活的
intx=7,y=6;
int&z=x;

继承

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

Java

//java 的继承使用关键字 extends(当然java 中的对象默认都是继承Object 对象的)
class HelloWorld extends Object{
...
}
//java 的继承使用关键字 extends(当然java 中的对象默认都是继承Object 对象的)
classHelloWorldextendsObject{
...
}
C++
//C++ 使用 : 表示继承
class HelloWorld : public Foo
{
...
};
//C++ 使用 : 表示继承
classHelloWorld:publicFoo
{
...
};
访问修饰符
Java
//对所有类可见。
public void print();
//在同一类内可见。
private void print();
// 对同一包内的类和所有子类可见。
protected void print();
//默认修饰符(default) 在同一包内可见。
void print();
//对所有类可见。
publicvoidprint();
//在同一类内可见。
privatevoidprint();
// 对同一包内的类和所有子类可见。
protectedvoidprint();
//默认修饰符(default) 在同一包内可见。
voidprint();
C++
//类的外部是可访问,跟Java类似
public:
void print();
//私有成员变量或函数在类的外部是不可访问的，甚至是不可查看的
private:
void print();
//默认情况下，类的所有成员都是私有的
void print();
//保护成员变量或函数与私有成员十分相似，但有一点不同，保护成员在派生类(即子类)中是可访问的
protected:
void print();
//类的外部是可访问,跟Java类似
public:
voidprint();
//私有成员变量或函数在类的外部是不可访问的，甚至是不可查看的
private:
voidprint();
//默认情况下，类的所有成员都是私有的
voidprint();
//保护成员变量或函数与私有成员十分相似，但有一点不同，保护成员在派生类(即子类)中是可访问的
protected:
voidprint();
抽象类
Java
//java 可以明确制定为抽象类 子类必须实现print() 函数
abstract class HelloWorld{
public abstract void print();
}
//或者你可以定义个接口
interface HelloWorld{
public void print();
}
//然后你可以实现这个接口
class HelloWorlImp implements HelloWorld{
public void print(){
...
}
}
//java 可以明确制定为抽象类 子类必须实现print() 函数
abstractclassHelloWorld{
publicabstractvoidprint();
}
//或者你可以定义个接口
interfaceHelloWorld{
publicvoidprint();
}
//然后你可以实现这个接口
classHelloWorlImpimplementsHelloWorld{
publicvoidprint(){
...
}
}
C++
//只需要定义一个纯虚函数
class HelloWorld
{
public:
virtual void print()=0;
}
//只需要定义一个纯虚函数
classHelloWorld
{
public:
virtualvoidprint()=0;
}

内存管理

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

布尔类型的定义

Java

boolean foo;
booleanfoo;
C++
bool foo;
boolfoo;
常量定义
Java
final int x = 8;
finalintx=8;
C++
const int x = 8;
constintx=8;
异常
Java
void print() throw IOException{
...
}
try{
print();
}catch(IOException e){
...
}
voidprint()throwIOException{
...
}
try{
print();
}catch(IOExceptione){
...
}
C++
void print(){
throw "Exception!!!";
}
try{
print();
}catch(...){//使用省略号表示让 catch 块能够处理 try 块抛出的任何类型的异常
...
}
voidprint(){
throw"Exception!!!";
}
try{
print();
}catch(...){//使用省略号表示让 catch 块能够处理 try 块抛出的任何类型的异常
...
}
数组
Java
//直接定义使用 不用管回收问题
int [] x = new int[10];
//直接定义使用 不用管回收问题
int[]x=newint[10];
C++
int x[10];
//或者
int *x = new x[10];
//用x 然后释放调
delete[] x;
intx[10];
//或者
int*x=newx[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);
}
ArrayListlist=newArrayList();
Iteratoriterator=list.iterator();
while(iterator.hasNext()){
System.out.println(itr.next());
}
//或者
for(Objecto:list){
System.out.println(o);
}
C++
vector myVec;
for ( vector::iterator itr = myVec.begin();itr != myVec.end();++itr )
{
cout << *itr;
}
vectormyVec;
for(vector::iteratoritr=myVec.begin();itr!=myVec.end();++itr)
{
cout<
}

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