java代碼編譯成本

❶ java代碼怎麼編譯啊

1.安裝jdk1.5或更高版本，比如說安裝在D盤
2.在系統屬性的環境變數的path變數中加入C:\Program Files\Java\jdk1.6.0_12\bin；
3.在dos中輸入javac，如果有反應就算是配置好了。
4.編譯的格式是：javac 源文件名.java
5.運行格式是：java 源文件名

❷ 如何寫出好的Java代碼

如何寫出好的Java代碼

1． 優雅需要付出代價。
從短期利益來看，對某個問題提出優雅的解決方法，似乎可能花你更多的時間。但當它終於能夠正確執行並可輕易套用於新案例中，不需要花上數以時計，甚至以天計或以月計的辛苦代價時，你會看得到先前所花功夫的回報（即使沒有人可以衡量這一點）。這不僅給你一個可更容易開發和調試的程序，也更易於理解和維護。這正是它在金錢上的價值所在。這一點有賴某種人生經驗才能夠了解，因為當你努力讓某一段程序代碼變得比較優雅時，你並不是處於一種具生產力的狀態下。但是，請抗拒那些催促你趕工的人們，因為那麼做只會減緩你的速度罷了。
2． 先求能動，再求快。
即使你已確定某段程序代碼極為重要，而且是系統的重要瓶頸，這個准則依然成立。盡可能簡化設計，讓系統能夠先正確動作。如果程序的執行不夠快，再量測其效能。幾乎你總是會發現，你所認為的」瓶頸」其實都不是問題所在。把你的時間花在刀口上吧。
3． 記住」各個擊破」的原理。
如果你所探討的問題過於混雜，試著想像該問題的基本動作會是什麼，並假設這一小塊東西能夠神奇地處理掉最難的部分。這」一小塊」東西其實就是對象–請撰寫運用該對象的程序代碼，然後檢視對象，並將其中困難的部分再包裝成其他對象，依此類推。
4． 區分class開發者和class使用者（使用端程序員）。
Class 使用者扮演著」客戶」角色，不需要（也不知道）class的底層運作方式。Class開發者必須是class設計專家，並撰寫class，使它能夠盡可能被大多數新手程序員所用，而且在程序中能夠穩當執行。一套程序庫只有在具備通透性的情況下，使用起來才會容易。
5．當你撰寫class時，試著給予明了易懂的名稱，減少不必要的註解。
你給客戶端程序員的介面，應該保持概念上的單純性。不了這個目的，當函數的重載（overloading）適合製作出直覺、易用的介面時，請善加使用。
6． 也必你的分析和設計必須讓系統中的classes保持最少，須讓其Public interfaces保持最少，以及讓這些classes和其他classes之間的關聯性（ 尤其是base classes）保持最少。
如果你的設計所得結果更甚於此，請問問自己，是否其中每一樣東西在整個程序生命期中都饒富價值？如果並非如此，那麼，維護它們會使你付出代價。開發團隊的成員都有不維護」無益於生產力提升」的任何東西的傾向；這是許多設計方法無法解釋的現象。
7． 讓所有東西盡量自動化。先撰寫測試用的程序代碼（在你撰寫class之前），並讓它和class結合在一起。請使用makefile或類似工具，自動進行測試動作。
通過這種方式，只要執行測試程序，所有的程序變動就可以自動獲得驗證，而且可以立即發現錯誤。由於你知道的測試架構所具備的安全性，所以當你發現新的需求時，你會更勇於進行全面修改。請記住，程序語言最大的改進，是來自型別檢查、異常處理等機制所賦予的內置測試動作。但這些功能只能協助你到達某種程度。開發一個穩固系統時，你得自己驗證自己的classes或程序的性質。
8． 在你撰寫class之前先寫測試碼，以便驗證你的class 是否設計完備。如果你無法撰寫測試碼，你便無法知道你的class 的可能長相。撰寫測試碼通常能夠顯現出額外的特性（features）或限制 ( constraints)__它們並不一定總是能夠在分析和設計過程中出現。測試碼也可做為展示class 用法的示常式序。
9． 所有軟體設計上的問題，都可以通過」引入額外的概念性間接層（conceptual indirection）」加以簡化。這個軟體工程上的基礎法則是抽象化概念的根據，而抽象化概念正是面向對象程序設計的主要性質。
10． 間接層(indirection)應該要有意義（和准則-9致）。
這里所指的意義可以像」將共用程序代碼置於惟一函數」這么簡單。如果你加入的間接層（或抽象化、或封裝等等）不具意義，它可能就和沒有適當的間接層一樣糟糕。
11． 讓class盡可能微小而無法切割（atomic）。
賦予每個class單一而清楚的用途。如果你的classes或你的系統成長得過於復雜，請將復雜的classes切割成比較簡單的幾個classes。最明顯的一個判斷指針就是class的大小：如果它很大，那麼它工作量過多的機會就可能很高，那就應該被切割。重新設計class的建議線索是：
1） 復雜的switch語句：請考慮運用多態（Polymorphism）。
2） 許多函數各自處理類型極為不同的動作：請考慮切割為多個不同的（classes）。

