C++&JAVA异同

来源：互联网发布：撮合算法编辑：程序博客网时间：2024/04/30 10:28

C++与Java异同

1、指针★★★★★
C C++中的指针，提供了很大的灵活性，但是灵活也带来了危险，对指针操作的不当容易造成内存泄露或是空悬指针等问题。

Java取消了指针。但实际上，java中声明的所有引用数据类型的名称，可以理解为就是一个指针。该名称存储在栈内存上，指向对内存上使用new开辟的空间。

如：

int[] array = new int[10]

整型数组名array在栈内存上，在堆内存上开辟了10*4字节的空间，用array指向该块内存。

可以把array理解为一个指针，里面存放的地址就是new出来的空间。

如：

class Person{

……

}

Person p = new Person() ;

对象名p开辟在栈内存，用new为对象在堆内存开辟空间，对象名p指向该堆内存。

但实际上呢，该名称并不像C++中的指针，特别是在进行参数传递的时候。

java已经声明：参数传递都是值传递。

但是当引用数据类型作为函数参数的时候，把一个已声明的对象p1传进来的时候，其实是产生了一个该对象的副本p2，这个p2指向p1，所以通过p2调用p1的成员时，可以完成修改，等函数调用结束，保留修改。如：

class Person{

public String name ;

public int age ;

public Person(String name ,int age){

this.name = name ;

this.age = age ;

}

public class Test{

public static void main(String[] args){

Person p = new Person("张三" , 10) ;

System.out.println("修改前-->姓名："+ p.name+"，年龄："+p.age) ;

changePro(p) ; //对象p传进来，这时产生p的一个副本，假设是p1，它指向p。 //通过这个副本p1，可以调用p的成员。

System.out.println("修改后-->姓名："+ p.name+"，年龄："+p.age) ;

}

public static void changePro(Person p){ //通过副本可以调用原对象的成员

p.name = "李四" ;

p.age = 30 ;

}

}

结果：

修改前-->姓名：张三，年龄：10

修改后-->姓名：李四，年龄：30

但当你把p1传进来之后，产生副本p2，然后试图通过p2来改变p1的指向，显然是不可能的，这时改变的仅仅是p2的指向，函数调用结束之后，p1的指向不变。如：

class Person{

public String name ;

public int age ;

public Person(String name ,int age){

this.name = name ;

this.age = age ;

}

public class Test{

public static void main(String[] args){

Person p = new Person("张三" , 10) ;

System.out.println("修改前-->姓名："+ p.name+"，年龄："+p.age) ;

changeObj(p) ; //对象p传进来，这是产生p的一个副本，假设是p1，它指向p。 //在函数中，改变的只是这个副本的指向。

System.out.println("修改后-->姓名："+ p.name+"，年龄："+p.age) ;

}

public static Person newP = new Person("李四", 30) ;

public static void changeObj(Person p){

p = newP ; //企图改变指向，实际改变的是副本的指向，

//函数结束后，原对象的指向不会改变

}

}

结果：

修改前-->姓名：张三，年龄：10

修改后-->姓名：张三，年龄：10

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．* ；