C++&JAVA異同

2019-11-17 04:00:59

字體：大中小

來源：轉載

供稿：網友

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

上一篇：java經典題目

下一篇：java備份MySQL (windows linux)