12． 小心冗長的引數列（argument lists）。
冗長的引數列會使函數的調用動作不易撰寫、閱讀、維護。你應該試著將函數搬移到更適當的class中，並盡量以對象為引數。
13． 不要一再重復。
如果某段程序代碼不斷出現於許多derived class函數中，請將該段程序代碼置於某個base class 函數內，然後在derived class函數中調用。這么做不僅可以省下程序代碼空間，也可以讓修改該段程序代碼動作更易於進行。有時候找出此種共通程序代碼還可以為介面增加實用功能。
14． 小心switch語句或成串的if-else 子句。
通常這種情況代表所謂的」type-check coding」。也就是說究竟會執行哪一段程序代碼，乃是依據某種型別信息來做抉擇（最初，確切型別可能不十分明顯）。你通常可以使用繼承和多態來取代此類程序代碼；Polymorphical method （多態函數）的調用會自動執行此類型別檢驗，並提供更可靠更容易的擴充性。
15． 從設計觀點來看，請找出變動的事物，並使它和不變的事物分離。
也就是說，找出系統中可能被你改變的元素，將它們封裝於classes中。你可以在《Thinking in Patterns with Java》（可免費下載於 www. BruceEckel. Com）大量學習到這種觀念。
16． 不要利用subclassing來擴充基礎功能。
如果某個介面元素對class而言極重要，它應該被放在base class 里頭，而不是直到衍生（derivation）時才被加入。如果你在繼承過程中加入了函數，或許你應該重新思考整個設計。
17． 少就是多。
從class 的最小介面開始妨展，盡可能在解決問題的前提下讓它保持既小又單純。不要預先考量你的class被使用的所有可能方式。一旦class被實際運用，你自然會知道你得如何擴充介面。不過，一旦class被使用後，你就無法在不影響客戶程序代碼的情況下縮減其介面。如果你要加入更多函數倒是沒有問題–不會影響既有的客戶程序代碼，它們只需重新編譯即可。但即使新函數取代了舊函數的功能，也請你保留既有介面。如果你得通過」加入更多引數」的方式來擴充既有函數的介面，請你以新引數寫出一個重載化的函數；通過 這種方式就不會影響既有函數的任何客戶了。
18． 大聲念出你的classes,確認它們符合邏輯。
請base class和derived class 之間的關系是」is-a」(是一種)，讓class和成員對象之間的關系是」has-a」(有一個)。
19． 當你猶豫不決於繼承（inheritance）或合成（組合，composition）時，請你問問自己，是否需要向上轉型（upcast）為基礎型別。
如果不需要，請優先選擇合成（也就是是使用成員對象）。這種作法可以消除」過多基礎型別」。如果你採用繼承，使用者會認為他們應該可以向上轉型。
20． 運用數據成員來表示數值的變化，運用經過覆寫的函數（overrided method）來代錶行為的變化 。
也就是說，如果你找到了某個 class, 帶有一些狀態變數，而其函數會依據這些變數值切換不同的行為，那麼你或許就應該重新設計，在subclasses 和覆寫後的函數（overrided methods）中展現行為止的差異。
21． 小心重載（overloading）。
函數不應該依據引數值條件式地選擇執行某一段程序代碼。這種情況下你應該撰寫兩個或更多個重載函數（overloaded methods）
22． 使用異常體系（exception hierarchies）
最好是從Java標准異常體系中衍生特定的classes, 那麼，捕捉異常的人便可以捕捉特定異常，之後才捕捉基本異常。如果你加入新的衍生異常，原有的客戶端程序仍能通過其基礎型別來捕捉它。
23． 有時候簡單的聚合（aggregation）就夠了。
飛機上的」旅客舒適系統」包括數個分離的元素：座椅、空調、視訊設備等等，你會需要在飛機上產生許多這樣的東西。你會將它們聲明為Private成員並開發出一個全新的介面嗎？不會的，在這個例子中，元素也是Public介面的一部分，所以仍然是安全的。當然啦，簡單聚合並不是一個常被運用的解法，但有時候的確是。
24． 試著從客戶程序員和程序維護的角度思考。
你的class應該設計得盡可能容易使用。你應該預先考量可能性有的變動，並針對這些 可能的變動進行設計，使這些變動日後可輕易完成。
25． 小心」巨大對象並發症」。
這往往是剛踏OOP領域的過程式（proceral）程序員的一個苦惱，因為他們往往最終還是寫出一個過程式程序，並將它們擺放到一個或兩個巨大對象中。注意，除了application framework (應用程序框架，譯註：一種很特殊的、大型OO程序庫，幫你架構程序本體)之外，對象代表的是程序中的觀念，而不是程序本身。
26． 如果你得用某種醜陋的方式來達成某個動作，請將醜陋的部分局限在某個class里頭。
27． 如果你得用某種不可移植方式來達成某個動作，請將它抽象化並局限於某個class里頭。這樣一個」額外間接層」能夠防止不可移植的部分擴散到整個程序。這種作法的具體呈現便是Bridge設計模式（design pattern）。
28． 對象不應僅僅只用來持有數據。
對象也應該具有定義明確界限清楚的行為。有時候使用」數據對象」是適當的，但只有在通用形容器不適用時，才適合刻意以數據對象來包裝、傳輸一群數據項。
29． 欲從既有的classes身上產生新的classes時，請以組合(composition)為優先考量。
你應該只在必要時才使用繼承。如果在組合適用之處你卻選擇了繼承，你的設計就滲雜了非必要的復雜性。
30． 運用繼承和函數覆寫機制來展現行為上的差異，運用fields(數據成員)來展現狀態上的差異。
這句話的極端例子，就是繼承出不同的classes表現各種不同的顏色，而不使用」color」field.
31． 當心變異性（variance）。
語意相異的兩個對象擁有相同的動作（或說責任）是可能的。OO世界中存在著一種天生的引誘，讓人想要從某個class繼承出另一個subclass,為的是獲得繼承帶來的福利。這便是所謂」變異性」。但是，沒有任何正當理由足以讓我們強迫製造出某個其實並不存在的superclass/subclass關系。比較好的解決方式是寫出一個共用的base class,它為兩個derived classes製作出共用介面–這種方式會耗用更多空間，但你可以如你所盼望地從繼承機制獲得好處，而且或許能夠在設計上獲得重大發現。
32． 注意繼承上的限制。
最清晰易懂的設計是將功能加到繼承得來的class里頭；繼承過程中拿掉舊功能（而非增加新功能）則是一種可疑的設計。不過，規則可以打破。如果你所處理的是舊有的class程序庫，那麼在某個class的subclass限制功能，可能會比重新制定整個結構（俾使新class得以良好地相稱於舊 class）有效率得多。
33． 使用設計模式（design patterns）來減少」赤裸裸無加掩飾的機能（naked functionality）」。
舉個例子，如果你的class只應該產出惟一一個對象，那麼請不要以加思索毫無設計的手法來完成它，然後撰寫」只該產生一份對象」這樣的註解就拍拍屁股走人。請將它包裝成singleton（譯註：一個有名的設計模式，可譯為」單件」）。如果主程序中有多而混亂的」用以產生對象」的程序代碼，請找出類似 factory method這樣的生成模式（creational patterns），使價錢可用以封裝生成動作減少」赤裸裸無加掩飾的機能」（naked functionality）不僅可以讓你的程序更易理解和維護，也可以阻止出於好意卻帶來意外的維護者。
34． 當心」因分析而導致的癱瘓（analysis paralysis）」。
請記住，你往往必須在獲得所有信息之前讓項目繼續前進。而且理解未知部分的最好也最快的方式，通常就是實際前進一步而不只是紙上談兵。除非找到解決辦法，否則無法知道解決辦法。Java擁有內置的防火牆，請讓它們發揮作用。你在單一class或一組classes中所犯的錯誤，並不會傷害整個系統的完整性。
35． 當你認為你已經獲得一份優秀的分析、設計或實現時，請試著加以演練。
將團隊以外的某些人帶進來-他不必非得是個顧問不可，他可以是公司其他團隊的成員。請那個人以新鮮的姿態審視你們的成果，這樣可以在尚可輕易修改的階段找出問題，其收獲會比因演練而付出的時間和金錢代價來得高。實現 （Implementation）
36. 一般來說，請遵守Sun的程序編寫習慣。
價錢可以在以下網址找到相關文檔：java.sun.com/docs/codeconv/idex.html。本書盡可能遵守這些習慣。眾多Java程序員看到的程序代碼，都有是由這些習慣構成的。如果你固執地停留在過去的編寫風格中，你的（程序代碼）讀者會比較辛苦。不論你決定採用什麼編寫習慣，請在整個程序中保持一致。你可以在home.wtal.de/software-solutions/jindent上找到一個用來重排Java程序的免費工具。
37. 無論使用何種編寫風格，如果你的團隊（或整個公司，那就更好了）能夠加以標准化，那麼的確會帶來顯著效果。這代表每個人都可以在其他人不遵守編寫風格修改其作品，這是個公平的游戲。標准化的價值在於，分析程序代碼時所花的腦力較小，因而可以專心於程序代碼的實質意義。
38. 遵守標準的大小寫規范。
將 class名稱的第一個字母應為大寫。數據成員、函數、對象（references）的第一個字母應為小寫。所有識別名稱的每個字都應該連在一塊兒，所有非首字的第一個字母都應該大寫。例如： ThisIsAClassName thisIsAMethodOrFieldName 如果你在static final 基本型別的定義處指定了常量初始式（constant initializers）,那麼該識別名稱應該全為大寫，代表一個編譯期常量。 Packages是個特例，其名稱皆為小寫，即使非首字的字母亦是如此。域名（org, net, e 等等）皆應為小寫。（這是Java 1.1遷移至Java 2時的一項改變） 。
39、不要自己發明」裝飾用的」Private數據成員名稱。
通常這種的形式是在最前端加上底線和其他字元，匈牙利命名法（Hungarian notation）是其中最差的示範。在這種命名法中，你得加入額外字元來表示數據的型別、用途、位置等等。彷彿你用的是匯編語言（assembly language）而編譯器沒有提供任何協肋似的。這樣的命名方式容易讓人混淆又難以閱讀，也不易推行和維護。就讓classes和packages來進行」名稱上的范
圍制定（name scoping）」吧。
40、當你擬定通用性的class時，請遵守正規形式（canonical form）。
包括equals( )、hashCode( )、clone( ) ( 實現出Cloneable),並實現出Comparable和Serialiable等等。
41、對於那些」取得或改變Private數據值」的函數，請使用Java Beans 的」get」、」set」、」is」等命名習慣，即使你當時不認為自己正在撰寫Java Bean。這么做不僅可以輕易以Bean的運用方式來運用你的class,也是對此類函數的一種標准命名方式，使讀者更易於理解。
42、對於你所擬定的每一個class，請考慮為它加入static public test( )，其中含有class功能測試碼。
你不需要移除該測試就可將程序納入項目。而且如果有所變動，你可以輕易重新執行測試。這段程序代碼也可以做為class的使用示例。
43、有時候你需要通過繼承，才得以訪問base class的protected成員。
這可能會引發對多重基類（multiple base types）的認識需求。如果你不需要向上轉型，你可以先衍生新的class發便執行protected訪問動作，然後在」需要用到上述 protected成員」的所有classes中，將新class聲明為成員對象，而非直接繼承。
44、避免純粹為了效率考量而使用final函數。
只有在程序能動但執行不夠快時，而且效能量測工具（profiler）顯示某個函數的調用動作成為瓶頸時，才使用final函數。
45、如果兩個classes因某種功能性原因而產生了關聯（例如容器containers和迭代器iterators）,那麼請試著讓其中某個class成為另一個class 的內隱類（inner class）。
這不僅強調二者間的關聯，也是通過」將class名稱嵌套置於另一個class 內」而使同一個class 名稱在單一Package中可被重復使用。Java 容器庫在每個容器類中都定義了一個內隱的（inner）Iterator class,因而能夠提供容器一份共通介面。運用內隱類的另一個原因是讓它成為private實現物的一部分。在這里，內隱類會為信息隱藏帶來好處，而不是對上述的class關聯性提供肋益，也不是為了防止命名空間污染問題(namespace pollution)。
46、任何時候你都要注意那些高度耦合（coupling）的 classes.請考慮內隱類（inner classes）為程序擬定和維護帶來的好處。內隱類的使用並不是要去除classes間的耦合，而是要讓耦合關系更明顯也更便利。
47、不要成為」過早最佳化」的犧牲品。
那會讓人神經錯亂。尤其在系統建構初期，先別煩惱究竟要不要撰寫（或避免）原生函數（native methods）、要不要將某些數聲明為final、要不要調校程序代碼效率等等。你的主要問題應該是先證明設計的正確性，除非設計本身需要某種程度的效率。
48、讓范圍（作用域，scope）盡可能愈小愈好，這么一來對象的可視范圍和壽命都將盡可能地小。
這種作法可降低」對象被用於錯誤場所，因而隱藏難以察覺的臭蟲」的機會。假設你有個容器，以及一段走訪該容器的程序片段。如果你復制該段程序代碼，將它用於新的容器身上，你可能會不小心以舊容器的大小做為新容器的走訪上限值。如果舊容器已不在訪問范圍內，那麼編譯期便可找出這樣的錯誤。
49、使用Java 標准程序庫提供的容器。
請熟悉他們的用法。你將因此大幅提升你的生產力。請優先選擇ArrayList來處理序列（sequences），選擇HashSet來處理集合（sets）、選擇HashMap來處理關聯式數組（associative arrays），選擇Linkedlist (而不是Stack) 來處理 shacks和queues。
50、對一個強固的（robust）程序而言，每一個組成都必須強固。
請在你所撰寫的每個class中運用Java 提供的所有強固提升工具：訪問許可權、異常、型別檢驗等等。通過這種方式，你可以在建構系統時安全地移往抽象化的下一個層次。
51、寧可在編譯期發生錯誤，也不要在執行期發生錯誤。
試著在最靠近問題發生點的地方處理問題。請優先在」擲出異常之處」處理問題，並在擁有足夠信息以處理異常的最接近處理函數（handler）中捕捉異常。請進行現階段你能夠對該異常所做的處理；如果你無法解決問題，應該再次擲出異常。
52、當心冗長的函數定義。
函數應該是一種簡短的、」描述並實現class介面中某個可分離部分」的功能單元。過長且復雜的函數不僅難以維護，維護代價也高。或許它嘗試做太多事情了。如果你發現這一類函數，代表它應該被切割成多相函數。這種函數也提醒你或許得撰寫新的class。小型函數同樣能夠在你的class中被重復運用。（有時候函數必須很大才行，但它們應該只做一件事情。）
53、盡可能保持」Private」。
一旦你對外公開了程序庫的概況（method、Class 或field）。你便再也無法移除它們。因為如果移除它們，便會破壞某個現有的程序代碼，使得它們必須重新被編寫或重新設計。如果你只公開必要部分，那麼你便可以改變其他東西而不造成傷害。設計總是會演化，所以這是個十分重要的自由度。通過這種方式，實現碼的更動對derived class 造成的沖擊會降最低。在多線程環境下，私密性格外重要-只有private數據可受保護而不被un-synchronized（未受同步控制）的運用所破壞。
54、大量運用註解，並使用javadoc的」註解文檔語法」來產生程序的說明文檔。
不過註解應該賦予程序代碼真正的意義；如果只是重申程序代碼已經明確表示的內容，那是很煩人的。請注意，通常Java class和其函數的名稱都很長，為的便是降低註解量。
55、避免使用」魔術數字」，也就是那種寫死在程序代碼里頭的數字–如果你想改變它們，它們就會成為你的惡夢，因為你永遠都沒有辦法知道」100″究竟代表」 數組大小」或其他東西。你應該產生具描述性的常量度名稱，並在程序中使用該常量名稱。這使程序更易於理解也更易於維護。
56、撰寫構造函數時，請考慮異常狀態。最好情境下，構造函數不執行任何會擲出異常的動作。
次佳情境下，class 只繼承自（或合成自）強固的（robust）classes，所以如有任何異常被擲出，並不需要清理。其他情況下，你就得在finally子句清理合成後的classes。如果某個構造函數一定會失敗，適當的動作就是擲出異常，使調用者不至於盲目認為對象已被正確產生而繼續執行。
57、如果你的class需要在」客戶程序員用完對象」後進行清理動作，請將清理動作，放到單一而定義明確的函數中。最好令其名稱為cleanup() 以便能夠將用途告訴他人。此外請將boolean旗標放到class中，用以代表對象是否已被清理，使finalize()得以檢驗其死亡條件（請參考第 4章）。
58、finalize() 只可用於對象死亡條件的檢驗（請參考4章），俾有益於調試。
特殊情況下可能需要釋放一些不會被垃圾回收的內存。因為垃圾回收器可能不會被喚起處理你的對象，所以你無法使用finalize()執行必要的清理動作。基於這個原因，你得擬定自己的」清理用」函數。在class finalize()中，請檢查確認對象的確已被清理，並在對象尚未被清理時，擲出衍生自Runtime Exception 的異常。使用這種架構前，請先確認finalize()在你的系統上可正常動作（這可能需要調用System.gc()來確認）。
59、如果某個對象在某個特定范圍（scope）內必須被清理（cleaned up）,而不是被垃圾回收機制收回，請使用以下方法；將對象初始化，成功後立刻進入擁有finally子句的一個try區段內。Finally子句會引發清理動作。
60、當你在繼承過程中覆寫了finalize(),請記得調用super. Finalize()。
但如果你的」直接上一層superclass」是Object，，就不需要這個動作。你應該讓super.finalize() 成為被覆寫（overridden）之finalize()的最後一個動作而不是第一個動作，用以確保base class的組件在你需要它們的時候仍然可用。
61、當你撰寫固定大小的對象容器，請將它們轉換為數組–尤其是從某個函數返回此一容器時。
通過這種方式，你可以獲得數組的」編譯期型別檢驗」的好處，而且數組接收者可能不需要」先將數組中的對象加以轉型」便能加以使用。請注意，容器庫的base class (Java. Util. Collection) 具有兩個toArray()，能夠達到這個目的。
62、在interface(介面)和abstract class(抽象類)之間，優先選擇前者。
如果你知道某些東西即將被設計為一個base class,你的第一選擇應該是讓它成為interface;只有在一定得放進函數或數據成員時，才應該將它改為abstract class. Interface只和」客戶端想進行什麼動作」有關，class則比較把重心放在實現細節上。
63、在構造函數中只做惟一必要動作：將對象設定至適當狀態。
避免調用其他函數（除了final函數），因為這些函數可能會被其他人覆寫因而使你在建構過程中得不可預期的結果（請參考第7章以取得更詳細的信息）。小型而簡單的構造函數比較不可能擲出異常或引發問題。
64、為了避免一個十分令人泄氣的經驗，請確認你的classpath中的每個名稱，都只有一個未被放到packages里頭class。否則編譯器會先找到另一個名稱相同的class，並回報錯誤消息。如果你懷疑你的classpath出了問題，試著從classpath中的每個起點查找同名的.class文件。最好還是將所有classes都放到packages里頭。
65、留意一不小心犯下的重載（overloading）錯誤。
如果你覆寫base class 函數時沒有正確拼寫其名稱，那麼便會增加一個新的函數，而不是覆寫原有的函數。但是情況完全合法，所以你不會從編譯器或執行期系統得到任何錯誤消息–你的程序代碼只是無法正確作用，如此而已。
66、當心過早最佳化。
先讓程序動起來，再讓它快–但只有在你必須（也就是說只有在程序被證明在某段程序代碼上遭遇效能瓶頸）時才這么做。除非你已經使用效能量測工具（profiler）找出瓶頸所在，否則你可能性只是在浪費你的時間。效能調校的」隱藏成本」便是讓你的程序代碼變得更不可讀、更難維持。
67、記住，程序代碼被閱讀的時間多於它被撰寫的時間。
清晰的設計能夠製作出去易懂的程序。註解、細節說明、示例都是無價的。這些東西能夠幫助你和你的後繼者。如果沒有其他信息，那麼Java 線上文檔找出一些有用的信息時，你所遭遇的挫敗應該足以讓你相信這一點。

