-
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.* ;