C++&JAVA异同

2、内存动态分配
C++中使用new和delete进行内存的动态分配和回收，new是在堆内存上开辟空间，内存使用完毕之后，必须手动使用delete来回收。

Java中只要是声明了引用数据类型，在使用之前，必须使用new进行内存空间的开辟。但是在对象消亡之后，不用手工的进行内存回收。Java自有的内存回收机制会自动回收垃圾对象（所谓垃圾对象，是指之前开辟的对象内存，不再被栈内存所引用了）。当然也可以通过System.gc()方法进行手工的回收。
3、析构函数
C++析构函数（无参，无返回值）的作用是释放构造函数中动态分配的内存空间，即调用（此调用可以通过对象．析构函数调用，也可以等对象生存期结束时系统自动调用）析构函数。

Java中没有析构函数，通过垃圾回收机制，自动回收垃圾对象。不过可以通过覆写Object类中的fanalize()方法，实现与C++中析构函数一样的效果，当手动或自动销毁对象时，会自动调用fanalize()方法。
4、空类中的内容
C++的空类一定还有4个函数：默认构造函数，默认析构函数，默认拷贝构造函数，

Java的空类中有：默认构造函数，从Object类继承来的方法，如
类中默认属性
C++类中的成员访问权限三种：public>protected>private。不声明的话，默认为private权限。

Java类中的成员访问权限四种：public>protected>defalt>private。默认是default权限。
5、类中成员函数的实现
C++中是习惯在．h头文件的类中声明函数；在类外的．cpp文件中实现函数，要#include头文件。
如：
//demo.h
Class Person{
Public:
Void fun() ; //类中声明
}

//demo.cpp
#include “demo.h”
Void Person ：：fun(){ //类外实现
。。。。//实现体
}

Java是类中声明+实现方法。如果不在类中实现，再加上abstract关键字就是抽象方法了。
如：
class Person{
Public void fun(){//类中声明+实现
。。。。//实现体
}
}
6、对象的实例化
class Person{
private ：
int age ;
public ：
Person(){}
Person(int a){
age = a ;
}
void fun(){….}
}
。。。。 //主函数开始
Person p1 ; //调用的是无参的构造函数
Person p2(18) ; //调用带参构造函数
p1.fun() ; //调用成员函数
p2.fun() ;

java中实例化对象，必须使用new关键字。
class Person{
private String name ;
private int age ;
public Person(){}
public Person(String name, int age){
this.name = name ;
this.age = age ;
}
public void fun() {…..}
}
。。。。。//主函数开始
Person p1 = null ;
p1 = new Person() ; //必须使用new关键字开辟内存空间，调用无参构造。
Person p2 = new Person(“张三”, 18) ;  //调用带参构造。
p1.fun() ; //调用方法
p2.fun() ;
7、This关键字
C++中叫this指针，实例化一个对象时，会默认产生一个this指针指向这个对象，作用是编译器用来区别同一类的不同对象。即当对象．成员函数时，通过this指针知道是哪个对象，调用成员函数来操作该对象的成员属性。

Java中this有3个用途：
1、表示本类中的属性或方法。如this．方法，this．属性。
2、表示当前对象。
3、调用本类的构造方法。如this()，this(参数1,参数2.。。。)。
【其中用途1、2的作用类似C++中的this指针。】
8、对象成员的调用
C++通过对象．成员函数，或是类指针->成员函数来调用。

Java中只能通过对象．成员函数调用。

二者中Static属性的成员，可以直接通过类名．成员函数直接调用。
9、子类-->父类,构造函数的传参
共同点：子类中的构造函数如果不明确指出调用父类的哪个构造函数时，系统默认去调用父类的无参构造函数。同时，如果父类中自己定义了带参的构造函数，最好再定义一个无参的构造函数。

class Person{
private ：
int age ;
public ：
Person(){}
Person(int a){
age = a ;
}
}
class Student ：public Person{
private ：
int score ;
public ：
Student(int a, int s) ：Person(a){ //向父类构造函数传递
score = s ;
}
}

class Person{
private String name ;
private int age ;
public Person(){}
public Person(String name, int age){
this.name = name ;
this.age = age ;
}
}
class Student extends Person{
private int score ;
public Student(String name, int age, int score){
super(name,age) ; //向父类构造函数传递
this.score = score ;
}
}
10、多态性
C++中的多态性必须靠【虚函数或纯虚函数+子类对虚函数或纯虚函数的覆盖】实现。
虚函数用virtual声明，
如：
virtual void fun() ；//类内声明
void 类名 ：fun() {….}//类外实现

Java通过子类对普通父类中普通方法的覆写、子类对抽象类中普通方法或抽象方法的覆写、子类对接口中抽象方法的覆写。+向上转型。
抽象方法用abstract声明，且没有内容实现。
如：
abstract void fun() ; //类内无实现
11、抽象类
二者的抽象类都不能实例化对象。纯虚函数和抽象方法概念类似，作用类似。

C++中也可以说有抽象类，带有纯虚函数的类。
纯虚函数是没有内容实现，且带有“=0”的虚函数，不能实例化对象。
如：
virtual void fun() = 0 ; //类内声明为=0，类外也不实现。

Java中的抽象类是用abstract关键字声明的类，其中包含了抽象方法。不能实例化对象。
Java中的接口是一种特殊的类，或者说一种特殊的抽象类。是由全部的静态常量和抽象函数构成。
12、访问权限
C++通过3种继承方式来改变子类与父类间成员的访问权限。
class Student ：public Person{
public ：
。。。。。。
Private ：
。。。。。。
}；
class worker ：protected Person{
public ：
。。。。。。
Private ：
。。。。。。
}；
Class farmer ：private Person{
public ：
。。。。。。
Private ：
。。。。。。
}；

Java通过包机制实现不同类之间成员的访问权限。
Package org.tyut.a
class Person{
private …..
private ……
public …….
public ……
}
package org.tuyt.b
class Person{
private …..
private ……
public …….
public ……
}
package org.tuyt.c
class Person{
private …..
private ……
public …….
public ……
}

13、C++预处理&java导入包
二者的思路是一样的：想使用当前类以外的类时，
C++中，在类定义前使用#include预编译指令，将要包含的类库包含进来。
标准类库用尖括号<  >，不带h。自定义类库用双引号“”，带h，会先从当前路径查找。
如：
#include  <iostream>
#include “demo.h”

Java中，将要使用的类导入进来，使用import命令，要注明类所在的包。
如：
imort  java．Lang．* ；
import  org．tyut．* ；

 

评论

1 楼 zeeeitch 2009-11-28  

想对第3点说一下


java的垃圾回收和finalize函数做清理，属于“不确定性”清理，和析构函数思想不一样，finalize基本没什么作用，我看没什么人写

和c++析构特性一起提出的RAII，对应的java还是使用代理模式进行资源监控，如spring对事务的自动处理那样