❸ 誰能簡單闡述下java編譯執行的過程

Java虛擬機(JVM)是可運行Java代碼的假想計算機。只要根據JVM規格描述將解釋器移植到特定的計算機上，就能保證經過編譯的任何Java代碼能夠在該系統上運行。本文首先簡要介紹從Java文件的編譯到最終執行的過程，隨後對JVM規格描述作一說明。

一.Java源文件的編譯、下載、解釋和執行
Java應用程序的開發周期包括編譯、下載、解釋和執行幾個部分。Java編譯程序將Java源程序翻譯為JVM可執行代碼?位元組碼。這一編譯過程同C/C++的編譯有些不同。當C編譯器編譯生成一個對象的代碼時，該代碼是為在某一特定硬體平台運行而產生的。因此，在編譯過程中，編譯程序通過查表將所有對符號的引用轉換為特定的內存偏移量，以保證程序運行。Java編譯器卻不將對變數和方法的引用編譯為數值引用，也不確定程序執行過程中的內存布局，而是將這些符號引用信息保留在位元組碼中，由解釋器在運行過程中創立內存布局，然後再通過查表來確定一個方法所在的地址。這樣就有效的保證了Java的可移植性和安全性。

運行JVM位元組碼的工作是由解釋器來完成的。解釋執行過程分三部進行：代碼的裝入、代碼的校驗和代碼的執行。裝入代碼的工作由"類裝載器"（class loader）完成。類裝載器負責裝入運行一個程序需要的所有代碼，這也包括程序代碼中的類所繼承的類和被其調用的類。當類裝載器裝入一個類時，該類被放在自己的名字空間中。除了通過符號引用自己名字空間以外的類，類之間沒有其他辦法可以影響其他類。在本台計算機上的所有類都在同一地址空間內，而所有從外部引進的類，都有一個自己獨立的名字空間。這使得本地類通過共享相同的名字空間獲得較高的運行效率，同時又保證它們與從外部引進的類不會相互影響。當裝入了運行程序需要的所有類後，解釋器便可確定整個可執行程序的內存布局。解釋器為符號引用同特定的地址空間建立對應關系及查詢表。通過在這一階段確定代碼的內存布局，Java很好地解決了由超類改變而使子類崩潰的問題，同時也防止了代碼對地址的非法訪問。

