如何寫出好的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領域的過程式（procedural）程序員的一個苦惱，因為他們往往最終還是寫出一個過程式程序，并將它們擺放到一個或兩個巨大對象中。注意，除了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, edu 等等）皆應為小寫。（這是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代碼 實現下面圖片所達到的效果。 要代碼 最好簡單點的

//Subject.java

/**

*?科目類

*/

public?class?Subject?{

/**?名稱?*/

private?String?name;

/**?成績?*/

private?int?score;

public?Subject(String?name,int?score){

this.name?=?name;

this.score?=?score;

}

public?String?getName()?{

return?name;

}

public?void?setName(String?name)?{

this.name?=?name;

}

public?int?getScore()?{

return?score;

}

public?void?setScore(int?score)?{

this.score?=?score;

}????

}

import?java.util.List;

//Student.java

/**

*?學生類

*/

public?class?Student{

/**?姓名?*/

private?String?name;

/**?學科?*/

private?ListSubject?subjects;

/**?總分??*/

private?int?totalScore?=?0;

/**?平均分?*/

private?int?avgScore?=?0;

public?Student(String?name,ListSubject?subjects){

this.name?=?name;

this.subjects?=?subjects;

if(subjects?!=?null??subjects.size()??0){

for(Subject?s?:?subjects){

totalScore?+=?s.getScore();

}

avgScore?=?totalScore?/?subjects.size();

}

}

public?String?getName()?{

return?name;

}

public?void?setName(String?name)?{

this.name?=?name;

}

public?ListSubject?getSubjects()?{

return?subjects;

}

public?void?setSubjects(ListSubject?subjects)?{

this.subjects?=?subjects;

}

public?int?getTotalScore()?{

return?totalScore;

}

public?int?getAvgScore()?{

return?avgScore;

}????

}

import?java.util.ArrayList;

import?java.util.Arrays;

import?java.util.Comparator;

import?java.util.List;

import?java.util.Scanner;

//StudentScore.java

/**

*?主測試程序

*/

public?class?StudentScore?{

public?static?void?main(String[]?args)?{

Scanner?scanner?=?new?Scanner(System.in);

System.out.println("請輸入課程數");

int?subjectNum?=?scanner.nextInt();

System.out.println("請輸入人數");

int?stuNum?=?scanner.nextInt();

String[]?subjectNames?=?new?String[subjectNum];

for(int?i?=?0;?i??subjectNum;?i++){

System.out.println("請輸入第"?+?(i?+?1)?+?"門科目名稱");

subjectNames[i]?=?scanner.next();

}

String[]?stuNames?=?new?String[stuNum];

for(int?i?=?0;?i??stuNum;?i++){

System.out.println("請輸入第"?+?(i?+?1)?+?"個學員名稱");

stuNames[i]?=?scanner.next();

}

Student[]?stuArr?=?new?Student[stuNum];

for(int?i?=?0;?i??stuNum;?i++){

ListSubject?subjects?=?new?ArrayListSubject();

for(int?j?=?0;?j??subjectNum;?j++){

System.out.println("輸入"?+?stuNames[i]?+?"的"?+?subjectNames[j]?+?"成績");

int?score?=?scanner.nextInt();

Subject?subject?=?new?Subject(subjectNames[j],?score);

subjects.add(subject);

}

stuArr[i]?=?new?Student(stuNames[i],?subjects);

}

//按照總成績從高到底排序

Arrays.sort(stuArr,?new?ComparatorStudent()?{

@Override

public?int?compare(Student?stu1,?Student?stu2)?{

if(stu1.getTotalScore()??stu2.getTotalScore()){

return?1;

}?else?if(stu1.getTotalScore()??stu2.getTotalScore()){

return?-1;

}?else?{

return?0;

}

}

});

//輸出標題頭

final?String?FORMAT?=?"\t";

System.out.print("姓名"?+?FORMAT);

for(int?i?=?0;i??subjectNum;?i++){

System.out.print(subjectNames[i]?+?FORMAT);

}

System.out.println("總分"?+?FORMAT?+?"平均分"?+?FORMAT?+?"排名");

//按照排名輸出

for(int?i?=?0;?i??stuArr.length;?i++){

System.out.print(stuArr[i].getName()?+?FORMAT);

for(int?j?=?0;?j??subjectNum;?j++){

System.out.print(stuArr[i].getSubjects().get(j).getScore()?+?FORMAT);

}

System.out.println(stuArr[i].getTotalScore()?+?FORMAT?+?stuArr[i].getAvgScore()?+?FORMAT?+?"第"?+?(i?+?1)?+?"名");

}

}

}

java代碼實現，好的話加分

肯定要把修改時間給記錄下來；所以數據庫里面肯定有個對應的修改時間，每次update的時候，更新修改時間，查詢的時候 order by modifyTime desc就ok了，至于表現上，可以使用在定義tr的時候，第一行給一個固定的id，js里面通過document.getElementById("").style=""來讓第一行高亮或者突出顯示，當然最好用jquery的gird控件那就更好弄了

如何用java代碼實現radis存儲

第一步，在windows安裝配置好redis數據庫。這里我就不再概述了。jedis-2.4.2.jar，當然最好是最新版本的jar包。這個在下就出來的。后，放在一個文件夾下面，一會會需要到。

第二步。打開eclipse,新建一個java工程。如下圖所示：

第三步：在Test這個java工程里面，我們新建一個folder，命名lib,把剛才的jedis-2.4.2.jar包放在我們新建的lib的包下面，如下圖所示：

第四步，在eclipse中，選中jar包，build path下。然后我們再Test這個項目里面我們新建一個class，class名字為TestConnect。

第五步，在類里面，我們輸入如下的內容：

// Connecting to Redis server on localhost

//實例化一個客戶端

Jedis jedis = new Jedis("localhost");

//=================================================

// check whether server is running or not

//ping下，看看是否通的

System.out.println("Server is running: " + jedis.ping());

//保存一個

jedis.set("leiTest", "localhost Connection ?sucessfully");

//獲取一個

System.out.println("通過key獲取value： ? ?" + jedis.get("leiTest"));

第六步，對剛才的類進行運行，ctrl+f11快捷鍵運行下，如下圖所示：

第七步，進一步驗證我們是否在redis上是否保存了數據，并且能夠取出來，我們到redis安裝包的目錄，如下圖，打開紅色框內的 redis-cli.exe,打開后，我們進入下面的第二個圖片的界面。

第八步：我們在redis的客戶端的界面 輸入 ?get leiTest ?這個指令。leiTest是剛才在eclipse中我們存入redis數據庫中的一個String類型的鍵。如下圖，證明我們確實成功了，你也試試吧。

急求一段Java代碼可實現窗口抖動功能。最好能詳細點。

實現鼠標點擊的監聽，然后實現類似于下面的代碼：

setLocation(x, y);

Thread.sleep(100);

setLocation(x+20, y);

Thread.sleep(100);

setLocation(x, y+20);

將其放進循環里面循環三五次什么的，坐標的變換根據震動的幅度和范圍進行調整，睡眠時間也根據自己的需要設置就行了。

如果坐標變化需要看起來連續的話，就需要將坐標的位置設置成函數，再利用循環來讓其位置不斷的變換了。

求java代碼，實現每30分鐘循環執行一次一段代碼

可以用Timer來實現

把你寫的代碼添加到一個監聽器中

然后創建Timer對象 設置為30分鐘執行一次 再start()就ok

void?test()

{

Timer?timer=new?Timer(30*60*1000,new?ActionListener(

public?void?actionPerformed()

{

//樓主你的代碼

}

)).start();

}