java與C++的區別

「做爲一名C++程序員，咱們早已掌握了面向對象程序設計的基本概念，並且Java的語法無疑是很是熟悉的。事實上，Java原本就是從C++衍生出來的。」
　　然而，C++和Java之間仍存在一些顯著的差別。能夠這樣說，這些差別表明着技術的極大進步。一旦咱們弄清楚了這些差別，就會理解爲何說Java是一種優秀的程序設計語言。本附錄將引導你們認識用於區分Java和C++的一些重要特徵。
　　(1) 最大的障礙在於速度：解釋過的Java要比C的執行速度慢上約20倍。不管什麼都不能阻止Java語言進行編譯。寫做本書的時候，剛剛出現了一些準實時編譯器，它們能顯著加快速度。固然，咱們徹底有理由認爲會出現適用於更多流行平臺的純固有編譯器，但倘若沒有那些編譯器，因爲速度的限制，必須有些問題是Java不能解決的。
　　(2) 和C++同樣，Java也提供了兩種類型的註釋。
　　(3) 全部東西都必須置入一個類。不存在全局函數或者全局數據。若是想得到與全局函數等價的功能，可考慮將static方法和static數據置入一個類裏。注意沒有象結構、枚舉或者聯合這一類的東西，一切只有「類」（Class）！
　　(4) 全部方法都是在類的主體定義的。因此用C++的眼光看，彷佛全部函數都已嵌入，但實情並不是如何（嵌入的問題在後面講述）。
　　(5) 在Java中，類定義採起幾乎和C++同樣的形式。但沒有標誌結束的分號。沒有class foo這種形式的類聲明，只有類定義。
　　class aType()
　　void aMethod() {/* 方法主體*/}
　　}
　　(6) Java中沒有做用域範圍運算符「::」。Java利用點號作全部的事情，但能夠不用考慮它，由於只能在一個類裏定義元素。即便那些方法定義，也必須在一個類的內部，因此根本沒有必要指定做用域的範圍。咱們注意到的一項差別是對static方法的調用：使用ClassName.methodName()。除此之外，package（包）的名字是用點號創建的，並能用import關鍵字實現C++的「#include」的一部分功能。例以下面這個語句：
　　import java.awt.*;
　　（#include並不直接映射成import，但在使用時有相似的感受。）
　　(7) 與C++相似，Java含有一系列「主類型」（Primitive type），以實現更有效率的訪問。在Java中，這些類型包括boolean，char，byte，short，int，long，float以及double。全部主類型的大小都是固有的，且與具體的機器無關（考慮到移植的問題）。這確定會對性能形成必定的影響，具體取決於不一樣的機器。對類型的檢查和要求在Java裏變得更苛刻。例如：
　　■條件表達式只能是boolean（布爾）類型，不可以使用整數。
　　■必須使用象X+Y這樣的一個表達式的結果；不能僅僅用「X+Y」來實現「反作用」。
　　(8) char（字符）類型使用國際通用的16位Unicode字符集，因此能自動錶達大多數國家的字符。
　　(9) 靜態引用的字串會自動轉換成String對象。和C及C++不一樣，沒有獨立的靜態字符數組字串可供使用。
　　(10) Java增添了三個右移位運算符「>>>」，具備與「邏輯」右移位運算符相似的功用，可在最末尾插入零值。「>>」則會在移位的同時插入符號位（即「算術」移位）。
　　(11) 儘管表面上相似，但與C++相比，Java數組採用的是一個頗爲不一樣的結構，並具備獨特的行爲。有一個只讀的length成員，經過它可知道數組有多大。並且一旦超過數組邊界，運行期檢查會自動丟棄一個異常。全部數組都是在內存「堆」裏建立的，咱們可將一個數組分配給另外一個（只是簡單地複製數組句柄）。數組標識符屬於第一級對象，它的全部方法一般都適用於其餘全部對象。
　　(12) 對於全部不屬於主類型的對象，都只能經過new命令建立。和C++不一樣，Java沒有相應的命令能夠「在堆棧上」建立不屬於主類型的對象。全部主類型都只能在堆棧上建立，同時不使用new命令。全部主要的類都有本身的「封裝（器）」類，因此可以經過new建立等價的、之內存「堆」爲基礎的對象（主類型數組是一個例外：它們可象C++那樣經過集合初始化進行分配，或者使用new）。
　　(13) Java中沒必要進行提早聲明。若想在定義前使用一個類或方法，只需直接使用它便可——編譯器會保證使用恰當的定義。因此和在C++中不一樣，咱們不會碰到任何涉及提早引用的問題。
　　(14) Java沒有預處理機。若想使用另外一個庫裏的類，只需使用import命令，並指定庫名便可。不存在相似於預處理機的宏。
　　(15) Java用包代替了命名空間。因爲將全部東西都置入一個類，並且因爲採用了一種名爲「封裝」的機制，它能針對類名進行相似於命名空間分解的操做，因此命名的問題再也不進入咱們的考慮之列。數據包也會在單獨一個庫名下收集庫的組件。咱們只需簡單地「import」（導入）一個包，剩下的工做會由編譯器自動完成。
　　(16) 被定義成類成員的對象句柄會自動初始化成null。對基本類數據成員的初始化在Java裏獲得了可靠的保障。若不明確地進行初始化，它們就會獲得一個默認值（零或等價的值）。可對它們進行明確的初始化（顯式初始化）：要麼在類內定義它們，要麼在構建器中定義。採用的語法比C++的語法更容易理解，並且對於static和非static成員來講都是固定不變的。咱們沒必要從外部定義static成員的存儲方式，這和C++是不一樣的。
　　(17) 在Java裏，沒有象C和C++那樣的指針。用new建立一個對象的時候，會得到一個引用（本書一直將其稱做「句柄」）。例如：
　　String s = new String("howdy");
　　然而，C++引用在建立時必須進行初始化，並且不可重定義到一個不一樣的位置。但Java引用並不必定侷限於建立時的位置。它們可根據狀況任意定義，這便消除了對指針的部分需求。在C和C++裏大量採用指針的另外一個緣由是爲了能指向任意一個內存位置（這同時會使它們變得不安全，也是Java不提供這一支持的緣由）。指針一般被看做在基本變量數組中四處移動的一種有效手段。Java容許咱們以更安全的形式達到相同的目標。解決指針問題的終極方法是「固有方法」（已在附錄A討論）。將指針傳遞給方法時，一般不會帶來太大的問題，由於此時沒有全局函數，只有類。並且咱們可傳遞對對象的引用。Java語言最開始聲稱本身「徹底不採用指針！」但隨着許多程序員都質問沒有指針如何工做？因而後來又聲明「採用受到限制的指針」。你們可自行判斷它是否「真」的是一個指針。但無論在何種狀況下，都不存在指針「算術」。
　　(18) Java提供了與C++相似的「構建器」（Constructor）。若是不本身定義一個，就會得到一個默認構建器。而若是定義了一個非默認的構建器，就不會爲咱們自動定義默認構建器。這和C++是同樣的。注意沒有複製構建器，由於全部自變量都是按引用傳遞的。
　　(19) Java中沒有「破壞器」（Destructor）。變量不存在「做用域」的問題。一個對象的「存在時間」是由對象的存在時間決定的，並不是由垃圾收集器決定。有個finalize()方法是每個類的成員，它在某種程度上相似於C++的「破壞器」。但finalize()是由垃圾收集器調用的，並且只負責釋放「資源」（如打開的文件、套接字、端口、URL等等）。如需在一個特定的地點作某樣事情，必須建立一個特殊的方法，並調用它，不能依賴finalize()。而在另外一方面，C++中的全部對象都會（或者說「應該」）破壞，但並不是Java中的全部對象都會被看成「垃圾」收集掉。因爲Java不支持破壞器的概念，因此在必要的時候，必須謹慎地建立一個清除方法。並且針對類內的基礎類以及成員對象，須要明確調用全部清除方法。
　　(20) Java具備方法「過載」機制，它的工做原理與C++函數的過載幾乎是徹底相同的。
　　(21) Java不支持默認自變量。
　　(22) Java中沒有goto。它採起的無條件跳起色制是「break 標籤」或者「continue 標準」，用於跳出當前的多重嵌套循環。
　　(23) Java採用了一種單根式的分級結構，所以全部對象都是從根類Object統一繼承的。而在C++中，咱們可在任何地方啓動一個新的繼承樹，因此最後每每看到包含了大量樹的「一片森林」。在Java中，咱們不管如何都只有一個分級結構。儘管這表面上看彷佛形成了限制，但因爲咱們知道每一個對象確定至少有一個Object接口，因此每每能得到更強大的能力。C++目前彷佛是惟一沒有強制單根結構的惟一一種OO語言。
　　(24) Java沒有模板或者參數化類型的其餘形式。它提供了一系列集合：Vector（向量），Stack（堆棧）以及Hashtable（散列表），用於容納Object引用。利用這些集合，咱們的一系列要求可獲得知足。但這些集合並不是是爲實現象C++「標準模板庫」（STL）那樣的快速調用而設計的。Java 1.2中的新集合顯得更加完整，但仍不具有正宗模板那樣的高效率使用手段。
　　(25) 「垃圾收集」意味着在Java中出現內存漏洞的狀況會少得多，但也並不是徹底不可能（若調用一個用於分配存儲空間的固有方法，垃圾收集器就不能對其進行跟蹤監視）。然而，內存漏洞和資源漏洞可能是因爲編寫不當的finalize()形成的，或是因爲在已分配的一個塊尾釋放一種資源形成的（「破壞器」在此時顯得特別方便）。垃圾收集器是在C++基礎上的一種極大進步，使許多編程問題消彌於無形之中。但對少數幾個垃圾收集器力有不逮的問題，它倒是不大適合的。但垃圾收集器的大量優勢也使這一處缺點顯得微不足道。
　　(26) Java內建了對多線程的支持。利用一個特殊的Thread類，咱們可經過繼承建立一個新線程（放棄了run()方法）。若將synchronized（同步）關鍵字做爲方法的一個類型限制符使用，相互排斥現象會在對象這一級發生。在任何給定的時間，只有一個線程能使用一個對象的synchronized方法。在另外一方面，一個synchronized方法進入之後，它首先會「鎖定」對象，防止其餘任何synchronized方法再使用那個對象。只有退出了這個方法，纔會將對象「解鎖」。在線程之間，咱們仍然要負責實現更復雜的同步機制，方法是建立本身的「監視器」類。遞歸的synchronized方法能夠正常運做。若線程的優先等級相同，則時間的「分片」不能獲得保證。
　　(27) 咱們不是象C++那樣控制聲明代碼塊，而是將訪問限定符（public，private和protected）置入每一個類成員的定義裏。若未規定一個「顯式」（明確的）限定符，就會默認爲「友好的」（friendly）。這意味着同一個包裏的其餘元素也能夠訪問它（至關於它們都成爲C++的「friends」——朋友），但不可由包外的任何元素訪問。類——以及類內的每一個方法——都有一個訪問限定符，決定它是否能在文件的外部「可見」。private關鍵字一般不多在Java中使用，由於與排斥同一個包內其餘類的訪問相比，「友好的」訪問一般更加有用。然而，在多線程的環境中，對private的恰當運用是很是重要的。Java的protected關鍵字意味着「可由繼承者訪問，亦可由包內其餘元素訪問」。注意Java沒有與C++的protected關鍵字等價的元素，後者意味着「只能由繼承者訪問」（之前可用「private protected」實現這個目的，但這一對關鍵字的組合已被取消了）。
　　(28) 嵌套的類。在C++中，對類進行嵌套有助於隱藏名稱，並便於代碼的組織（但C++的「命名空間」已使名稱的隱藏顯得多餘）。Java的「封裝」或「打包」概念等價於C++的命名空間，因此再也不是一個問題。Java 1.1引入了「內部類」的概念，它祕密保持指向外部類的一個句柄——建立內部類對象的時候須要用到。這意味着內部類對象也許能訪問外部類對象的成員，毋需任何條件——就好象那些成員直接隸屬於內部類對象同樣。這樣便爲回調問題提供了一個更優秀的方案——C++是用指向成員的指針解決的。
　　(29) 因爲存在前面介紹的那種內部類，因此Java裏沒有指向成員的指針。
　　(30) Java不存在「嵌入」（inline）方法。Java編譯器也許會自行決定嵌入一個方法，但咱們對此沒有更多的控制權力。在Java中，可爲一個方法使用final關鍵字，從而「建議」進行嵌入操做。然而，嵌入函數對於C++的編譯器來講也只是一種建議。
　　(31) Java中的繼承具備與C++相同的效果，但採用的語法不一樣。Java用extends關鍵字標誌從一個基礎類的繼承，並用super關鍵字指出準備在基礎類中調用的方法，它與咱們當前所在的方法具備相同的名字（然而，Java中的super關鍵字只容許咱們訪問父類的方法——亦即分級結構的上一級）。經過在C++中設定基礎類的做用域，咱們可訪問位於分級結構較深處的方法。亦可用super關鍵字調用基礎類構建器。正如早先指出的那樣，全部類最終都會從Object裏自動繼承。和C++不一樣，不存在明確的構建器初始化列表。但編譯器會強迫咱們在構建器主體的開頭進行所有的基礎類初始化，並且不容許咱們在主體的後面部分進行這一工做。經過組合運用自動初始化以及來自未初始化對象句柄的異常，成員的初始化可獲得有效的保證。
　　public class Foo extends Bar {
　　 public Foo(String msg) {
　　 super(msg); // Calls base constructor
　　 }
　　 public baz(int i) { // Override
　　 super.baz(i); // Calls base method
　　 }
　　}
　　(32) Java中的繼承不會改變基礎類成員的保護級別。咱們不能在Java中指定public，private或者protected繼承，這一點與C++是相同的。此外，在衍生類中的優先方法不能減小對基礎類方法的訪問。例如，假設一個成員在基礎類中屬於public，而咱們用另外一個方法代替了它，那麼用於替換的方法也必須屬於public（編譯器會自動檢查）。
　　(33) Java提供了一個interface關鍵字，它的做用是建立抽象基礎類的一個等價物。在其中填充抽象方法，且沒有數據成員。這樣一來，對於僅僅設計成一個接口的東西，以及對於用extends關鍵字在現有功能基礎上的擴展，二者之間便產生了一個明顯的差別。不值得用abstract關鍵字產生一種相似的效果，由於咱們不能建立屬於那個類的一個對象。一個abstract（抽象）類可包含抽象方法（儘管並不要求在它裏面包含什麼東西），但它也能包含用於具體實現的代碼。所以，它被限制成一個單一的繼承。經過與接口聯合使用，這一方案避免了對相似於C++虛擬基礎類那樣的一些機制的須要。
　　爲建立可進行「例示」（即建立一個實例）的一個interface（接口）的版本，需使用implements關鍵字。它的語法相似於繼承的語法，以下所示：
　　public interface Face {
　　 public void smile();
　　}
　　public class Baz extends Bar implements Face {
　　 public void smile( ) {
　　 System.out.println("a warm smile");
　　 }
　　}
　　(34) Java中沒有virtual關鍵字，由於全部非static方法都確定會用到動態綁定。在Java中，程序員沒必要自行決定是否使用