隨後，被裝入的代碼由位元組碼校驗器進行檢查。校驗器可發現操作數棧溢出，非法數據類型轉化等多種錯誤。通過校驗後，代碼便開始執行了。

Java位元組碼的執行有兩種方式：
1.即時編譯方式：解釋器先將位元組碼編譯成機器碼，然後再執行該機器碼。
2.解釋執行方式：解釋器通過每次解釋並執行一小段代碼來完成Java位元組碼程 序的所有操作。
通常採用的是第二種方法。由於JVM規格描述具有足夠的靈活性，這使得將位元組碼翻譯為機器代碼的工作

具有較高的效率。對於那些對運行速度要求較高的應用程序，解釋器可將Java位元組碼即時編譯為機器碼，從而很好地保證了Java代碼的可移植性和高性能。

二.JVM規格描述
JVM的設計目標是提供一個基於抽象規格描述的計算機模型，為解釋程序開發人員提很好的靈活性，同時也確保Java代碼可在符合該規范的任何系統上運行。JVM對其實現的某些方面給出了具體的定義，特別是對Java可執行代碼，即位元組碼(Bytecode)的格式給出了明確的規格。這一規格包括操作碼和操作數的語法和數值、標識符的數值表示方式、以及Java類文件中的Java對象、常量緩沖池在JVM的存儲映象。這些定義為JVM解釋器開發人員提供了所需的信息和開發環境。Java的設計者希望給開發人員以隨心所欲使用Java的自由。

