JAVA和C++都是面向?qū)ο笳Z言。也就是說，它們都能夠?qū)崿F(xiàn)面向?qū)ο笏枷耄ǚ庋b，繼乘，多態(tài)）。而由于c++為了照顧大量的C語言使用者，而兼容了C，使得自身僅僅成為了帶類的C語言，多多少少影響了其面向?qū)ο蟮膹氐仔?！JAVA則是完全的面向?qū)ο笳Z言，它句法更清晰，規(guī)模更小，更易學(xué)。它是在對多種程序設(shè)計(jì)語言進(jìn)行了深入細(xì)致研究的基礎(chǔ)上，摒棄了其他語言的不足之處，從根本上解決了c++的固有缺陷。
公司主營業(yè)務(wù)：成都做網(wǎng)站、成都網(wǎng)站建設(shè)、移動(dòng)網(wǎng)站開發(fā)等業(yè)務(wù)。幫助企業(yè)客戶真正實(shí)現(xiàn)互聯(lián)網(wǎng)宣傳，提高企業(yè)的競爭能力。創(chuàng)新互聯(lián)建站是一支青春激揚(yáng)、勤奮敬業(yè)、活力青春激揚(yáng)、勤奮敬業(yè)、活力澎湃、和諧高效的團(tuán)隊(duì)。公司秉承以“開放、自由、嚴(yán)謹(jǐn)、自律”為核心的企業(yè)文化，感謝他們對我們的高要求，感謝他們從不同領(lǐng)域給我們帶來的挑戰(zhàn)，讓我們激情的團(tuán)隊(duì)有機(jī)會(huì)用頭腦與智慧不斷的給客戶帶來驚喜。創(chuàng)新互聯(lián)建站推出赤峰免費(fèi)做網(wǎng)站回饋大家。
Java和c++的相似之處多于不同之處，但兩種語言有幾處主要的不同使得Java更容易學(xué)習(xí)，并且編程環(huán)境更為簡單。
我在這里不能完全列出不同之處，僅列出比較顯著的區(qū)別：
1．指針
JAVA語言讓編程者無法找到指針來直接訪問內(nèi)存無指針，并且增添了自動(dòng)的內(nèi)存管理功能，從而有效地防止了c／c++語言中指針操作失誤，如野指針?biāo)斐傻南到y(tǒng)崩潰。但也不是說JAVA沒有指針，虛擬機(jī)內(nèi)部還是使用了指針，只是外人不得使用而已。這有利于Java程序的安全。
2．多重繼承
c++支持多重繼承，這是c++的一個(gè)特征，它允許多父類派生一個(gè)類。盡管多重繼承功能很強(qiáng)，但使用復(fù)雜，而且會(huì)引起許多麻煩，編譯程序?qū)崿F(xiàn)它也很不容易。Java不支持多重繼承，但允許一個(gè)類繼承多個(gè)接口(extends+implement)，實(shí)現(xiàn)了c++多重繼承的功能，又避免了c++中的多重繼承實(shí)現(xiàn)方式帶來的諸多不便。
3．?dāng)?shù)據(jù)類型及類
Java是完全面向?qū)ο蟮恼Z言，所有函數(shù)和變量都必須是類的一部分。除了基本數(shù)據(jù)類型之外，其余的都作為類對象，包括數(shù)組。對象將數(shù)據(jù)和方法結(jié)合起來，把它們封裝在類中，這樣每個(gè)對象都可實(shí)現(xiàn)自己的特點(diǎn)和行為。而c++允許將函數(shù)和變量定義為全局的。此外，Java中取消了c／c++中的結(jié)構(gòu)和聯(lián)合，消除了不必要的麻煩。
4．自動(dòng)內(nèi)存管理
Java程序中所有的對象都是用new操作符建立在內(nèi)存堆棧上，這個(gè)操作符類似于c++的new操作符。下面的語句由一個(gè)建立了一個(gè)類Read的對象，然后調(diào)用該對象的work方法：
Read r＝new Read()；
r.work()；
語句Read r＝new Read()；在堆棧結(jié)構(gòu)上建立了一個(gè)Read的實(shí)例。Java自動(dòng)進(jìn)行無用內(nèi)存回收操作，不需要程序員進(jìn)行刪除。而c十十中必須由程序員釋放內(nèi)存資源，增加了程序設(shè)計(jì)者的負(fù)擔(dān)。Java中當(dāng)一個(gè)對象不被再用到時(shí)，無用內(nèi)存回收器將給它加上標(biāo)簽以示刪除。JAVA里無用內(nèi)存回收程序是以線程方式在后臺(tái)運(yùn)行的，利用空閑時(shí)間工作。
5．操作符重載
Java不支持操作符重載。操作符重載被認(rèn)為是c十十的突出特征，在Java中雖然類大體上可以實(shí)現(xiàn)這樣的功能，但操作符重載的方便性仍然丟失了不少。Java語言不支持操作符重載是為了保持Java語言盡可能簡單。
6．預(yù)處理功能
Java不支持預(yù)處理功能。c／c十十在編譯過程中都有一個(gè)預(yù)編澤階段，即眾所周知的預(yù)處理器。預(yù)處理器為開發(fā)人員提供了方便，但增加了編譯的復(fù)雜性。JAVA虛擬機(jī)沒有預(yù)處理器，但它提供的引入語句(import)與c十十預(yù)處理器的功能類似。
7. Java不支持缺省函數(shù)參數(shù)，而c十十支持
在c中，代碼組織在函數(shù)中，函數(shù)可以訪問程序的全局變量。c十十增加了類，提供了類算法，該算法是與類相連的函數(shù)，c十十類方法與Java類方法十分相似，然而，由于c十十仍然支持c，所以不能阻止c十十開發(fā)人員使用函數(shù)，結(jié)果函數(shù)和方法混合使用使得程序比較混亂。
Java沒有函數(shù)，作為一個(gè)比c十十更純的面向?qū)ο蟮恼Z言，Java強(qiáng)迫開發(fā)人員把所有例行程序包括在類中，事實(shí)上，用方法實(shí)現(xiàn)例行程序可激勵(lì)開發(fā)人員更好地組織編碼。
8 字符串
c和c十十不支持字符串變量，在c和c十十程序中使用Null終止符代表字符串的結(jié)束，在Java中字符串是用類對象(string和stringBuffer)來實(shí)現(xiàn)的，這些類對象是Java語言的核心，用類對象實(shí)現(xiàn)字符串有以下幾個(gè)優(yōu)點(diǎn)：
(1)在整個(gè)系統(tǒng)中建立字符串和訪問字符串元素的方法是一致的；
(2)J3陽字符串類是作為Java語言的一部分定義的，而不是作為外加的延伸部分；
(3)Java字符串執(zhí)行運(yùn)行時(shí)檢空，可幫助排除一些運(yùn)行時(shí)發(fā)生的錯(cuò)誤；
(4)可對字符串用“十”進(jìn)行連接操作。
9“goto語句
“可怕”的goto語句是c和c++的“遺物”，它是該語言技術(shù)上的合法部分，引用goto語句引起了程序結(jié)構(gòu)的混亂，不易理解，goto語句子要用于無條件轉(zhuǎn)移子程序和多結(jié)構(gòu)分支技術(shù)。鑒于以廣理由，Java不提供goto語句，它雖然指定goto作為關(guān)鍵字，但不支持它的使用，使程序簡潔易讀。
l0．類型轉(zhuǎn)換
在c和c十十中有時(shí)出現(xiàn)數(shù)據(jù)類型的隱含轉(zhuǎn)換，這就涉及了自動(dòng)強(qiáng)制類型轉(zhuǎn)換問題。例如，在c十十中可將一浮點(diǎn)值賦予整型變量，并去掉其尾數(shù)。Java不支持c十十中的自動(dòng)強(qiáng)制類型轉(zhuǎn)換，如果需要，必須由程序顯式進(jìn)行強(qiáng)制類型轉(zhuǎn)換。
11.異常
JAVA中的異常機(jī)制用于捕獲例外事件，增強(qiáng)系統(tǒng)容錯(cuò)能力
try{／／可能產(chǎn)生例外的代碼
}catch(exceptionType name){
//處理
}
其中exceptionType表示異常類型。而C++則沒有如此方便的機(jī)制。
附:
Java群體每天都在擴(kuò)大，它既包括一些世界最大的ISV，也包括公司CIO、信息技術(shù)人員、系統(tǒng)分析人員、C/S開發(fā)人員、編程人員、多媒體設(shè)計(jì)者、市場行銷人員、教育工作者、經(jīng)理、影視生產(chǎn)者甚至業(yè)余愛好者等廣泛的用戶。從傳統(tǒng)上看，這樣一些人在一起有效地工作是不多見的。當(dāng)我們談到開放系統(tǒng)時(shí)，我們往往是就已發(fā)表的API及規(guī)格，或者源碼的可得性，或者硬件、聯(lián)網(wǎng)及操作系統(tǒng)而言的，沒有一個(gè)人是從人的開放意義上來談的。Java完成了開放系統(tǒng)的閉合鏈。它開發(fā)了人力資源，而反過來又開辟了共同工作的道路。
一談到Java，人們馬上會(huì)想起一種類似于C++的、適用于分布環(huán)境的面向?qū)ο缶幊陶Z言，想到這種語言的簡單、穩(wěn)定、安全、與體系結(jié)構(gòu)無關(guān)、可移植、可解釋、高性能、多線程和動(dòng)態(tài)性等特征。這些都是Java作為一種程序設(shè)計(jì)語言的主要特征。
Java是由Sun公司的一個(gè)技術(shù)小組研制出來的。在實(shí)現(xiàn)Java語言的過程中，Sun小組的技術(shù)人員很快就意識(shí)到:C++無法成為一種完全面向?qū)ο蟮?、網(wǎng)絡(luò)化的開發(fā)語言。C++是通過給原先的C語言增加面向?qū)ο蠊δ芏_發(fā)出來的，因此,它存在著先天不足。這主要體現(xiàn)在C++種類繁多，功能大量冗余，同時(shí)又沒有任何一種C++編譯器能夠支持它的全部功能。鑒于這種情況，Sun公司的技術(shù)人員決定不擴(kuò)充C++，而開發(fā)一種全新的計(jì)算機(jī)語言(Java的前身Oak)。但是，C++已經(jīng)成了大多數(shù)編程人員所熟練掌握的語言，Java的設(shè)計(jì)顯然不能無視這個(gè)現(xiàn)實(shí)。如果Java和C++之間的差別過大，那么程序員們在學(xué)會(huì)這種語言的過程中無疑要花費(fèi)大量的時(shí)間和精力。因此，Java保留了盡可能多的C++風(fēng)格。
Java自誕生起，為網(wǎng)絡(luò)用戶創(chuàng)造了無數(shù)客戶端的小應(yīng)用程序，由于這類應(yīng)用程序效果良好、數(shù)量巨大，以至于許多用戶想到Java編程語言時(shí)，會(huì)在腦海中出現(xiàn)一個(gè)不完全正確的印象-Java是用來編寫小的客戶端程序的。其實(shí)，隨著技術(shù)的進(jìn)步，Java語言正在逐步改變自己執(zhí)行效率較低、無法擔(dān)任企業(yè)關(guān)鍵計(jì)算任務(wù)的形象，不斷向計(jì)算技術(shù)的核心地帶前進(jìn)。今天的Java技術(shù)正沿著網(wǎng)絡(luò)滲入各個(gè)應(yīng)用領(lǐng)域。
企業(yè)計(jì)算：企業(yè)計(jì)算是Java最重要的技術(shù)主題。Sun公司已經(jīng)公布了企業(yè)JavaBean（EJB，Enterprise JavaBean）的規(guī)格，隨后眾多公司開始開發(fā)企業(yè)應(yīng)用領(lǐng)域的Java技術(shù)。IBM公司也已經(jīng)為Windows NT開發(fā)了IBM HPCJ（High Performance Compiler for Java）12.0版，同時(shí)研制了IBM JDK（JavaDevelopment Kit）for Windows NT，Novell公司也在宣布了一個(gè)新的服務(wù)器端的企業(yè)Java平臺(tái)，而Sun公司也在積極地升級(jí)自己的JDK系統(tǒng)，這個(gè)形勢表明，Java正在穩(wěn)步走向企業(yè)高端計(jì)算。對于Java來說，與其它編程語言爭奪企業(yè)計(jì)算主力編程工具的優(yōu)勢在于：其一，Java在進(jìn)行面向?qū)ο蟮木幊坦ぷ鲿r(shí)，比其它的編程語言如C++更加簡單，因此保證了編程的高效率，減少了編程投入；其二，Java虛擬機(jī)技術(shù)所提供的"一次編程，到處使用"的跨平臺(tái)能力非常適合網(wǎng)絡(luò)環(huán)境，這給Java在網(wǎng)絡(luò)服務(wù)器端的發(fā)展提供了便利條件；其三，Java擁有強(qiáng)大的提供商和支持者隊(duì)伍，該隊(duì)伍包括IBM、Oracle、Novell、Sybase和Netscape等公司。
提速運(yùn)行：許多企業(yè)的應(yīng)用開發(fā)人員非常喜愛Java的語言特性，但是在開發(fā)重要系統(tǒng)時(shí)，語言特性和執(zhí)行效率之間的抉擇往往令人傷透腦筋。在關(guān)鍵計(jì)算中，用戶可能并不在乎數(shù)據(jù)如何壓縮或者運(yùn)行的延遲關(guān)系如何設(shè)置，但是對程序的運(yùn)行速度卻非常重視，這使廠商將Java的編譯策略開發(fā)放在了首位?，F(xiàn)在的Java語言，其執(zhí)行方式已經(jīng)不僅僅是解釋執(zhí)行方式了，即時(shí)編譯器（JITC、just-in-time compiler）技術(shù)和原型編譯技術(shù)已經(jīng)被許多廠家采用，包括Sun、IBM、Oracle以及Netscape等公司在內(nèi)的技術(shù)提供商正在利用這些技術(shù)逐步提高Java的執(zhí)行速度，其中IBM公司早已將Java虛擬機(jī)（JVM，JavaVirtual Machine）、操作系統(tǒng)和硬件的特性有機(jī)的結(jié)合在一起，非常有效地提高了Java的執(zhí)行效率。
嵌入計(jì)算：嵌入式Java是一個(gè)潛力巨大的應(yīng)用技術(shù)，該技術(shù)充分發(fā)揮了Java小巧靈活的特點(diǎn)。以HP公司為例，該公司以自己的方式制造編譯工具和Java虛擬機(jī)，其目的是將Java嵌入各種設(shè)備，如打印機(jī)、醫(yī)學(xué)監(jiān)視器和自動(dòng)提款機(jī)等。嵌入設(shè)備依靠一個(gè)實(shí)時(shí)操作系統(tǒng)來處理某一個(gè)實(shí)時(shí)生效的事件，Java被嵌入這些設(shè)備后，通過實(shí)時(shí)擴(kuò)展（real-time extension）開始發(fā)揮作用，使設(shè)備具備了一定的智能性，增強(qiáng)了嵌入設(shè)備的可管理性和可用性，大大提高了設(shè)備的工作效率。各廠商對這一潛力巨大的市場都非常重視，目前該市場缺乏的是一個(gè)標(biāo)準(zhǔn)，如果存在標(biāo)準(zhǔn)的話，相信很快就會(huì)有大量使用嵌入Java技術(shù)的設(shè)備上市。
微軟剛剛發(fā)行的Windows XP放棄了對Java的支持，但Java能夠獨(dú)立運(yùn)行于很多操作平臺(tái)上，其中也包括Linux，并且在某些特性上要比在Windows上發(fā)揮得更好，我們完全有理由拋棄Windows而選擇使用Linux來做Java開發(fā)?，F(xiàn)在，你可以左手拿著Linux，右手拿著Java，然后對面帶微笑手里拿著Windows XP的Bill Gates說："讓你的XP去見鬼吧！"
對于軟件開發(fā)者來講，任何一種編程語言都不可能是完美的。如果希望更好地理解Java語言，最好的方法是把這種語言與其同類型的語言相比較。既然Java類似于C++，把它同C++進(jìn)行一番比較也是順理成章的事情,哪一個(gè)好，哪一個(gè)不好，每個(gè)開發(fā)人員都有各自的看法。我個(gè)人認(rèn)為Java開發(fā)要比C++好一些。當(dāng)然每個(gè)人的看法和喜好是不同的。后面的文章將向大家介紹Java和C++的不同和對其的改進(jìn)。孰強(qiáng)孰弱，大家自然就會(huì)明白了。
我們知道，Java一開始采用C++的語法格式，基本上是為了讓程序設(shè)計(jì)者可以很快地熟悉 Java的語法格式，縮短學(xué)習(xí)Java的時(shí)間，畢竟C和C++仍舊是最多人會(huì)的一種程序語言。但是如果我們仔細(xì)檢查Java程序語言的許多細(xì)節(jié)設(shè)計(jì)，我們可以發(fā)現(xiàn)Java去掉了不少C++的特點(diǎn)，并且加入一些新的特性。這些與C++的差異包括：
1.不再有#define、#include等預(yù)處理程序(Preprocessor)的功能
C++語言很重要的一個(gè)特點(diǎn)就是它的預(yù)處理程序。有些其他程序語言雖然也加入了#include的功能，但是還是欠缺處理宏(Macro)的能力。#define的功能在Java中我們可以用定義常數(shù)(constant)的方式來取代，而#include在Java中是不需要的，因?yàn)樵贘ava中程序在執(zhí)行時(shí)，會(huì)把類型數(shù)據(jù)記錄在對象實(shí)體之中，我們不需要靠一些標(biāo)頭文件(header file)來知道我們使用的對象或數(shù)值是屬于什么數(shù)據(jù)類型。
如果你使用C++語言時(shí)，只使用預(yù)處理程序的#include和#define功能的話，那么你大概不會(huì)覺得Java這樣的設(shè)計(jì)對你產(chǎn)生什么樣的困擾，但是如果你是使用C++語言預(yù)處理程序中宏功能的高手，你可能會(huì)覺得很不方便，進(jìn)而懷疑Java如此設(shè)計(jì)的意義何在。
使用預(yù)處理程序雖然可以很方便地達(dá)到許多功能，但是站在軟件工程的角度上看，對整個(gè)軟件的維護(hù)其實(shí)是很不利的。由于C++語言中預(yù)處理程序的功能太過強(qiáng)大，厲害的程序設(shè)計(jì)高手常會(huì)自行開發(fā)一套只有自己看的懂的宏語言，一旦整個(gè)軟件要交給其他人去維護(hù)，后繼者很難在短時(shí)間內(nèi)了解前一個(gè)人所寫下的宏功能，增加軟件開發(fā)時(shí)團(tuán)隊(duì)工作及日后維護(hù)的困難度。
另外一點(diǎn)則是C++語言的編譯器所看到的程序代碼，其實(shí)和程序設(shè)計(jì)者看到的程序代碼是不同的。程序設(shè)計(jì)者看到的是尚未經(jīng)過預(yù)處理程序處理過的程序代碼，而編譯器看到的則是預(yù)處理程序處理過的程序代碼，一旦交給預(yù)處理程序處理的宏內(nèi)容有誤，編譯器產(chǎn)生的錯(cuò)誤信息將不會(huì)是程序設(shè)計(jì)師所預(yù)料的。而這一點(diǎn)自然也增加了程序在排錯(cuò)時(shí)的困難度。
預(yù)處理程序的存在也造成了閱讀程序的不便。如果你想使用別人已經(jīng)完成的C++語言程序，那么通常你不但要閱讀他所寫下的文件，還必須一并查閱上文件，才能了解其程序的全貌。如果換成是Java程序，只要查看java的程序文件就夠了。
2.不再有structure、union及typedef
事實(shí)上，早在C++中就可以去掉C語言中的structure和union等對復(fù)雜數(shù)據(jù)的自定結(jié)構(gòu)類型，因?yàn)轭?Class)的定義方式可以完全做到這項(xiàng)功能。而typedef也是不必要的，一切都用類就可以了。雖然C++這樣的設(shè)計(jì)是為了和C語言兼容，但是使用多余的語言特點(diǎn)不但不必要，而且容易造成對程序認(rèn)識(shí)的混淆。
3.不再有函數(shù)
在Java程序語言中，去掉了程序向?qū)дZ言中最重要的單元--函數(shù)(Function)。如果我們以對象向?qū)У挠^念來看待函數(shù)，就可以了解函數(shù)在對象向?qū)У母拍钪?，是不必要的。在對象向?qū)У某绦蛴^念里，對象的數(shù)據(jù)才是真正的主體，而處理對象數(shù)據(jù)的方法則必須依附在對象內(nèi)才有意義。因此，去掉函數(shù)并不表示不再有子程序等模組化程 序的概念，相反地，是利用對象中的方法來取代函數(shù)，再一次強(qiáng)化對向?qū)У陌l(fā)展策略。
4.不再有多重繼承(Multiplelnheritance)
在C++中，多重繼承是一項(xiàng)很強(qiáng)的功能，但也是一般人難以掌控的部分。去掉多重繼承雖然降低了Java語言的功能，但是也大幅簡化撰寫程序時(shí)的困難度。雖然移除了多重繼承的功能，但是Java提供了interface的方式，可以達(dá)到部分多重繼承的功用。所謂的interface基本上定義了一個(gè)類的對外溝通的方法原型，以及類內(nèi)部的常 數(shù)，和多重繼承不同之處在于interface并不會(huì)定義類方法的內(nèi)容，以及類中的變量數(shù)據(jù)。
5.不再有Goto
在程序語言的發(fā)展史上，Goto一直是毀譽(yù)參半的一項(xiàng)功能。在很多時(shí)候使用Goto可以大幅減少不必要的程序代碼，但是也由于Goto可以很自由地改變程序的流程，如果冒然地使用，更可能造成程序結(jié)構(gòu)混亂的情況。一般來說，正確使用Goto的例子多出現(xiàn)在循環(huán)內(nèi)部，想要提早結(jié)束某一層循環(huán)。在C語言中，我們可以使用break 或contine來改變某一層循環(huán)的流程， 但如果想要改變兩層以上的環(huán)執(zhí)行流程，不是使用Goto就是以多余的布爾(boolean)變量，配合上一串if-then-else的判斷來達(dá)成。
Java一方面移除了Goto的功能， 而另一方面同時(shí)擴(kuò)大了break和continue的功能，可以允許多層循環(huán)的break或continue。如此一來不但避免了濫用Goto的可能性，同時(shí)也保存下Goto的好處。
6.不再有OperatorOverloading
在C++中，Operator Overloading同樣也是一項(xiàng)值得討論的設(shè)計(jì)。幾乎在所有C++的書中，都會(huì)引用一些例子，告訴你使用OperatorOverloading可以使你的程序看起來更為自然。如下面是一個(gè)程序設(shè)計(jì)師自定義的復(fù)數(shù)類：
//C++中自定義的復(fù)數(shù)類及0pemtor Overloading
class Complex{
public：
Complex(double real,double image){
Real_number=real；
Image_number=image；
}
Complex operator+(Complexrhs){
Return Complex(rhs．real_number+real_number，
rhs．image_number+image_，nulnbef)；
}
private：
doublereal_number //實(shí)部
doublejmage_nunmber； //虛部
}
在這里，如果你使用+來作為復(fù)數(shù)的加法符號(hào)，大家都不會(huì)有疑義，但是如果你使用的是*或》這樣的符號(hào)，那么別人看到你的程序之后，難保不會(huì)產(chǎn)生認(rèn)識(shí)上的錯(cuò)誤。這也是Operator Overloading一大問題，當(dāng)大家都對運(yùn)算符賦予自己的定義后，整個(gè)程序的可讀性就會(huì)大受影響。Operator Overloading的存在并不是必要的，我們一樣可以定義類中的方法來達(dá)到同樣的目的，至于Java去掉這項(xiàng)功能的利弊，恐怕就要讀者自己去評(píng)斷了。
7.取消自動(dòng)類型轉(zhuǎn)換
Java是一個(gè)嚴(yán)格進(jìn)行類型檢查的程序語言，對于下面這樣的程序，在C++的編譯器上編譯時(shí)最多只會(huì)出現(xiàn)警告的信息，但是在Java里則不予通過：
Int aInteger； Double aDouble=2.71828； AInteger = aDouble；
雖然這樣的轉(zhuǎn)型在C++里是合法的，但是也會(huì)造成數(shù)據(jù)精確度的損失。Java為了要確定寫程序的人充分地了解這點(diǎn)，必須要程序設(shè)計(jì)強(qiáng)制轉(zhuǎn)型(type casting)，Java的編譯器才會(huì)接受：
int aInteger；
doublea Double=2.71828；
aInteger=(int)aDouble；
8.不再有指針
取消指針(Pointer)這樣數(shù)據(jù)類型，可能會(huì)讓許多熟悉C++語言的程序設(shè)計(jì)師大吃一驚。在C++語言里，靈活地運(yùn)用指針是許多程序設(shè)計(jì)師的得意之作，但是占整個(gè)除錯(cuò)時(shí)間最久的也是指針的問題。配合上C++對內(nèi)存管理的態(tài)度，程序設(shè)計(jì)師必須要自己去追蹤自己向系統(tǒng)要到的內(nèi)存，最后確實(shí)地交還給系統(tǒng)，并且在使用指針時(shí)，要小心翼翼地注意不要跨過合法的記憶空間，造成Segmentation Fault或General Protection Fault之類的問題。
Java去掉了指針類型，并不表示程序設(shè)計(jì)師在開發(fā)高級(jí)數(shù)據(jù)結(jié)構(gòu)，像堆棧(stack)、 隊(duì)列(queue)、二元樹(binarytree)時(shí)，都必須要像在傳統(tǒng)Basic上，利用大范圍的數(shù)組來自行模擬系統(tǒng)內(nèi)存，自行建構(gòu)類似指針的表示方式。
相反地，Java提供了和Lisp語言中相似的Reference類型，通過Reference去讀取配置到的內(nèi)存內(nèi)容，可以確保不會(huì)去讀取到不屬于自己的內(nèi)存空間，而另一方面，程序的執(zhí)行系統(tǒng)也可以動(dòng)態(tài)地去做內(nèi)存垃圾回收的工作，將沒有被reference參考到的內(nèi)存空間回收給系統(tǒng)使用。
9.和C++連接
不管Java是多么強(qiáng)大，總是有人需要把它和C++連接起來。因?yàn)橹灰幸粋€(gè)新的程序語言或是軟件開發(fā)工具一出現(xiàn)，大家就會(huì)問："它是否具有和原有程序庫連接的能力呢?"也因?yàn)镃++語言在電腦界中占了很重要的地位。大家的問題其實(shí)就等于是直接問"它是否可以和C++連接?"。目前在Java中，的確提供了和C++語言連接的方法，它的做法基本上是先將C++語言所寫的程序建構(gòu)成動(dòng)態(tài)鏈接函數(shù)庫(DynamicLinking Library，DLL)，再由Java程序去調(diào)用DLL里的函數(shù)。
這種連接的方式，使得DLL中的函數(shù)，從Java的眼光看就是一個(gè)"方法"。不過因?yàn)檫@種方法是直接由其他的程序語言所提供，而不是以Java語言所寫的，所以它被稱之為"原生方法"(NativeMethod)。
由于Java Applet一些安全上的限制，所以這種連接外部程序的方法只能用在Java Application內(nèi)。
小結(jié)：
事實(shí)上，constant和typedef這兩條語句包含了#define語句的作用。現(xiàn)在，結(jié)構(gòu)和聯(lián)合已經(jīng)被Java的類所代替。刪除這些特性的原因是:由于其希望維持與C語言的向后兼容性，C ++的語言規(guī)范包含了大量冗余。比如，類實(shí)際上就已經(jīng)包括了結(jié)構(gòu)和聯(lián)合的作用，因此這兩種數(shù)據(jù)結(jié)構(gòu)完全可以取消。關(guān)于#define語句，Java語言規(guī)范的制訂者認(rèn)為:盡管該語句的出發(fā)點(diǎn)是為了增強(qiáng)程序的可讀性，但實(shí)際效果卻恰恰相反，它常常導(dǎo)致難讀的代碼，故應(yīng)該予以取消。Java不再支持獨(dú)立函數(shù)，因此任何函數(shù)都必須封裝到某個(gè)類中。由于人們普遍認(rèn)為， C++所用的超類是非常不穩(wěn)定的，因此Java拋棄了C++中的多繼承并代之以接口。Java的接口指的是，在別的類看來一個(gè)類所能實(shí)現(xiàn)的方法。它所顯示的只是一個(gè)類的方法或常量和變量 ，而不是這個(gè)類的全部結(jié)構(gòu)。
最后，Java還取消了C++中的GOTO語句、操作符重載、自動(dòng)類型轉(zhuǎn)換及指針數(shù)據(jù)類型。 GOTO語句引起的爭議已經(jīng)有很多年了，可一直陰魂不散，這跟某些程序員對該語句一直情有獨(dú)鐘有關(guān)。C++仍然支持?jǐn)?shù)據(jù)類型的自動(dòng)轉(zhuǎn)換，但Java要求編程人員顯式實(shí)現(xiàn)數(shù)據(jù)類型之間的轉(zhuǎn)換。自動(dòng)數(shù)據(jù)類型轉(zhuǎn)換使得兩個(gè)數(shù)據(jù)類型互不兼容的變量可以相互賦值，而不需要給出顯式說明。這有時(shí)會(huì)導(dǎo)致一些問題，其中最常見的是精確度損失。比方說，如果把一個(gè)帶符號(hào)的32位整數(shù)賦給一個(gè)無符號(hào)整數(shù)，則所有的結(jié)果均為正數(shù)。Java的設(shè)計(jì)者們認(rèn)為這很容易引起程序錯(cuò)誤，從而決定不支持這種轉(zhuǎn)換方式。
JAVA的優(yōu)勢是什么？
Java語言是目前的排行第一的語言，其優(yōu)勢也是非常突出的，那么具體體現(xiàn)在哪里吶？
我來給你說一下Java的優(yōu)勢：
1.java的風(fēng)格類似C++但不同于C++,從某種意義上講，java是C++的一個(gè)變種；
2.java摒棄了C、C++中的容易引發(fā)錯(cuò)誤和難以理解的指針，結(jié)構(gòu)，以及內(nèi)存管理等；
3.java提供了豐富的類庫，很方便開發(fā)程序；
4.java是完全面向?qū)ο蟮恼Z言，支持 繼承，重載，多態(tài)等面向?qū)ο蟮奶匦裕?/p>
5.C++是面向?qū)ο蠛兔嫦蜻^程的混合語言， C是純面向過程的語言；
6.java是一種強(qiáng)類型的語言，比C/C++檢查還要嚴(yán)格，java區(qū)分大小寫字母；
7.java提供了自動(dòng)垃圾回收機(jī)制gc，有效避免了C、C++的內(nèi)存泄漏問題；
8.java禁止非法訪問內(nèi)存，因?yàn)閖ava沒有指針，內(nèi)存的申請和釋放；
9.跨平臺(tái)，java的源代碼編譯成結(jié)構(gòu)中立的中間格式，這種格式與機(jī)器無關(guān)，只要在安裝有JVM（java虛擬機(jī)）的電腦上，都能運(yùn)行這種與機(jī)器無關(guān)的中間文件；java一次編譯，到處運(yùn)行；
10.對于不同的操作系統(tǒng)，會(huì)有不同的java虛擬機(jī)，這也就決定了java的可移植性；
11.java支持多線程，簡單理解，如果是單核CPU，那么會(huì)通過時(shí)間片輪轉(zhuǎn)的方式，多線程執(zhí)行程序，如果是多核CPU，那么就可以理解為，兩個(gè)或多個(gè)線程同時(shí)運(yùn)行。
一、做網(wǎng)站
Java可以用來做網(wǎng)站，很多大型網(wǎng)站都是用Java寫的，比如我們熟悉的B站，所以想學(xué)習(xí)Java的同學(xué)還可以負(fù)責(zé)網(wǎng)站方面的制作，這方面的崗位（網(wǎng)站開發(fā)）也比較多，一直以來都相當(dāng)流行。
二、做安卓軟件
安卓是基于Linux的操作系統(tǒng)，其中源代碼就是Java，市面上所有的安卓手機(jī)都是修改Java運(yùn)行的，對于更多的開發(fā)人員來說，他們更多的時(shí)間是花在開發(fā)APP上面。你隨便打開一個(gè)App應(yīng)用，他們就是用Java語言做的。
三、做游戲
電腦上的大多數(shù)游戲也是用Java來開發(fā)的，最經(jīng)典的就是《我的世界》，還有當(dāng)今世界最具影響力的游戲英雄聯(lián)盟，吃雞也是用Java寫的
四、寫軟件
很多編程語言都是可以來寫軟件的，但Java是現(xiàn)在應(yīng)用最廣泛的，比如：企業(yè)級(jí)應(yīng)用開發(fā)，還有OA、郵箱、物流、醫(yī)療、投票、金融、考試、礦山等信息方面的系統(tǒng)，Java都占有極為重要的地位?，F(xiàn)在國內(nèi)的最熱門的就是手機(jī)應(yīng)用，學(xué)習(xí)Java去做手機(jī)應(yīng)用還是比較吃香的。
說啦這么多那么應(yīng)該如何學(xué)習(xí)Java那？
在這個(gè)里我使用腦圖給大家出一個(gè)，Java的學(xué)習(xí)線路供大家參考：
還有一些資料：
Java在市場中的占有率是非常之高的，希望大都成為優(yōu)秀的程序員！??！
首先,編程風(fēng)格并不同于其他的style，目的并不是形成自己獨(dú)樹一幟的風(fēng)格，而是為了讓你的程序易讀,有利于團(tuán)隊(duì)合作以及別人幫你改錯(cuò)。
風(fēng)格是通用的
C語言和C++語言的編程風(fēng)格 （Java見下）
第一章:縮進(jìn)格式
Tab是8個(gè)字符,于是縮進(jìn)也是8個(gè)字符.有很多怪異的風(fēng)格,他們將縮進(jìn)格式定義為4個(gè)字符(設(shè)置為2個(gè)字符!)的深度,這就象試圖將PI定義為3一樣讓人難以接受.
理由是:縮進(jìn)的大小是為了清楚的定義一個(gè)塊的開始和結(jié)束.特別是當(dāng)你已經(jīng)在計(jì)算機(jī)前面呆了20多個(gè)小時(shí)了以后,你會(huì)發(fā)現(xiàn)一個(gè)大的縮進(jìn)格式使得你對程序的理解更容易.
現(xiàn)在,有一些人說,使用8個(gè)字符的縮進(jìn)使得代碼離右邊很近,在80個(gè)字符寬度的終端屏幕上看程序很難受.回答是,但你的程序有3個(gè)以上的縮進(jìn)的時(shí)候,你就應(yīng)該修改你的程序.
總之,8個(gè)字符的縮進(jìn)使得程序易讀,還有一個(gè)附加的好處,就是它能在你將程序變得嵌套層數(shù)太多的時(shí)候給你警告.這個(gè)時(shí)候,你應(yīng)該修改你的程序.
第二章:大符號(hào)的位置
另外一個(gè)C程序編程風(fēng)格的問題是對大括號(hào)的處理.同縮進(jìn)大小不同,幾乎沒有什么理由去選擇一種而不選擇另外一種風(fēng)格,但有一種推薦的風(fēng)格,它是Kernighan和Ritchie的經(jīng)典的那本書帶來的,它將開始
的大括號(hào)放在一行的最后,而將結(jié)束大括號(hào)放在一行的第一位,如下所示:
if (x is true) { we do y }
然而,還有一種特殊的情況:命名函數(shù):開始的括號(hào)是放在下一行的第一位,如下:
int function(int x) { body of function }
所有非正統(tǒng)的人會(huì)非難這種不一致性,但是,所有思維正常的人明白: (第一) KR是___對___的,(第二)如果KR不對,請參見第一條. (:-))......另外,函數(shù)也是特殊的,不一定非得一致.
需要注意的是結(jié)束的括號(hào)在它所占的那一行是空的,__除了__它跟隨著同一條語句的繼續(xù)符號(hào).如"while"在do-while循環(huán)中,或者"else"在if語句中.如下:
do { body of do-loop } while (condition);
以及
if (x == y) { .. } else if (x y) { ... } else { .... }
理由: KR.
另外,注意到這種大括號(hào)的放置方法減小了空行的數(shù)量,但卻沒有減少可讀性.于是,在屏幕大小受到限制的時(shí)候,你就可以有更多的空行來寫些注釋了.
第三章:命名系統(tǒng)
C是一種簡潔的語言,那么,命名也應(yīng)該是簡潔的.同MODULE-2以及ASCAL語言不同的是,C程序員不使用諸如ThisVariableIsATemporaryCounter之類的命名方式.一個(gè)C語言的程序員會(huì)將之命名為"tmp",這很容易書寫,且并不是那么難以去理解.
然而,當(dāng)混合類型的名字不得不出現(xiàn)的時(shí)候,描述性名字對全局變量來說是必要的了.調(diào)用一個(gè)名為"foo"全局的函數(shù)是很讓人惱火的.全局變量(只有你必須使用的時(shí)候才使用它) ,就象全局函數(shù)一樣,需要描述性的命名方式.假如你有一個(gè)函數(shù)用來計(jì)算活動(dòng)用戶的數(shù)量,你應(yīng)該這樣命名--"count_active_users()"--或另外的相近的形式,你不應(yīng)命名為"cntusr()".
有一種稱為Hungarian命名方式,它將函數(shù)的類型編碼寫入變量名中,這種方式是腦子有毛病的一種表現(xiàn)---編譯器知道這個(gè)類型而且會(huì)去檢查它,而這樣只會(huì)迷惑程序員. --知道為什么Micro$oft為什么會(huì)生產(chǎn)這么多"臭蟲"程序了把!!.
局部變量的命名應(yīng)該短小精悍.假如你有一個(gè)隨機(jī)的整數(shù)循環(huán)計(jì)數(shù)器,它有可能有"i",如果沒有任何可能使得它能被誤解的話,將其寫作"loop_counter"是效率低下的.同樣的,""tmp"可以是任何臨時(shí)數(shù)值的函數(shù)變量.
如果你害怕混淆你的局部變量的名字,還有另外一個(gè)問題,就是稱
function-growth-hormone-imbalancesyndrome.
第四章:函數(shù)
函數(shù)應(yīng)該短小而迷人,而且它只作一件事情.它應(yīng)只覆蓋一到兩個(gè)屏幕(80*24一屏),并且只作一件事情,而且將它做好.(這不就是UNIX的風(fēng)格嗎,譯者注).
一個(gè)函數(shù)的最大長度和函數(shù)的復(fù)雜程度以及縮進(jìn)大小成反比.于是,如果你已經(jīng)寫了簡單但長度較長的的函數(shù),而且你已經(jīng)對不同的情況做了很多很小的事情,寫一個(gè)更長一點(diǎn)的函數(shù)也是無所謂的.
然而,假如你要寫一個(gè)很復(fù)雜的函數(shù),而且你已經(jīng)估計(jì)到假如一般人讀這個(gè)函數(shù),他可能都不知道這個(gè)函數(shù)在說些什么,這個(gè)時(shí)候,使用具有描述性名字的有幫助的函數(shù).
另外一個(gè)需要考慮的是局部變量的數(shù)量.他們不應(yīng)該超過5-10個(gè),否則你有可能會(huì)出錯(cuò).重新考慮這個(gè)函數(shù),將他們分割成更小的函數(shù).人的大腦通?？梢院苋菀椎挠涀?件不同的事情,超過這個(gè)數(shù)量會(huì)引起混亂.你知道你很聰明,但是你可能仍想去明白2周以前的做的事情.
第5章:注釋
注釋是一件很好的事情,但是過多的注釋也是危險(xiǎn)的,不要試圖區(qū)解釋你的代碼是注釋如何如何的好:你應(yīng)該將代碼寫得更好,而不是花費(fèi)大量的時(shí)間去解釋那些糟糕的代碼.
通常情況下,你的注釋是說明你的代碼做些什么,而不是怎么做的.而且,要試圖避免將注釋插在一個(gè)函數(shù)體里:假如這個(gè)函數(shù)確實(shí)很復(fù)雜,你需要在其中有部分的注釋,你應(yīng)該回到第四章看看.你可以寫些簡短的注釋來注明或警告那些你認(rèn)為特別聰明(或極其丑陋)的部分,但是你必須要避免過多.取而代之的是,將注釋寫在函數(shù)前,告訴別人它做些什么事情,和可能為什么要這樣做.
第六章:你已經(jīng)深陷其中了.
不要著急.你有可能已經(jīng)被告之"GUN emacs"會(huì)自動(dòng)的幫你處理C的源代碼格式,而且你已經(jīng)看到它確實(shí)如此,但是,缺省的情況下,它的作用還是不盡如人意(實(shí)際上,他們比隨便敲出來的東西還要難看- ainfinite number of monkeys typing into GNU emacs would never make a good program)
于是,你可以要么不要使用GUN emacs,要么讓它使用sanervalules.使用后者,你需要將如下的語句輸入到你的.emacs文件中.(defun linux-c-mode() "C mode with adjusted defaults for use with the Linux kernel."(interactive) (c-mode) (c-set-style"KR") (setq c-basic-offset8))
這會(huì)定義一個(gè)M-x Linux-c-mode的命令.當(dāng)你hacking一個(gè)模塊的時(shí)候,如何你將-*- linux-c -*-輸入在最開始的兩行,這個(gè)模式會(huì)自動(dòng)起作用.而且,你也許想加入如下
(setq auto-mode-alist (cons '("/usr/src/linux.*/.*.〖ch〗$" . linux-c-mode) auto-mode-alist))
到你的.emacs文件中,這樣的話,當(dāng)你在/usr/src/linux下編輯文件的時(shí)候,它會(huì)自動(dòng)切換到linux-c-mode .
但是,假如你還不能讓emaces去自動(dòng)處理文件的格式,不要緊張,你還有一樣?xùn)|西: "縮進(jìn)" .
GNU的縮進(jìn)格式也很死板,這就是你為什么需要加上幾行命令選項(xiàng).然而,這還不算太壞,因?yàn)镚NU縮進(jìn)格式的創(chuàng)造者也記得KR的權(quán)威, (GNU沒有罪,他們僅僅是在這件事情上錯(cuò)誤的引導(dǎo)了人們) ,你要做的就只有輸入選項(xiàng)"-kr -i8"(表示"KR,縮進(jìn)8個(gè)字符).
"縮進(jìn)"有很多功能,特別是當(dāng)它建議你重新格式你的代碼的時(shí)候,你應(yīng)該看看幫助.但要記住: "縮進(jìn)"不是風(fēng)格很差的程序的萬靈丹.
JAVA編程風(fēng)格簡析
很久以來都在體會(huì)著JAVA的風(fēng)格，現(xiàn)在做一簡單陳述，希望大家多提寶貴意見。
對于一種好的編程語言，學(xué)習(xí)它的編程風(fēng)格是很重要的。每種語言都有自己的編寫和注釋約定，當(dāng)然所有語言都建立在最基本的約定之上。編程中最重要的并不是讓代碼按自己希望的方式運(yùn)行，而是程序中那種自明的編程風(fēng)格（這對于程序員的益處相信眾多程序員都身有體會(huì)）！但這還不夠，程序還應(yīng)該具有可讀、相對持久和可維護(hù)性?？勺x性非常重要，因?yàn)槟悴幌Ｍ约阂郧暗淖髌吩谥蟮拈喿x中給自己留下障礙，當(dāng)然，更重要的是自己的程序能讓其他程序員讀懂并且修改。
下面我把工作中所理解的java風(fēng)格做一簡單總結(jié)，這是我所理解的好的編程風(fēng)格和應(yīng)用中我們應(yīng)當(dāng)如何使用java編寫自己的代碼的小Guide。這并不完全，希望大家?guī)臀谊懤m(xù)總結(jié)各自的經(jīng)驗(yàn)。
一般性概述
好的編程風(fēng)格固然重要，但是你一定聽說過一些程序員的個(gè)人風(fēng)格。其實(shí)我們完全不必為那些所謂條條框框所累，但是作為原則是我們至少不能打破這些常規(guī)。我們應(yīng)該在保持自己風(fēng)格的同時(shí)盡量的把自己與編程潛原則靠攏。
可讀性很容易達(dá)到，比如，讓自己的代碼縮排排列、名字采用描述性但不要過長（短名應(yīng)僅僅用在非遠(yuǎn)程）、特殊名稱比如pi應(yīng)當(dāng)被定義為final類型。模塊性是編程需要注意的另一重點(diǎn)，把代碼劃分到類里，在類中把功能劃分到方法中，別讓一個(gè)類太大，否則在使用、修改和理解上都會(huì)造成不必要的麻煩，方法也一樣，如果一個(gè)方法長度超過50行，它產(chǎn)生錯(cuò)誤的概率將接近100％，盡量把大方法劃分為小方法，編程中為避免重復(fù)編寫，還應(yīng)盡量調(diào)用JAVA標(biāo)準(zhǔn)類庫。
盡量避免在寫代碼和注釋時(shí)使用不同語言，經(jīng)常見到論壇有朋友詢問諸如在java中調(diào)用c、調(diào)用php、調(diào)用shell之類的問題，其實(shí)在編程中，我們應(yīng)盡量使用一種語言去完成事情。另外就是不必最優(yōu)化自己的代碼，應(yīng)該選擇相對較優(yōu)的算法就可以了。
類、方法和fields
類應(yīng)體現(xiàn)出某種物質(zhì)的基本概念，比如要編程實(shí)現(xiàn)“汽車”的組成，那么所有的汽車都可以用類Car實(shí)現(xiàn)。這個(gè)類應(yīng)當(dāng)包括域描述、屬性描述和car的狀態(tài)（color, number of doors, age等）和由car可完成的操作（getColor, setColor等）。為了提高類的可重用性，不要在類中有過多的描述，當(dāng)然這也會(huì)增加錯(cuò)誤產(chǎn)生的機(jī)會(huì)。
類名首字母大寫，比如Date, String, Hashtable等 ... ...
類如下定義：(未使用Javadoc做注釋):
public class Car {
/* Instance variables are placed either in the beginning
or at the end of the class */
private int age;
private Color color;
/* The constructor should be placed in the beginning */
public Car(int age, Color color) {
this.age = age;
this.color = color;
}
/* Example method */
public int getAge() {
return age;
}
/* The main method is optional, but looks like this.
If it exists, it is either the first or the last
method in the class */
public static void main(String [] args) {
...
}
}
注意類名和大括號(hào)間的空格！
方法
方法一般定義為public。當(dāng)然，如果方法僅僅在當(dāng)前類用到可以定義為private，而如果希望一個(gè)子類沿用這個(gè)方法則不同，這時(shí)候的方法應(yīng)定義為protected。
java中的方法定義很有趣，它們一般小寫字母開頭，如果有兩個(gè)字組成，第二個(gè)字的首字母則大寫。因此名字的描述性是至關(guān)重要的。這使你不用閱讀整篇代碼來判斷這是一個(gè)什么方法。在給自己的方法取名時(shí)應(yīng)盡量不要太短或者太長，另一個(gè)需要注意的是大多方法使用動(dòng)詞（動(dòng)賓短語）。
例如：
public void eat() {}
public void eatBananas() {}
Selector（選擇器）方法有g(shù)et前綴，后綴是它們將要get的，比如
public int getBananas() {}
Mutator（存取器）方法則有set前綴，后綴則是他們要set的，比如
public void setBananas(int amount) {}
注意mutators大多無返回值。
方法的參數(shù)應(yīng)當(dāng)以如下方式給出：
public void aMethod(type parameter1, type parameter2, ... , type parametern) {}
如果參數(shù)過長，也可以斷開為幾行，應(yīng)對齊向下排列如：
public void aMethod(type parameter1, type parameter2,... ,
type parametern, type parameter n+1,... ,
type parameterm, type parameter m+1) {}
另外要注意類的左束括號(hào)應(yīng)在方法的右束括號(hào)之后而非下一行:
public int aMethod() {
int i = 0;
if(i == 0)
System.out.println("success！");
}
為了文件可讀性好，還要注意語句最好寫在同一行，當(dāng)然一行寫不下是可以斷行的，比如行字母超過80。
fields
比如變量，如果不希望它永久有效，應(yīng)設(shè)為private。如果一個(gè)變量在類中不發(fā)生任何動(dòng)作（比如數(shù)據(jù)結(jié)構(gòu)中的node）則可以設(shè)置為public，常量一般聲明為public。如果不能確定一個(gè)變量到底該聲明為什么，應(yīng)暫且聲明為private。
field的名字一般使用小寫字母，不要使用下橫線或其他特殊字符。 如果變量包含兩個(gè)字，那么第二個(gè)字的首字母大寫。比如：
int i, j, k;
Date date;
double myField;
常量一般全部大寫，也可以包含下橫線：
public static final int MAX_SIZE_OF_DATABASE
fields的名字通常為名詞。較重要的fields更應(yīng)具備描述性，比如程序中包含一個(gè)游戲的得分，那可以用score來代表。如果變量變化較頻繁，那使用一個(gè)單一字符來代表就ok了：
i, j, k 通常代表整數(shù)
r, t, u, v, w 通常代表實(shí)數(shù)
x, y, z 通常是并列出現(xiàn)或代表浮點(diǎn)數(shù)
s, s1, s2, 通常代表字符串
c, ch 通常代表字符
f, file 通常代表文件
tmp, temp 通常代表臨時(shí)變量
ctr, cnt, cntr 一般代表計(jì)數(shù)器(如果i, j, k這些變量已被使用)
dummy, foo, bar 一般代表啞元變量
args 是main-method的主參數(shù)名
縮排與換行
每行長度不得超過80字符。如果需要可以折行時(shí)，也應(yīng)當(dāng)與上一行有共同的縮排距離。代碼應(yīng)如何交錯(cuò)、如何建立新行、在哪里建立允許、哪里不允許都有一些一般約定，縮排空格一般為2個(gè)或4個(gè)空格。
條件表達(dá)式
如果見到如下語法表達(dá)式：
if (expr)
statement1;
else
statement2;
代碼行向右錯(cuò)排兩個(gè)空格如上所示。
如果在一個(gè)表達(dá)式中有超過一條的聲明，則需要大括號(hào):
if (expr){
statement1;
statement2;
} else{
statement3;
statement4;
}
有時(shí)我們會(huì)希望在表達(dá)式中使用表達(dá)式（比如條件嵌套），這時(shí)應(yīng)注意else表達(dá)式，它的位置很容易出錯(cuò)！如例：
if (expr1) {
statement1;
statement2;
} else if (expr2)
statement3;
else if (expr3) {
statement4;
statement5;
} else {
statement6;
statement7;
}
注意大括號(hào)位置！
Loops
while-loop語法如下：
while (expr) {
statement1;
statement2;
}
for-loop語法如下：
for (expr1; expr2; expr3){
statement1;
statement2;
}
注意大括號(hào)位置！僅一條聲明時(shí)大括號(hào)省略：
while (expr)
statement;
for (expr1; expr2; expr3)
statement;
例如，我們寫一個(gè)procedure寫出1到10這十個(gè)數(shù)字：
for (i = 1; i = 10; i++)
System.out.println(i);
try-catch語法形如：
try {
statements;
} catch (ExceptionClass e) {
statements;
}
如果try-catch語句后跟隨finally子句則形如：
try {
statements;
} catch (ExceptionClass e) {
statements;
} finally {
statements;
}
新行
每一行最好只闡述一件事情。比如，一行包含一個(gè)聲明、一個(gè)條件語句、一個(gè)循環(huán)等。不論多小，最好不要一行辦兩件事及以上。例如不要把一個(gè)if表達(dá)式或循環(huán)語句的主體放置在同一行，這樣的表達(dá)式斷行的易讀性會(huì)更高。通常，互相協(xié)作的代碼應(yīng)放在一起，為保證代碼美觀可讀，我們應(yīng)將代碼的不同代碼段放置在不同的段落。不過要牢記斷行不要太過分！比如:
public int factorial(int n) {
int result = 1;
for(int i = 1; i = n; i++)
result*=i;
return result;
}
給自己的代碼加入注釋
注釋就是類的描繪、方法存在的原因、它完成了什么以及它對它其中（變量）的作用域。假定閱讀你代碼的人已經(jīng)知道這是什么語言，所以不需要注釋語句功能，盡量使用簡短而有描述力的注釋。
Java有兩種類型的注釋：
//This is a comment that continues until the end of the line.
/* This is a comment. It goes on and on and on and on and on and on and on
and on and on and on and on and on and on and on and on and on and on and
on and on and on and on and on and on and on and on and ends like this: */
/**
* This is a JavaDoc comment. More about JavaDoc in the next section.
*/
如果在注釋中加入注釋則會(huì)出錯(cuò)：
/* You are not allowed to do anything like this /* because the compiler will
complain, if you are lucky */ DON'T DO THIS! And don't write comments in
upper case either... */
注釋應(yīng)放在它要解釋內(nèi)容上下，這樣會(huì)讓代碼更易于理解。
不要注釋一些語言的語句功能：
i++; // Add 1 to i
更不要讓自己的代碼處于這種狀態(tài)：
for(int i = 1; i = n; i++)
/* don't place comments where
they don't belong */
result*=i;
較短的注釋既可被放在被注釋代碼上下，而長注釋則習(xí)慣性的放在代碼之上：
/* Comments can be placed before the
block that is to be commented */
for(int i = 1; i = n; i++)
result*=i;
或者:
for(int i = 1; i = n; i++){
result*=i; // short comments can be placed like this
tmp++; // if necessary, they continue here
}
不要寫沒用的注釋：
i++; // change this later
Excuse me,這句肯定是胡扯！
不要寫自己都看不懂的注釋：
i++; // BMW
BMW? 如果你能連續(xù)十天記住這是什么意思的話，那么你的記憶真是不錯(cuò)了。所以不要寫沒人能看懂的注釋，ok？
最后重申一下：寫簡短而富于描述性的注釋，把它們放在該放的地方，而不要考驗(yàn)?zāi)阕约旱挠洃浟Γ?/p>
JavaDoc - 文檔工具
JavaDoc不僅是另一種給代碼加注釋的仿佛咱，更是一個(gè)文檔工具。類、方法和一些重要地方需要用JavaDoc來注釋。這并不是說你可以放棄常規(guī)的注釋，這兩者在代碼中應(yīng)該是相輔相成、互相彌補(bǔ)的關(guān)系。
類被注釋如：
/**
* Car represents cars ... A description of the class
* should be place here. Note that the description begins
* on the second line and that there is a space between
* the asterix and the text. Next we will add some fields
* indicating who the authors of the class are and
* other useful information. Notice the newline!
*
* @author Jerry Meng
* @version %I%, %G%
*/
public class Car {
注意JavaDoc結(jié)束和類開始間無空行。
方法被注釋如：
/**
* A description of what the method does...
*
* @param n a description of the parameter
* @return a description of the return value
*/
public int factorial(int n) {
某些不是全部，被JavaDoc注釋區(qū)域如：
/**
* Short description of the variable (one line)
*/
type variable;
什么應(yīng)當(dāng)使用JavaDoc做注釋？如何注釋的恰當(dāng)呢？
可以這樣想，JavaDoc中所作的注釋都可以在類的文檔中看到。所有讀這個(gè)類的文檔的讀者都會(huì)明白這個(gè)類所完成的功能、它包括的方法、如何使用這些方法及方法的返回值。一些作用域，比如public的變量或常量將會(huì)一目了然。任何不了解這個(gè)類內(nèi)部結(jié)構(gòu)的人都可以輕松的調(diào)用它。這便是你用JavaDoc可以輕松提供的信息。而使用一般注釋的地方，一般是給那些可能修改你的類代碼的程序員，它們一般描述了類的內(nèi)部信息和結(jié)構(gòu)。
下面我寫一下car的類來描述一個(gè)編程風(fēng)格好的java類應(yīng)該是怎樣的。當(dāng)然這僅僅是一個(gè)小例子(apart from selector and mutator methods)，僅僅是在考慮JAVA編程風(fēng)格上一個(gè)參考而已。
import java.awt.Color;
/**
* This is a class representing cars. A car has certain features, such
* as color, age, number of doors etc and a car can be repainted,
* the tank can be filled etc.
*
* @author Jerry Meng
* @version %I%, %G%
*/
public class Car {
/**
* The maximum size of the tank in litres.
*/
private static final double TANK_SIZE = 100.0;
/**
* The color of the car.
*/
private Color color;
/**
* The age of the car.
*/
private int age;
/**
* The number of doors of the car.
*/
private int doors;
/**
* The amount of gasoline in the tank.
*/
private double gasoline;
/**
* Class constructor, which constructs a brand new, black car with
* five doors and a full tank.
*/
public Car() {
this(Color.black, 0, 5, TANK_SIZE);
}
/**
* Class constructor specifying the color, age, number of doors
* and litres of gasoline
*
* @param color The color of the car
* @param age The age of the car
* @param doors The number of doors
* @param km Kilometres driven
* @param gasoline The litres of gasoline
*/
public Car(Color color, int age, int doors, double gasoline) {
this.color = color;
this.age = age;
this.doors = doors;
this.gasoline = gasoline;
}
/**
* Returns the color of the car
*/
public Color getColor() {
return color;
}
/**
* Repaints the car (i.e. changes its color)
*/
public void setColor(Color color) {
this.color = color;
}
/**
* Returns the age of the car
*/
public int getAge() {
return age;
}
/**
* Returns the number of doors of the car
*/
public int getDoors() {
return doors;
}
/**
* Returns the amount of gasoline in the tank
*/
public double getGasoline() {
return gasoline;
}
/**
* Fills the tank. The amount of gasoline cannot exceed
* the size of the tank. In that case, the tank will be
* filled to the maximum and the rest will run out in
* the sand.
*
* @param gas The amount of gasoline to put in the tank
*/
public void setGasoline(double gas) {
if(gasoline + gas = TANK_SIZE)
gasoline+=gas;
else
gasoline = TANK_SIZE;
}
}
區(qū)別太多。先列幾條吧。
1. c是面向過程的語言。c++和Java都是面向?qū)ο蟮摹Ｔ赾中沒有類或者對象的概念。
2. java運(yùn)行在虛擬機(jī)上，號(hào)稱與平臺(tái)無關(guān)。也就是你開發(fā)的java程序無論是unix，linux還是windows都可以正常運(yùn)行。但是實(shí)際上這是一個(gè)良好的愿望，實(shí)際跨平臺(tái)時(shí)還會(huì)有各種各樣的問題。c和c++都是直接編譯成可執(zhí)行文件，是否能跨平臺(tái)主要看你用到的編譯器特性是否有多平臺(tái)支持。
3. 因?yàn)閏和c++是直接編譯成可執(zhí)行文件，所以運(yùn)行效率要比java高。至于c和c++哪個(gè)更快，兩種語言的擁躉已經(jīng)吵了很多年。
4. java因?yàn)槭沁\(yùn)行在虛擬機(jī)上，不需要考慮內(nèi)存管理和垃圾回收機(jī)制。也是就你可以聲明一個(gè)對象而不用考慮釋放他，虛擬機(jī)幫你做這事情。而c和c++語言本身沒有多少內(nèi)存管理的概念，寫c和c++程序如果用到指針就一定要考慮內(nèi)存申請和釋放。內(nèi)存泄漏是c和c++最頭疼的問題。
5. 代碼重用：java中有一個(gè)根類object，所有的類都是其子類，通過這種方式將容器和算法分離，實(shí)現(xiàn)一種操作作用于多種對象，提高代碼重用。c++中沒有總根對象，但是c++提供了另一個(gè)更強(qiáng)大的功能“模板”，同樣高效地實(shí)現(xiàn)了一種操作作用于多種對象，提供了高效的代碼重用方法。
6. 數(shù)據(jù)結(jié)構(gòu)：java內(nèi)建了豐富的數(shù)據(jù)結(jié)構(gòu)：列表，集合等等（很久沒用java了，有些記不太清）。而c++則用“模板”同樣提供了各種數(shù)據(jù)結(jié)構(gòu)（容器）。
7. c語言在一些比較低層，和硬件打交道的地方用得比較多。另外很多開源軟件由于unix/linux開發(fā)習(xí)慣也大多采用c來開發(fā)。Java是現(xiàn)在最流行的開發(fā)語言，c++比起java稍稍不那么流行一些，但是功能很強(qiáng)大。如能深入掌握，可以寫出兼顧效率和美觀的優(yōu)秀代碼。
JAVA的技術(shù)特點(diǎn)是什么?
Java由美國SUN公司(被oracle公司收購)發(fā)明于1995年，是目前業(yè)界應(yīng)用最廣泛、使用人數(shù)最多的語言，連續(xù)多年排名世界第一，可以稱之為“計(jì)算機(jī)語言界的英語”。
那么Java這么高的評(píng)價(jià)它的特點(diǎn)有哪些，下面我來為題主解答：
一、跨平臺(tái)/可移植性
這是Java的核心優(yōu)勢。Java在設(shè)計(jì)時(shí)就很注重移植和跨平臺(tái)性。比如：Java的int永遠(yuǎn)都是32位。不像C++可能是16，32，可能是根據(jù)編譯器廠商規(guī)定的變化。這樣的話程序的移植就會(huì)非常麻煩。
Java首先利用文本編輯器編寫 Java源程序，源文件的后綴名為.java；再利用編譯器（javac）將源程序編譯成字節(jié)碼文件，字節(jié)碼文件的后綴名為.class； 最后利用虛擬機(jī)（解釋器，java）解釋執(zhí)行。如下圖所示：
二、安全性
Java適合于網(wǎng)絡(luò)/分布式環(huán)境，為了達(dá)到這個(gè)目標(biāo)，在安全性方面投入了很大的精力，使Java可以很容易構(gòu)建防病毒，防篡改的系統(tǒng)。比如Java取消了強(qiáng)大但又危險(xiǎn)的指針。由于指針可進(jìn)行移動(dòng)運(yùn)算，指針可隨便指向一個(gè)內(nèi)存區(qū)域，而不管這個(gè)區(qū)域是否可用，這樣做是危險(xiǎn)的。
三、面向?qū)ο?/p>
面向?qū)ο笫且环N程序設(shè)計(jì)技術(shù)，非常適合大型軟件的設(shè)計(jì)和開發(fā)。由于C++為了照顧大量C語言使用者而兼容了C，使得自身僅僅成為了帶類的C語言，多少影響了其面向?qū)ο蟮膹氐仔?！Java則是完全的面向?qū)ο笳Z言。
四、簡單性
Java就是C++語法的簡化版，我們也可以將Java稱之為“C++-”。跟我念“C加加減”，指的就是將C++的一些內(nèi)容去掉；比如：頭文件，指針運(yùn)算，結(jié)構(gòu)，聯(lián)合，操作符重載，虛基類等等。同時(shí)，由于語法基于C語言，因此學(xué)習(xí)起來完全不費(fèi)力。
五、高性能
Java最初發(fā)展階段，總是被人詬病“性能低”；客觀上，高級(jí)語言運(yùn)行效率總是低于低級(jí)語言的，這個(gè)無法避免。Java語言本身發(fā)展中通過虛擬機(jī)的優(yōu)化提升了幾十倍運(yùn)行效率。比如，通過JIT(JUST IN TIME)即時(shí)編譯技術(shù)提高運(yùn)行效率。 將一些“熱點(diǎn)”字節(jié)碼編譯成本地機(jī)器碼，并將結(jié)果緩存起來，在需要的時(shí)候重新調(diào)用。這樣的話，使Java程序的執(zhí)行效率大大提高，某些代碼甚至接近C++的效率。
因此，Java低性能的短腿，已經(jīng)被完全解決了。業(yè)界發(fā)展上，我們也看到很多C++應(yīng)用轉(zhuǎn)到Java開發(fā)，很多C++程序員轉(zhuǎn)型為Java程序員。
六、分布式
Java是為Internet的分布式環(huán)境設(shè)計(jì)的，因?yàn)樗軌蛱幚鞹CP/IP協(xié)議。事實(shí)上，通過URL訪問一個(gè)網(wǎng)絡(luò)資源和訪問本地文件是一樣簡單的。Java還支持遠(yuǎn)程方法調(diào)用(RMI,Remote Method Invocation)，使程序能夠通過網(wǎng)絡(luò)調(diào)用方法。
七、多線程
多線程的使用可以帶來更好的交互響應(yīng)和實(shí)時(shí)行為。 Java多線程的簡單性是Java成為主流服務(wù)器端開發(fā)語言的主要原因之一。
八、健壯性
Java是一種健壯的語言，吸收了C/C++ 語言的優(yōu)點(diǎn)，但去掉了其影響程序健壯性的部分（如：指針、內(nèi)存的申請與釋放等）。Java程序不可能造成計(jì)算機(jī)崩潰。即使Java程序也可能有錯(cuò)誤。如果出現(xiàn)某種出乎意料之事，程序也不會(huì)崩潰，而是把該異常拋出，再通過異常處理機(jī)制加以處理。
以上幾種特性你了解到啦嗎？? ? 記得給個(gè)贊！
當(dāng)然這些還沒完，Java除啦這些特性還有一些其他的特點(diǎn)我也來給你講一講??！
1.java的風(fēng)格類似C++,從某種意義上講，java是C++的一個(gè)變種。但是java摒棄了C、C++中的容易引發(fā)錯(cuò)誤和難以理解的指針，結(jié)構(gòu)，以及內(nèi)存管理等；
2.java是一種強(qiáng)類型的語言，比C/C++檢查還要嚴(yán)格，java區(qū)分大小寫字母；
3.java禁止非法訪問內(nèi)存，因?yàn)閖ava沒有指針，內(nèi)存的申請和釋放；
4.對于不同的操作系統(tǒng)，會(huì)有不同的java虛擬機(jī)，這也就決定了java的可移植性；
5.java提供了自動(dòng)垃圾回收機(jī)制gc，有效避免了C、C++的內(nèi)存泄漏問題；
記得給個(gè)贊！
重慶分公司
重慶分公司