文章出處：飛諾網(http://dev.firnow.com/course/3_program/c++/cppjs/20090403/164032.html)

JAVA和C++都是面嚮對象語言。也就是說，它們都可以實現面向對象思想（封裝，繼承，多態）。而因爲C++爲了照顧大量的C語言使用者， 而兼容了C，使得自身僅僅成爲了帶類的C語言，多多少少影響了其面向對象的完全性！JAVA則是徹底的面嚮對象語言，它句法更清晰，規模更小，更易學。它是在對多種程序設計語言進行了深刻細緻研究的基礎上，據棄了其餘語言的不足之處，從根本上解決了c++的固有缺陷。 Java和c++的類似之處多於不一樣之處，但兩種語言幾處主要的不一樣使得Java更容易學習，而且編程環境更爲簡單。

 

轉自：http://club.topsage.com/thread-265349-1-1.html

Java並不只僅是C++語言的一個變種，它們在某些本質問題上有根本的不一樣： 　　

（1）Java比C++程序可靠性更高。有人曾估計每50行C++程序中至少有一個BUG。姑且不去討論這個數字是否誇張，可是任何一個C++程序員都不得不認可C++語言在提供強大的功能的同時也提升了程序含BUG的可能性。Java語言經過改變語言的特性大大提升了程序的可靠性。 　　

（2）Java語言不須要程序對內存進行分配和回收。Java丟棄了C++  中不多使用的、很難理解的、使人迷惑的那些特性，如操做符重載、多繼承、自動的強制類型轉換。特別地，Java語言不使用指針，並提供了自動的廢料收 集，Examda提示: 在Java語言中，內存的分配和回收都是自動進行的，程序員無須考慮內存碎片的問題。 　　

（3）Java語言中沒有指針的概念，引入了真正的數組。不一樣於C++中利用指針實現的「僞數組」，Examda,Java引入了真正的數組，同時將 容易形成麻煩的指針從語言中去掉，這將有利於防止在c++程序中常見的由於數組操做越界等指針操做而對系統數據進行非法讀寫帶來的不安全問題。 　　

（4）Java用接口（Interface）技術取代C++程序中的多繼承性。接口與多繼承有一樣的功能，可是省卻了多繼承在實現和維護上的複雜性。 　　

Java和C++各有各的優點，無需爭論那種語言好，哪一種語言很差，可以存在就必定有它的優點，只要你決定了要學編程就紮實的學好，編程語言都是相同的，學會一種，其餘的學起來就很容易了。

 

具體來講有如下幾點：

1．指針 JAVA語言讓編程者沒法找到指針來直接訪問內存，而且增添了自動的內存管理功能，從而有效地防止了c/c++語言中指針操做失誤，如野指針所形成的系統崩潰。但也不是說JAVA沒有指針，虛擬機內部仍是使用了指針，只是外人不得使用而已。這有利於Java程序的安全。

2．多重繼承 c++支持多重繼承，這是c++的一個特徵，它容許多父類派生一個類。儘管多重繼承功能很強，但使用複雜，並且會引發許多麻煩，編譯程序實現它也很不容易。Java不支持多重繼承，但容許一個類繼承多個接口(extends+implement)，實現了c++多重繼承的功能，又避免了c++中的多重繼承實現方式帶來的諸多不便。

3. 數據類型及類 Java是徹底面向對象的語言，全部函數和變量都必須是類的一部分。除了基本數據類型以外，其他的都做爲類對象，包括數組。對象將數據和方法結合起來，把它們封裝在類中，這樣每一個對象均可實現本身的特色和行爲。而c++容許將函數和變量定義爲全局的。此外，Java中取消了c/c++中的結構和聯合，消除了沒必要要的麻煩。

4. 自動內存管理 Java程序中全部的對象都是用new操做符創建在內存堆棧上，這個操做符相似於c++的new操做符。下面的語句由一個創建了一個類Read的對象，而後調用該對象的work方法：

 

Read r＝new Read()；
r.work()；

語句Read r＝new Read()；在堆棧結構上創建了一個Read的實例。Java自動進行無用內存回收操做，不須要程序員進行刪除。而c++中必須由程序貝釋放內存資源， 增長了程序設計者的負扔。Java中當一個對象不被再用到時，無用內存回收器將給它加上標籤以示刪除。JAVA裏無用內存回收程序是以線程方式在後臺運行的，利用空閒時間工做。

5. 操做符重載 Java不支持操做符重載。操做符重載被認爲是c++的突出特徵，在Java中雖然類大致上能夠實現這樣的功能，但操做符重載的方便性仍然丟失了很多。Java語言不支持操做符重載是爲了保持Java語言儘量簡單。

6. 預處理功能 Java不支持預處理功能。c/c++在編譯過程當中都有一個預編澤階段，即衆所周知的預處理器。預處理器爲開發人員提供了方便，但增長了編譯的複雜性。JAVA虛擬機沒有預處理器，但它提供的引入語句(import)與c++預處理器的功能相似。

7. Java不支持缺省函數參數，而c++支持 在c中，代碼組織在函數中，函數能夠訪問程序的全局變量。c++增長了類，提供了類算法，該算法是與類相連的函數，c++類方法與Java類方法+分類似，然而，因爲c++仍然支持c，因此不能阻止c++開發人員使用函數，結果函數和方法混合使用使得程序比較混亂。Java沒有不包含在類中的函數，做爲一個比c++更純的面向對象的語言，Java強迫開發人員把全部例行程序包括在類中，事實上，用方法實現例行程序可激勵開發人員更好地組織編碼。

8. 字符串 c和c++不支持字符串變量，在c和c++程序中使用Null終止符表明字符串的結束，在Java中字符串是用類對象(strinR和stringBuffer)來實現的，這些類對象是Java語言的核心，用類對象實現字符串有如下幾個優勢：

(1)在整個系統中創建字符串和訪問字符串元素的方法是一致的；

(2)Java字符串類是做爲Java語言的一部分定義的，而不是做爲外加的延伸部分；

(3)Java字符串執行運行時檢空，可幫助排除一些運行時發生的錯誤；

(4)可對字符串用「+」進行鏈接操做。

9. goto語句 「可怕」的goto語句是c和c++的「遺物」，它是該語言技術上的合法部分，引用goto語句引發了程序結構的混亂，不易理解，goto語句子要用於無 條件轉移子程序和多結構分支技術。鑑於以廣理由，Java不提供goto語句，它雖然指定goto做爲關鍵字，但不支持它的使用，使程序簡潔易讀。

l0. 類型轉換 在c和c++中有時出現數據類型的隱含轉換，這就涉及了自動強制類型轉換問題。例如，在c++中可將一浮點值賦予整型變量，並去掉其尾數。Java不支持c++中的自動強制類型轉換，若是須要，必須由程序顯式進行強制類型轉換。

11. 異常 JAVA中的異常機制用於捕獲例外事件，加強系統容錯能力

 

try{//可能產生例外的代碼

}catch(exceptionType name){

//處理

}

 其中exceptionType表示異常類型。而C++則沒有如此方便的機制。