JVM定義了控制Java代碼解釋執行和具體實現的五種規格，它們是：
JVM指令系統
JVM寄存器
JVM棧結構
JVM碎片回收堆
JVM存儲區

2.1JVM指令系統

JVM指令系統同其他計算機的指令系統極其相似。Java指令也是由 操作碼和操作數兩部分組成。操作碼為8位二進制數，操作數進緊隨在操作碼的後面，其長度根據需要而不同。操作碼用於指定一條指令操作的性質（在這里我們採用匯編符號的形式進行說明），如iload表示從存儲器中裝入一個整數，anewarray表示為一個新數組分配空間，iand表示兩個整數的"與"，ret用於流程式控制制，表示從對某一方法的調用中返回。當長度大於8位時，操作數被分為兩個以上位元組存放。JVM採用了"big endian"的編碼方式來處理這種情況，即高位bits存放在低位元組中。這同 Motorola及其他的RISC CPU採用的編碼方式是一致的，而與Intel採用的"little endian "的編碼方式即低位bits存放在低位位元組的方法不同。

Java指令系統是以Java語言的實現為目的設計的，其中包含了用於調用方法和監視多先程系統的指令。Java的8位操作碼的長度使得JVM最多有256種指令，目前已使用了160多種操作碼。

2.2JVM指令系統

