C++与Java的语法区别

C++与Java的语法区别

首先，两个大的不同是主函数和怎样编译的不同，接下来是许多小的区别。

main 函数
C++
//自由浮动的函数
int main( int argc, char* argv[])
{
    printf( "Hello, world" );
}
Java
// 每个函数都必须是一个类的一部分;当java <class>运行是一个特定类的主函数会被调用
// (因此你可以让每个类都有一个main函数，这在写单元测试是很有用)
class HelloWorld
{
    public static void main(String args[])
    {
        System.out.println( "Hello, World" );
    }
}

类的声明
除了 Java 不要求用分号外几乎是相同的。 
C++
    class Bar {};
    
Java
    class Bar {}
   

方法声明
   都相同的, 除了在Java,方法必须总是 某个类的一部分并且可能public/private/protected 作为修饰

构造函数和析构函数
构造函数都是相同的 (即类的名字), Java没有准确意义上的的析构函数

静态成员函数和变量
方法声明是相同的, 但 Java 提供静态初始化块来来初始化静态变量 (不需要在源文件中声明): 
class Foo 
{
    static private int x;
    // 静态初始化块
    { x = 5; }
}

对象的声明
C++
    // 在栈中
    myClass x;
 
    //或者在堆中
    myClass *x = new myClass;
    
Java
   // 总是在对堆中声明
    myClass x = new myClass();
   

继   承
C++
    class Foo : public Bar
    { ... };
    
Java
    class Foo extends Bar
    { ... }
    

访问级别 (abstraction barriers)
C++
   public:
        void foo();
        void bar();
    
Java
    public void foo();
    public void bar();
    

虚函数
C++
    virtual int foo(); // 或者非虚函数写作 int foo();
    
Java
    // 函数默认的就是虚函数; 用final关键字防止重载
    int foo(); // 或者, final int foo();

内存管理
大体上是相同的--new 来分配， 但是 Java没有 delete，因为它有垃圾回收器。

NULL vs null
C++
    // 初始化一个指针为 NULL
    int *x = NULL;
    
Java
   // 编译器将捕获使用未初始化的引用
   //但是如果你因需要初始化一个引用而赋一个null，那么这是无效的
    myClass x = null;
    

布尔型
Java有一点罗嗦: 你必须写 boolean而不止是 bool. 
C++
   bool foo;
Java
     boolean foo;

常   量
C++
    const int x = 7;
    
Java
    final int x = 7;
    

抛异常
首先，Java在编译器强制抛异常—如果你的方法可能会抛异常你必需明确报告 
C++
     int foo() throw (IOException)
Java
     int foo() throws IOException

数     组
C++
    int x[10];
    // 或
    int *x = new x[10];
    // 使用 x,然后归还内存
    delete[] x;
    
Java
    int[] x = new int[10];
    // 使用 x, 内存有垃圾回收器回收或
    //或在程序生命周期尽头归还给系统
    

集合和迭代器
C++
迭代器是类的成员。范围的开始是<容器>.begin(), 结束是 <容器>.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() );
    }
 
    // 或, 在Java 5中
    ArrayList myArrayList = new ArrayList();
    for( Object o : myArrayList ) {
        System.out.println( o );
    }
    
 

    
抽象类
C++
     // 只需要包含一个纯虚函数
    class Bar { public: virtual void foo() = 0; };
    
Java
     // 语法上允许显示的声明!
    abstract class Bar { public abstract void foo(); }
 
    // 或者你也可以声明一个接口
    interface Bar { public void foo(); }
 
    // 然后让一个类继承这个接口:
    class Chocolate implements Bar
    {
        public void foo() { /* do something */ }
    }
    
引用 vs  指针
C++
     //引用不可改变,通过使用指针来获得更多的灵活性
    int bar = 7, qux = 6;
    int& foo = bar;
    
Java
     // 引用是可变的，仅存储对象地址; 
    //没有指针类型
    myClass x;
    x.foo(); // error, x is a null ``pointer''
 
    // 注意你要总是用 . 来访问域
    
编  译
C++
     // 编译
    g++ foo.cc -o outfile
    // 运行
    ./outfile
    
Java
    // 编译foo.java文件中的类成<classname>.class    javac foo.java 
    // 通过调用<classname>中的静态main方法来运行
    java <classname >
    
注   释

两种语言是一样的 (// 和 /* */ 可以用)

1.关于作用域，
如下代码：
///
{
 int x = 125;
 {
  int x=34; //Illegal
 }
}

在c/c++中，这中写法是没有问题的，这叫作用域屏蔽（是这么叫吧？），但在java里这样写就是非法的，的确这是个很好的避免引起歧义的做法。

2.java没有sizeof（）

3.java终于摒弃了goto，同时提供了另一个类似的功能
的东东，以便能在适当的地方起些适当的作用。label.
///
label1:
outer-iteration
{
 inner-iteration
 {
  //......
  break; //案例1
  //......
  continue; //案例2
  //......
  continue label1; //案例3
  //......
  break label1; //案例4
  //......
 }
}
/
在案例1中break中断了内部循环，退到了外部循环。案例2中continue仍在内部循环。案例3中continue到label1
处，重新开始循环。案例4退到label1处，但是这次再不进入循环了（不可思议）。

以上规则同样适用于while循环。

4.如果Java的基类里有一个被重载了好几次的方法，那么在派生类里重新定义那个方法，是不会把基类里定义的任何一个给遮盖掉的(这点同C++不同)。其实在派生类里用相同的参数列表，相同的返回类型来覆写方法的这种做法，实在是太普通了。

5.多了package

访问控制符， import, 每个编译单元（.java文件）只能有一个public类，如果还有其他类，那这些类就成为这个
public类的辅助类，这是因为他们都不是public的，因此对外边世界来说，它们都是看不到的。

编译.java文件的时候，它里面的每个类都会产生输出。其输出的文件名字就是.java里面类的名字，这样写不了
几个java文件就会产生一堆.class文件，但是不要奇怪，一个能正常工作的java文件本来就是由一堆.class文件
组成的，当然也可以用jar把他们封装成java Archive （JAR）文件。java解释器会负责寻找，装载和解释这些
文件的。

package和import就好像一个刀一个盾。是把一个单独的全局名字空间分割开来，这样不论internet上有多少人
再用java编程，你就都不会再碰到名字冲突的问题了。值得注意的是，每次创建package给它起名的时候，你也
隐含的设置了一个目录结构。这个package必须保存在由它的名字所指示的目录里，而这个目录又必须在classpath
下面。

java的访问控制符：public是众所周知的可以任何人都可以访问的；package权限，默认的访问权限没有关键词，
但通常还是把它成为package权限，（有时也成为friendly）它的意思是所有同属这个package的类都能访问这个
成员，由于同一编译单元只能同属一个package，因此同一个编译单元里的各个类，自动的可以进行相互访问。
protected, private.