所有的CPU均包含用於保存系統狀態和處理器所需信息的寄存器組。如果虛擬機定義較多的寄存器，便可以從中得到更多的信息而不必對棧或內存進行訪問，這有利於提高運行速度。然而，如果虛擬機中的寄存器比實際CPU的寄存器多，在實現虛擬機時就會佔用處理器大量的時間來用常規存儲器模擬寄存器，這反而會降低虛擬機的效率。針對這種情況，JVM只設置了4個最為常用的寄存器。它們是：
pc程序計數器
optop操作數棧頂指針
frame當前執行環境指針
vars指向當前執行環境中第一個局部變數的指針
所有寄存器均為32位。pc用於記錄程序的執行。optop,frame和vars用於記錄指向Java棧區的指針。

2.3JVM棧結構

作為基於棧結構的計算機，Java棧是JVM存儲信息的主要方法。當JVM得到一個Java位元組碼應用程序後，便為該代碼中一個類的每一個方法創建一個棧框架，以保存該方法的狀態信息。每個棧框架包括以下三類信息：
局部變數
執行環境
操作數棧

局部變數用於存儲一個類的方法中所用到的局部變數。vars寄存器指向該變數表中的第一個局部變數。
執行環境用於保存解釋器對Java位元組碼進行解釋過程中所需的信息。它們是：上次調用的方法、局部變數指針和操作數棧的棧頂和棧底指針。執行環境是一個執行一個方法的控制中心。例如：如果解釋器要執行iadd(整數加法)，首先要從frame寄存器中找到當前執行環境，而後便從執行環境中找到操作數棧，從棧頂彈出兩個整數進行加法運算，最後將結果壓入棧頂。
操作數棧用於存儲運算所需操作數及運算的結果。

2.4JVM碎片回收堆

Java類的實例所需的存儲空間是在堆上分配的。解釋器具體承擔為類實例分配空間的工作。解釋器在為一個實例分配完存儲空間後，便開始記錄對該實例所佔用的內存區域的使用。一旦對象使用完畢，便將其回收到堆中。
在Java語言中，除了new語句外沒有其他方法為一對象申請和釋放內存。對內存進行釋放和回收的工作是由Java運行系統承擔的。這允許Java運行系統的設計者自己決定碎片回收的方法。在SUN公司開發的Java解釋器和Hot Java環境中，碎片回收用後台線程的方式來執行。這不但為運行系統提供了良好的性能，而且使程序設計人員擺脫了自己控制內存使用的風險。

2.5JVM存儲區

JVM有兩類存儲區：常量緩沖池和方法區。常量緩沖池用於存儲類名稱、方法和欄位名稱以及串常量。方法區則用於存儲Java方法的位元組碼。對於這兩種存儲區域具體實現方式在JVM規格中沒有明確規定。這使得Java應用程序的存儲布局必須在運行過程中確定，依賴於具體平台的實現方式。

JVM是為Java位元組碼定義的一種獨立於具體平台的規格描述，是Java平台獨立性的基礎。目前的JVM還存在一些限制和不足，有待於進一步的完善，但無論如何，JVM的思想是成功的。

對比分析：如果把Java原程序想像成我們的C++原程序，Java原程序編譯後生成的位元組碼就相當於C++原程序編譯後的80x86的機器碼（二進製程序文件），JVM虛擬機相當於80x86計算機系統,Java解釋器相當於80x86CPU。在80x86CPU上運行的是機器碼，在Java解釋器上運行的是Java位元組碼。

Java解釋器相當於運行Java位元組碼的「CPU」,但該「CPU」不是通過硬體實現的，而是用軟體實現的。Java解釋器實際上就是特定的平台下的一個應用程序。只要實現了特定平台下的解釋器程序，Java位元組碼就能通過解釋器程序在該平台下運行，這是Java跨平台的根本。當前，並不是在所有的平台下都有相應Java解釋器程序，這也是Java並不能在所有的平台下都能運行的原因，它只能在已實現了Java解釋器程序的平台下運行。

❹ 如何編譯java程序

三種方法：

1.在IDE中，如eclipse中寫的Java程序，在點擊保存後eclipse就會調用javac編譯程序編譯，編譯文件在當前項目的bin目錄下。

2.作為一個獨立的文件且沒有定義Java環境變數，需要在cmd窗口中切換到java bin目錄下執行Javac程序，執行格式為javac 空格 Java源文件；如 javac C：//hello.java;

3.作為一個獨立的文件且定義了Java環境變數，打開cmd窗口，可以在任意目錄輸入javac java源文件，如javac D：//hi.java。

(4)java代碼編譯成本擴展閱讀

Java也是一種高級語言，要讓計算機執行你撰寫的Java程序，也得通過編譯程序的編譯。但是Java編譯程序並不直接將Java源代碼編譯為相依於計算機平台的0、1序列，而是將其編譯為位元組碼。

Java源代碼的擴展名為.java，經過編譯程序編譯之後生成擴展名為.class的位元組碼。

❺ Java代碼的編譯問題

public void init()
{
setFont=getParameter("font");
addMouseListener(new MouseAdapter() //怎麼樣觸發的滑鼠事件
{
/*介面中的方法默認的就是public的訪問許可權，所以下面的兩個放的訪問許可權不夠，應該加上public*/
/*public*/void mousePressed(MouseEvent e)
{
xOrigin=getX();
yOrigin=getY();

}
/*public*/void mouseReleased(MouseEvent e)
{
Graphics g=getGraphics();
g.drawLine(xOrigin,yOrigin,e.getX(),e.getY());
}
});
//setFont=getParameter("font");
System.out.println("init");
}
//實現介面或抽象類中未實現的方法時，應該注意這個許可權問題！！！

❻ java語言的編譯環境和c++有什麼區別，java的特色是什麼

Java不是編譯成本機機器代碼，而是編譯成自己的虛擬機代碼，由虛擬機解釋執行，C++是編譯成本機代碼執行的。
Java是一種跨平台，適合於分布式計算環境的面向對象編程語言。
具體來說，它具有如下特性：
簡單性、面向對象、分布式、解釋型、可靠、安全、平台無關、可移植、高性能、多線程、動態性等。
下面我們將重點介紹Java語言的面向對象、平台無關、分布式、多線程、可靠和安全等特性。
1.面向對象
面向對象其實是現實世界模型的自然延伸。現實世界中任何實體都可以看作是對象。對象之間通過消息相互作用。另外，現實世界中任何實體都可歸屬於某類事物，任何對象都是某一類事物的實例。如果說傳統的過程式編程語言是以過程為中心以演算法為驅動的話，面向對象的編程語言則是以對象為中心以消息為驅動。用公式表示，過程式編程語言為：程序=演算法+數據；面向對象編程語言為：程序=對象+消息。
所有面向對象編程語言都支持三個概念：封裝、多態性和繼承，Java也不例外。現實世界中的對象均有屬性和行為，映射到計算機程序上，屬性則表示對象的數據，行為表示對象的方法（其作用是處理數據或同外界交互）。所謂封裝，就是用一個自主式框架把對象的數據和方法聯在一起形成一個整體。可以說，對象是支持封裝的手段，是封裝的基本單位。Java語言的封裝性較強，因為Java無全程變數，無主函數，在Java中絕大部分成員是對象，只有簡單的數字類型、字元類型和布爾類型除外。而對於這些類型，Java也提供了相應的對象類型以便與其他對象交互操作。
多態性就是多種表現形式，具體來說，可以用「一個對外介面，多個內在實現方法」表示。舉一個例子，計算機中的堆棧可以存儲各種格式的數據，包括整型，浮點或字元。不管存儲的是何種數據，堆棧的演算法實現是一樣的。針對不同的數據類型，編程人員不必手工選擇，只需使用統一介面名，系統可自動選擇。運算符重載（operatoroverload)一直被認為是一種優秀的多態機制體現，但由於考慮到它會使程序變得難以理解，所以Java最後還是把它取消了。
繼承是指一個對象直接使用另一對象的屬性和方法。事實上，我們遇到的很多實體都有繼承的含義。例如，若把汽車看成一個實體，它可以分成多個子實體，如：卡車、公共汽車等。這些子實體都具有汽車的特性，因此，汽車是它們的「父親」，而這些子實體則是汽車的「孩子」。Java提供給用戶一系列類（class），Java的類有層次結構，子類可以繼承父類的屬性和方法。與另外一些面向對象編程語言不同，Java只支持單一繼承。
2�平台無關性
Java是平台無關的語言是指用Java寫的應用程序不用修改就可在不同的軟硬體平台上運行。平台無關有兩種：源代碼級和目標代碼級。C和C++具有一定程度的源代碼級平台無關，表明用C或C++寫的應用程序不用修改只需重新編譯就可以在不同平台上運行。
Java主要靠Java虛擬機（JVM）在目標碼級實現平台無關性。JVM是一種抽象機器，它附著在具體操作系統之上，本身具有一套虛機器指令，並有自己的棧、寄存器組等。但JVM通常是在軟體上而不是在硬體上實現。（目前，SUN系統公司已經設計實現了Java晶元，主要使用在網路計算機NC上。
另外，Java晶元的出現也會使Java更容易嵌入到家用電器中。）JVM是Java平台無關的基礎，在JVM上，有一個Java解釋器用來解釋Java編譯器編譯後的程序。Java編程人員在編寫完軟體後，通過Java編譯器將Java源程序編譯為JVM的位元組代碼。任何一台機器只要配備了Java解釋器，就可以運行這個程序，而不管這種位元組碼是在何種平台上生成的。另外，Java採用的是基於IEEE標準的數據類型。通過JVM保證數據類型的一致性，也確保了Java的平台無關性。
Java的平台無關性具有深遠意義。首先，它使得編程人員所夢寐以求的事情（開發一次軟體在任意平台上運行）變成事實，這將大大加快和促進軟體產品的開發。其次Java的平台無關性正好迎合了「網路計算機」思想。如果大量常用的應用軟體（如字處理軟體等）都用Java重新編寫，並且放在某個Internet伺服器上，那麼具有NC的用戶將不需要佔用大量空間安裝軟體，他們只需要一個
Java解釋器，每當需要使用某種應用軟體時，下載該軟體的位元組代碼即可，運行結果也可以發回伺服器。目前，已有數家公司開始使用這種新型的計算模式構築自己的企業信息系統。
3�分布式
分布式包括數據分布和操作分布。數據分布是指數據可以分散在網路的不同主機上，操作分布是指把一個計算分散在不同主機上處理。
Java支持WWW客戶機/伺服器計算模式，因此，它支持這兩種分布性。對於前者，Java提供了一個叫作URL的對象，利用這個對象，你可以打開並訪問具有相同URL地址上的對象，訪問方式與訪問本地文件系統相同。對於後者，Java的applet小程序可以從伺服器下載到客戶端，即部分計算在客戶端進行，提高系統執行效率。
Java提供了一整套網路類庫，開發人員可以利用類庫進行網路程序設計，方便得實現Java的分布式特性。
4�可靠性和安全性
Java最初設計目的是應用於電子類消費產品，因此要求較高的可靠性。Java雖然源於C++，但它消除了許多C++不可靠因素，可以防止許多編程錯誤。首先，Java是強類型的語言，要求顯式的方法聲明，這保證了編譯器可以發現方法調用錯誤，保證程序更加可靠；其次，Java不支持指針，這杜絕了內存的非法訪問；第三，Java的自動單元收集防止了內存丟失等動態內存分配導致的問題；第四，Java解釋器運行時實施檢查，可以發現數組和字元串訪問的越界，最後，Java提供了異常處理機制，程序員可以把一組錯誤代碼放在一個地方，這樣可以簡化錯誤處理任務便於恢復。
由於Java主要用於網路應用程序開發，因此對安全性有較高的要求。如果沒有安全保證，用戶從網路下載程序執行就非常危險。Java通過自己的安全機制防止了病毒程序的產生和下載程序對本地系統的威脅破壞。當Java位元組碼進入解釋器時，首先必須經過位元組碼校驗器的檢查，然後，Java解釋器將決定程序中類的內存布局，隨後，類裝載器負責把來自網路的類裝載到單獨的內存區域，避免應用程序之間相互干擾破壞。最後，客戶端用戶還可以限制從網路上裝載的類只能訪問某些文件系統。
上述幾種機制結合起來，使得Java成為安全的編程語言。
5�多線程
線程是操作系統的一種新概念，它又被稱作輕量進程，是比傳統進程更小的可並發執行的單位。
C和C++採用單線程體系結構，而Java卻提供了多線程支持。
Java在兩方面支持多線程。一方面，Java環境本身就是多線程的。若干個系統線程運行負責必要的無用單元回收，系統維護等系統級操作；另一方面，Java語言內置多線程式控制制，可以大大簡化多線程應用程序開發。Java提供了一個類Thread，由它負責啟動運行，終止線程，並可檢查線程狀態。Java的線程還包括一組同步原語。這些原語負責對線程實行並發控制。利用Java的多線程編程介面，開發人員可以方便得寫出支持多線程的應用程序，提高程序執行效率。必須注意地是，Java的多線程支持在一定程度上受運行時支持平台的限制。例如，如果操作系統本身不支持多線程，Java的多線程特性可能就表現不出來。

❼ 為什麼android不將java代碼編譯成本地代碼

1、Java所謂的跨平台主要是指cpu架構（x86\ARM\IBM的cpu等等），而不僅僅是OS。
2、Android手機硬體不標准，編譯成機器碼到一些手機上無法運行。
3、ART是在app安裝時，將app的代碼編譯成本地機器碼，這樣就可以因地制宜地將二進制碼編譯成對應的本地機器碼了，解決了問題2。但也不是在app發布時編譯為本地機器碼的。

❽ JAVA代碼編譯

代碼如下：

abstractclassShape{
	
	publicabstractdoublegetArea();
}

classCircleextendsShape{

	privatedoubleradius;
	
	publicCircle(doubleradius){
		this.radius=radius;
	}

	@Override
	publicdoublegetArea(){
		returnMath.PI*radius*radius;
	}
}

classRectangleextendsShape{
	
	privatedoublewidth;
	
	privatedoubleheight;

	publicRectangle(doublewidth,doubleheight){
		this.width=width;
		this.height=height;
	}

	@Override
	publicdoublegetArea(){
		returnwidth*height;
	}
}

publicclassApp{
	
	publicstaticvoidmain(String[]args){

		Circlec=newCircle(12);
		System.out.println("圓面積："+c.getArea());
		
		Rectanglerect=newRectangle(12,34);
		System.out.println("矩形面積："+rect.getArea());
	}
}

❾ 什麼是Java代碼的編譯與反編譯

java代碼的編譯，就是你寫完代碼，java編譯器把它編譯成java虛擬機認識的代碼，然後再由虛擬機執行它。反編譯就是反過來，當然這不是java虛擬機乾的事兒，是你找反編譯工具乾的事兒，把編譯過的代碼反編譯成人看得懂的源代碼。

❿ 如何用Java代碼編譯Java文件

簡單點的，自己去運行javac編譯
復雜點的，javax.tools.ToolProvider有個getSystemJavaCompiler方法，他可以幫你找，並在內存中編譯