丑數java

❶ java做圖形界面程序，GUI寫出來怎麼那麼丑啊，java做界面...

java做圖形界面程序，GUI寫出來怎麼那麼丑啊，java做界面...
請在珍惜的時候,好好去愛

❷ JAVA的簡單問題.

oper是個你已經定義好的類

oper operandexp=new oper();的意思是：
分兩步
oper operandexp;創建一個oper的引用，名稱為 operandexp
operandexp = new oper(); 讓operandexp指向新創建的oper對象
其中new oper()是創建一個oper對象

❸ java的不同學習階段

Java推薦讀物與源代碼閱讀

1. Java 語言基礎
談到 Java 語言基礎學習的書籍，大家肯定會推薦Bruce Eckel的《Thinking in Java 》，它是一本寫的相當深刻的技術書籍，Java 語言基礎部分基本沒有其它任何一本書可以超越它。該書的作者Bruce Eckel 在網路上被稱為天才的投機者，作者的《Thinking in C++ 》在1995年曾獲 Software Development Jolt Award 最佳書籍大獎，《Thinking in Java 》被評為1999 年Java World「 最愛讀者歡迎圖書 」，並且贏得了編輯首選圖書獎。作者從1986 年至今，已經發表了超過150 篇計算機技術文章，出版了6 本書（其中4本是關於C++ 的），並且在全世界做了數百次演講。他是《Thinking in Java 》、《Thinking in C++ 》、《 C++ Inside & Out 》《Using C++ 》和《Thinking in Patterns 》的作者，同時還是《 Black Belt C++ 》文集的編輯。他的書被讀者稱為「最好的Java 參考書 …… 絕對讓人震驚」 ； 「 購買 Java 參考書最明智的選擇」 ；「我見過的最棒的編程指南 」 。作者的非凡才華，極其跨越語言的能力，使作者被選為Java 發展10年間與Java 關系最密切的10個人物之一。

《Thinking in Java 》講述了Java語言的方方面面，很多Java 語言的老手都評價「這是一本將Java語言講得相當醜陋的書」。該書談及了java 語言的很多細節，每一個方面都是相當深刻的。通過本書你可以看到「醜陋的」java 語言。

網路上關於java 語言講解的視頻很多很多，其中不凡有垃圾。《翁愷 —JAVA 語言 》可能是你學習 java 語言基礎的唯一選擇，該講座基本按照《Thinking in Java 》這本書講解，其中不凡有翁老師的很多有意思的笑話。我很幸運學習就是從此視頻開始的。內容包括30 講，我總共看了3 遍。

不過，對於初學者我不太推薦使用《Thinking in Java 》，我比較推薦 Prentice Hall PTR 的 《Core Java 2 》 國內稱為 《Java 2 核心技術》 ，目前是第七版。網路上大家都可以下載到電子版。 Oreilly 的 《Java in a nutshell 》 也是一個不錯的選擇。讀完以上兩本後，你可以看看翁愷老師的視頻，接著可以研究 《Thinking in Java 》了。

2. Java 數據結構
市面上關於Java數據結構的書本身就很少很少。大致有 APress 的《Java Collections 》 ，Jones 和Bartlett 的《Data Structures in Java 》、《Object-oriented Data Structures Using Java 》以及Prentice Hall 出版的《Data Structures and Algorithms in Java 》 (Dec 19, 2005) 還有一本就是《Data Structures And Algorithms With Object-oriented Design Patterns In Java 》。很幸運我的第一本英文書就是APress 的 《Java Collections 》（ 本書在國內可能根本就沒有中文版――只能下載英文版了），很不錯，講得很有條例、很簡單，是一本完完全全Java Collections API 介紹的書籍，其中不凡有擴展 API 的例子。這是我推薦你學習 java 數據結構的唯一一本好書。其它的Jones 和 Bartlett 的那兩本國內好像有一本中文版，想看你也可以看看。

在學習完API 後，你可以看看java.util 包中對應的類了。不過只有在學習過設計模式後你才有可能完全理解整個Java Collections Framework 。 Java Collections Framework 使用了很多著名的設計模式如：迭代器（ Iterator ）模式、工廠方法模式、裝飾器模式、適配器模式等等。通過研究 java.util 包中數據結構的源代碼，你可以知道臭名昭著的Properties類的設計了，同時可能基本具備設計簡單的數據結構的能力了。

所謂學習無止境，學習完Sun 提供了Java Collections Framework 後，你可以研究Apche 的另一個Java Collections Framework ，很有意思哦。互為補充的兩個Framework 。

在大家學習、研究Java Collections 之前，我提示一下Java Collections 主要包括以下三部分：介面（Interface）、實現（Implemention）和演算法（Algorithm）。

1. 介面主要有 List 、Set 、Queue 和Map 。 List 、Set 和Queue 是Collection 介面的子介面。

2. 實現主要是實現這些介面的具體類。如實現List 介面的ArrayList 、LinkedList 、Stack 和Vector ；實現Set 介面的HashSet 、TreeSet 和 LinkedHashSet ；實現Queue介面的PriorityQueue 、SynchronousQueue等等；實現Map 介面的HashMap 、TreeMap 、Hashtable 、Properties 、WeakHashMap 等等。

3.演算法主要是由Arrays類和Collections類提供的，它是整個Java Collection Framework 演算法的核心。支持各種類型的排序，查找等常用操作。

Java Collections 中包含兩個版本的數據結構，主要是原先的支持同步的數據結構和後來不支持同步的數據結構。

Java Collection Framework 在使用Comparator 和Comparable介面支持排序。同時提供新舊兩個版本的迭代器Iterator 和Enumeraton ，以及它們如何轉換等等。

在java.util 包中的Obserable介面和Observer類是考察者模式的核心。

……

3. Java IO
市面上關於IO的書籍也僅僅只有Oreilly 出版社的兩本，都是Elliotte Rusty Harold 的著作。兩本書的風格基本一致，推薦閱讀是第一版的《 Jvava I/O 》 ，講得比較淺顯，內容相對比較集中，實例也很多。第二版今年5月國外才出版，很有幸我在網路上下載了第二版，講得極其詳細―― 726 頁的大塊頭（我化了兩個星期），這次將NIO和IO和在一起，還包括J2ME 部分的，不過串口、並口通信部分好像類庫支持不夠，自己不能實際操作。

與第一版的《Jvava I/O》一起的Oreilly 還有一本 《Jvava NIO 》 ，也是很不錯的哦。

大家在依次閱讀完《Jvava I/O》以及《Jvava NIO》後，可以研究 java.io 包中的源代碼了。在大家研究源代碼前我給點提示：

Java 的 io 包主要包括：

1. 兩種流：位元組流（byte Stream）和字元流（character stream），這兩種流不存在所謂的誰代替誰、誰比誰高級之說，它們互為補充，只是側重點不同而已。

2. 兩種對稱： 1. 位元組流、字元流的對稱； 2. 輸入、輸出的對稱。

3. 一個橋梁：將位元組流轉變為字元流的InputStreamReader 和OutputStreamWriter 。

其中必須注意：

1. PipedInputStream 和PipedOutputStrem 是兩個比較有趣的類。

2. 支持 Buffered的流是我們經常使用的類。

3. 裝飾器（Decorator)模式在java最著名的應用就是用於io的設計。仔細研究各個Filter流與具體流的關系，多看設計模式的書籍。相信你會有所所獲。

4. 學習好io包，是研究net 包，rmi 包 …… 的基礎哦！

4 . Java 資料庫
資料庫的書籍太多太多了，也是太爛太爛了！這方面的書我基本都研究過，推薦的你就看看 Apress 的《JDBC Recipes A Problem Solution Approach 》 很不錯，國外2005年底才出版（國內好像沒有中文版，不過出了中文版也不一定值得看――國內經常將國外的書翻譯得一塌糊塗、不堪入目）不過我們真的很幸運，網路上有電子版的。值得一看。推薦我看的第一本比較滿意的―― Wiley 出版的 《Java Database Bible》 講得很不錯！Sun 公司自己的關於JDBC API介紹的那一本 《JDBC API Tutorial andRefernece 》 也不錯。我第二本JDBC 的就是研究的這套API 。

不過目前這些書都是一些相對比較浮淺的API 應用的書籍。有機會我會給大家帶來介紹JDBC API 以及JDBC 實現內部細節的書！我盡快努力，同時希望得到大家的支持！

順便給學習 JDBC 的朋友一點提示：

JDBC 的學習和使用主要是這套API ，其使用過程也是極其簡單，下面是使用 JDBC 的一般流程：

1. 載入某個資料庫的驅動（Driver 類），通常使用Class.forName(「驅動的類名「);

2. 連接資料庫――

Connection con = DriverManager.getConnection(url,username,password) ；

3. 得到會話―― Statement stmt = con.createStatement();

4. 執行操作―― Result rs = stmt.executeQuery(「sql 查詢語句」) ；

5. 處理結果――

while(rs.next()){

String col1 = rs.getString(1);

……

}

簡單吧！整個 JDBC 中可以變化的一般是：

1. 可以由 Connection 對象創建Statement 、PreparedStatement 和CallableStatement 創建三種類型的 Statement 。

2. 可以創建多種類型的ResultSet ：支持單向移動和個自由移動；可更新的和不可更新的；支持不同等級的交易的 …..

3. 數據輸入的批處理。

4. 結果集中特殊類型（Blob 、Clob 、Arrary 和Ref 、Struct )列的操作。

5. 這些特殊類型的錄入資料庫。

6. javax.sql 包中特殊結果集（CachedRowSet 、JdbcRowSet 、WebRowSet ）的操作。

7. 其它的就是一個DataSource了，也很簡單！一個J2EE中的被管理對象

簡單吧！相信大家很快就會征服JDBC 。

5. Java 網路編程
網路編程―― 一個神秘的、充滿挑戰的方向。不過在談Java 網路編程之前首先感謝Sun 公司的開發人員，因為它們天才的設想，充滿智慧的架構，使廣大java程序員學習java網路編程變得異常簡單。

Java網路編程方面的書，我推薦 O'Reilly 的 《Java Network Programming》 目前已經第三版了，以前的版本市面上肯定有！網路上早有第三版的電子版，國外2004 年出版，706 頁哦！講得很全，比較深入，太深入的可能由於 Sun 有些東西沒有完全公開，所以也就不好講了，有興趣的可以下載看看！第二本還是 O'Reilly 1998 年出版的 《Java distributed computing 》 基礎部分寫得比較詳細，後面的實例還是值得研究的。

在大家閱讀這些書之前，給大家一點提示：

java網路編程其實相對比較簡單，入門也很快很快。java 網路編程主要包括兩個部分：1.Socket ；2.URL 部分。不過第二部分也完全建立在第一部分的基礎上。

1. Socket 包括客戶端的Socket 和伺服器端的ServerSocket 。還有就是DatagramSocket 和DatagramPacket ，它對應於UDP 通信協議。 總之， Socket 部分是建立其它高級協議的基礎。

2. URL 類是一個網路資源定位器，通常和具體的網路協議如 HTTP ，FTP ，Telnet…… 相關。通過該類可以連接網路上的資源，通過其openStream 可以以io包中的流（InputStream ）的形式讀取網路資源；通過其OpenConnection 方法，可以打開一個連接，在此連接上可以不僅可以完成讀的操作，還可以完成寫的操作。

Java的網路編程大體包括以上兩部分。網路編程和IO以及多線程部分非常密切，在學習此部分前大家一定對這兩部分了解比較透徹。

學習了以上部分你可以研究java.net 包中的與此相關的源代碼了！研究所有的源代碼還為時尚早。在整個net 包中包含： ContentHandlerFactory 、URLStreamHandlerFactory 、URLStreamHandler 、URLClassLoader 等輔助類，它們構成了 java.net 網路編程的框架，通過研究其源代碼，你不僅可以快速理解java.net 包，還可以為以後擴展該包打下基礎，甚至可以將此思維方式運用到自己的項目中。

到此為止你對java.net 包應該才了解60％，還有一部分你可以使用JDecompiler 之類的反編譯軟體打開你JDK 安裝目錄下 \jdkxxx\jre\lib 目錄中的 rt.jar ，用WinRAR 之類的軟體打開它的sun.net 包，反編譯所有的文件，它是URL類工作的細節。當研究完該sun.net 包，你就會對整個網路編程很熟悉很熟悉了。

一切看起來我們已經對網路編程很精通了。其實不然，剛剛開始而已，要想深入，請繼續吧！網路上很多優秀的網路編程庫甚至軟體可以為我們「添加功力」。如 Apache 的 HttpCore 和 HTTPConnection 是兩個和 HTTP 協議相關庫； JGroups 是研究分布式通信、群組通信的必讀庫；接著我們可以研究 P2P 的軟體包，如 Sun 公司的 JXTA ，它可能是 java 平台點對點通信未來的標准哦！接著你可以研究成熟得不得了，使用極其廣泛得 P2P 軟體 Azureus ！ www.sourceforge.net 可以下載到！

千里之行始於足下！ Just do it ！（目前我也只研究了 net 包，其它的會在不久的將來繼續深入。 Sun 公司因為某些原因沒有公開 net 的其它實現細節，在其允許將其源代碼以文字的形式加以研究，以及允許將其沒有公開的實現寫入書中時，我很希望能出一本 java 網路編程的書籍，以飧廣大讀者！！）

6. Servlet 和JSP
Servlet 、JSP 的書也是滿地都是！值得推薦的也僅僅兩三本。實推Addison Wiley 的 《Servlets and JavaServer pages ：The J2EE Technology Web Tier 》 又是一本很厚的哦！國外 2003 年出版、784 頁，講得比較全，例子也很多，特別是第八章Filter ，舉了幾個不錯的例子。其它所有我看到的關於Servlet 和 JSP的書都沒有如此深入的！（可能有我沒有看到而已）。O』reilly 的 《Java Servlet Programming 》 和《 Java Server Pages 》 相對比較好懂一些，可以讀讀！

在大家學習 Servlet 和 Jsp 之前我還是要提醒一下：

本質上說Servlet 就是一個實現Servlet 介面的、部署於伺服器端的伺服器端的程序罷了！它可以象寫其它任何 java 應用程序一樣編寫，它可以操作資料庫、可以操作本地文件、可以連接本地 EJB…… 編寫 Servlet 程序的一般流程為：

1. 繼承一個 HttpServlet 類；

2. 覆蓋其 doGet 、doPost 方法；

3. 在覆蓋方法的內部操作方法參數 HttpServletRequest 和 HttpServletResponse 。

4. 讀取請求利用HttpServletRequest 。利用HttpServletRequest 你可以操作Http 協議的協議頭、可以得到請求的操作方法、可以得到請求的路徑、可以得到請求的字元串、以及和請求客戶相關的信息，更主要的你可以得到Cookie 和 HttpSession 這兩個對象。

5. 利用Cookie 你可以操作「甜心」對象或者將其寫入HttpServletResponse 中。

6. 向客戶輸出信息可以使用HttpServletResponse 。使用HttpServletResponse 可以寫入各種類型的協議頭、可以增加 Cookie 、可以重定向其它 URL 、可以向客戶發送 Http 協議的狀態碼。

7. 利用 HttpSession 在會話內完成你想實現的任何功能。

同時Servlet 還提供了一些事件和事件監聽器（簡單的觀察者模式而已）。還有就是過濾器（Filter ）和包裝器（ ServletRequestWrapper 、 ServletResponseWrapper ）――簡單的流的使用和裝飾器模式的使用。

學習 Sevlet 、JSP 必然要部署到伺服器中，記住通常文件部署的步驟和參數的設置以及在程序中如何使用就可以了。

完全理解 Servlet後，學習jsp相對比較容易了！Jsp 完全建立在Servlet的基礎上，它是為了迎合那些喜歡在Html 文檔中嵌入腳本（如：PHP 之類的網頁編程語言）的程序員的需要罷了！學起來也相當的容易！

一切看起來似乎那麼的風平浪靜，簡單好學！簡單的表象背後有其復雜的機理。要想對Servlet和Jsp徹底研究，你得研究 Tomcat等開源軟體的具體實現。它無非就是一個伺服器，在客戶利用網頁通過HTTP協議向伺服器發送請求後，伺服器將此 HTTP 求轉化為相應的HttpServletRequest對象，調用你編寫的Servlet罷了，在你的Servlet中你肯定操作了此 HttpServletRequest了吧，同時操作了HttpServletResponse了吧，伺服器就將此HttpServletResponse按照 HTTP 協議的要求利用HTTP協議發送給你的瀏覽器了！在伺服器端的Jsp網頁在被客戶請求後，Tomcat 會利用編譯軟體，使用 javax.servlet.jsp包中的模板，編譯此jsp文件，編譯後就是一個Servlet！以後的操作和Servlet完全一樣哦！

在Servlet和Jsp的基礎上出現了，所謂的高級技術：JSTL ，Struts…… 無非就是一些標簽和MVC模式的使用。

繼續前進吧！勝利就在前方！！

7. 多線程
一個看起來很神秘，卻很容易上手、很難精通的方向！

我推薦兩本我感覺很好的書籍。首先是我第一本能上手看的這方面的書， Sams 1998 年出版的 《Java Thread Programming 》 寫得暴好，很容易讀懂，我有空還時常看當時的筆記！要知道怎麼好你自己看吧！第二本OReilly三次出版的 《Java Threads》 最新是2004版，國內好像有中文版，推薦你還是看英文版的吧！書中談到了與多線程相關的N個方向，如IO 、Swing 、Collection 等等。

給大家一點提示吧！java 類庫中與多線程相關的類不是很多，主要有：Thread 、ThreadGroup 以及ThreadLocal和 InheritableThreadLocal 四個類和一個Runnable 介面；關鍵字synchronize 、volatile ；以及 Object 對象的wait 、 notify 、notifyAll 方法！

1 Thread 是多線程的核心類，提供了一系列創建和操作多線程的方法。

2 ThreadGroup 是一個管理Thread的工具類。

3 ThreadLocal 和InheritableThreadLocal 為Thread 提供了一個類似保險箱功能的存儲線程對象的類！

4 Runnable 不用說了吧！

5 synchronize 是同步方法和同步塊的核心哦！多個線程調用此方法時，只有一個線程可以使用此方法，其它方法阻塞，從而保證被操作對象內部狀態完整性。某個線程調用帶有synchronize 的方法或塊時會得到該對象的對象鎖，完成塊中的操作後釋放此對象鎖，從而其它對象可以繼續操作。

6 wait 、notify 、notifyAll 提供了有效的等待/ 通知機制。Java語言中每一個對象都有一個休息室，任何線程在其操作的對象的狀態不滿足的情況下，在該對象的休息室中休息，釋放對象鎖；當其它線程操作該對象後，喚醒休息室中的線程，它們再檢查條件，當條件滿足後，執行相應的操作。

多線程大致就這么多基礎的！簡單嗎！這對於一個真正的程序員應該是不夠的，真正對多線程要有所掌握，請您研究 java.util.concurrent 包吧！大師Doug Lea的作品，原先是一個開源的一致性編程的庫，後來被Sun公司並入java類庫。作者的網站上也有另外一個版本的該類庫！值得研究的好東西 !Hibernation 、 OpenJMS 等開源軟體都使用了此包！

8. 設計模式
談到設計模式很多人多會推薦GOF的那本，該書在Amzon上是五星級的推薦書籍。不過對於學習java沒多久的、特別是 java初學者，我很不推薦這本書。主要是該書的例子基本都是C++的，很多細節沒有講述得足夠清楚。

我給大家推薦的第一本是閻宏博士的《Java 與模式》 它是第一本中國人自己寫的關於設計模式的書籍，寫的比較有趣，融合了很多中華民族的文化和觀念，例子、類圖都比較多，且相對簡單！非常不錯的入門書籍―― 又是大塊頭哦！

其次我推薦 Wiley 出版社出版的 《Pattern In Java 》 一套三本，我才看了第一本，好像第二本不怎麼樣，第三本還不錯！

第三本是中文翻譯版的關於多線程模式的（很難得的中文翻譯版）中國鐵道出版社2003年出版的《Java 多線程設計模式》 ，將多線程模式講得非常淺顯，配有大量的圖例，每章都有習題，最後有答案！我研究多線程模式就是由它開始的！

第四本，今年出版的 Head First 系列的《Head First Design Pattern 》 秉承 Head First 系列圖書的優點，大量的類圖、豐富的實例、有趣的註解，值得購買！

其次在J2EE 方向你可以研究閱讀Addison Wesley 2002 年出版的《Patterns of Enterprise Application Architecture 》 ，眾多大腕的作品，講企業消息集成的！Sun 提供的《J2EE PATTERNS SL500 》也很好！晚了推薦那一本Amzon 4 星半的 《 Holub on patterns 》 大師的作品，提供了，很值得研究的例子，不過對上面四本不是很熟悉的讀者，最好不要讀它！可能會讓你比較累！

我學習設計模式經過一段很曲折的路線，前前後後大約看了20 本，閻宏博士的《Java 與模式》我看了4 遍，還排除我第一次基本沒看懂的看！記得研一時老師給我們講了GOF的那本，作為選修課，我和它們計算機系的碩士、博士們一起，到最後一個班40 － 50 個人，不超過3個人明白，我也沒有明白任何一點（基礎差吧――主要我對C++語言一點都不了解），憑我不伏輸的性格，我認為我對java語言理解還可以，我就借了《Java 與模式》，結果還是基本沒看懂。很有幸的是讀研三時，聽過了上交大饒若楠老師關於Java OOP語言的講座，我懂了組合書籍模式等三種設計模式後，對其它模式有了強烈的興趣和要征服它的願望！工作後我買的第一本就是《Java 與模式》，第一遍花了2個月研究了這個1000多頁的大塊頭，後來第三遍15天左右就可以搞定，筆記記了一大本！從此一發不可收拾。

選對書、埋頭研究。相信很快就會入門的！

學習Java語言8個簡單的部分，這只是我們研究Java語言的開始！這些都懂了充其量一個java程序員而已，後面的路很長很長！我們可以繼續研究資料庫實現的源代碼、Servlet 伺服器的源代碼、RMI 、EJB 、JNDI 、面向方面編程、重構、ANT 工具、Eclipse 工具、Spring 工具、JBoss 、JOnAS 、Apache Geronimo 等J2EE 伺服器！研究了這些你可能會成為一個出色的J2EE Architecture！你可以繼續研究剖析器、編譯器、JNODE（ java 寫的操作系統） ……

感謝大家有此耐心，聽我羅羅嗦嗦大半天！感謝大家的閱讀，感謝群里的朋友！這篇文章主要應群里朋友的呼聲――不知道如何選書、不知道從何看起！大半天的功夫完成趕此文章，字句上難免有失誤，同時由於能力有限不凡有錯誤！請閱讀後批評指正！

上面基本是我研究java語言的順序，以上書籍都是我閱讀過的，不存在替任何出版社宣傳的成分！有的方法可能不適合你，假如你能收獲一點，兩點甚至更多，請你不要吝嗇推薦給你的朋友――共同學習！

❹ 2021年Java和Python哪個語言的發展前景更好一些

如果有人跟你說Java比Python好或Python比Java好，奉勸你一句不要相信！用Python並且薪資待遇比較好的人，一定會告訴你Python好。用Java的人也一定會告訴你Java好。
一、Java VS Python 定位不同
Java源自C和C++的技術體系，於1995年推出，定位於給專門的程序員設計大型的復雜分布式應用而設計。
Python是1991年推出（比Java還早）主要面向於系統管理、科研、教育和非程序員群體等。
如果從時間來看，Python比Java早4年出身。在國內由於大數據的盛行、互聯網的快速發展，Python逐漸進入大眾眼中，相關企業開始加大了對Python人才的招聘力度。而Python的火爆直接導致相關人才真正的技術能力並沒有那麼好，但也能拿到高薪！隨後便流傳了「人生苦短，我用Python」。
但當Python進入大眾眼中的同時，Java也並未受到任何影響。薪資待遇及市場需求一直在穩步前進。
二、難易程度不同
1、Python
Python是一種解釋型腳本語言。而提到Python，大部人會想到簡單易學。其在設計上也堅持了清晰劃一的風格，這使得Python成為易讀、易維護的語言。
Python的設計目標之一是讓代碼具備高度的可閱讀性。它設計時盡量使用其它語言經常使用的標點符號和英文單字，讓代碼看起來整潔美觀。它不像其他的靜態語言如C、Pascal那樣需要重復書寫聲明語句，也不像它們的語法那樣經常有特殊情況和意外。
Python開發者有意讓違反了縮進規則的程序不能通過編譯，以此來強製程序員養成良好的編程習慣。並且Python語言利用縮進表示語句塊的開始和退出（Off-side規則），而非使用花括弧或者某種關鍵字。增加縮進表示語句塊的開始，而減少縮進則表示語句塊的退出。縮進成為了語法的一部分。
簡而言之：Python可直接調用別人的代碼介面。
2、Java
Java語言作為靜態面向對象編程語言的代表，極好地實現了面向對象理論，允許程序員以優雅的思維方式進行復雜的編程。
Java看起來設計得很像C++，但是為了使語言小和容易熟悉，設計者們把C++語言中許多可用的特徵去掉了，例如Java不支持go to語句。Java還剔除了C++的操作符過載（overload）和多繼承特徵，並且不使用主文件。因為Java沒有結構，數組和串都是對象，所以不需要指針。Java能夠自動處理對象的引用和間接引用，實現自動的無用單元收集，使用戶不必為存儲管理問題煩惱。
簡而言之：Java的很多處理相對要原生一點，代碼要多一些。
三、Java VS Python 應用領域不同
1、Python
· Web 和 Internet開發
· 科學計算和統計
· 人工智慧
· 教育
· 桌面界面開發
· 軟體開發
· 後端開發
2、Java
· Android應用
· 金融業應用的伺服器程序
· 網站
· 嵌入式領域
· 大數據技術
· 高頻交易的空間
· 科學應用
以上就是整理的Python和Java之間的區別。Python和Java哪個好？主要是結合個人想要發展的領域進行學習。兩個編程語言在市場的地位均不可撼動，但只有喜好才能讓你更容易付出百分之二百的努力！

❺ JAVA的SWING 太難看了怎麼辦

可以修改Swing的外觀，Swing支持Unix、Java和Windows三套外觀。你也可以到網上找找第三方的Swing控制項。如果你還不喜歡可以換成SWT或者你自己做一個渲染器渲染界面。

❻ java怎麼取得農歷的節日

public class Lunar
{
private int year;
private int month;
private int day;
private boolean leap;
final static String chineseNumber[] =
{ "一", "二", "三", "四", "五", "六", "七", "八", "九", "十", "十一", "十二" };
final static String Big_Or_Small[] =
{ "大", "小", "大", "小", "大", "小", "大", "大", "小", "大", "小", "大" };
private String[] LunarHolDayName =
{ "小寒", "大寒", "立春", "雨水", "驚蟄", "春分", "清明", "穀雨", "立夏", "小滿", "芒種", "夏至",
"小暑", "大暑", "立秋", "處暑", "白露", "秋分", "寒露", "霜降", "立冬", "小雪", "大雪",
"冬至" };

static SimpleDateFormat chineseDateFormat = new SimpleDateFormat(
" yyyy年MM月dd日 ");
final static long[] lunarInfo = new long[]
{ 0x04bd8, 0x04ae0, 0x0a570, 0x054d5, 0x0d260, 0x0d950, 0x16554, 0x056a0,
0x09ad0, 0x055d2, 0x04ae0, 0x0a5b6, 0x0a4d0, 0x0d250, 0x1d255,
0x0b540, 0x0d6a0, 0x0ada2, 0x095b0, 0x14977, 0x04970, 0x0a4b0,
0x0b4b5, 0x06a50, 0x06d40, 0x1ab54, 0x02b60, 0x09570, 0x052f2,
0x04970, 0x06566, 0x0d4a0, 0x0ea50, 0x06e95, 0x05ad0, 0x02b60,
0x186e3, 0x092e0, 0x1c8d7, 0x0c950, 0x0d4a0, 0x1d8a6, 0x0b550,
0x056a0, 0x1a5b4, 0x025d0, 0x092d0, 0x0d2b2, 0x0a950, 0x0b557,
0x06ca0, 0x0b550, 0x15355, 0x04da0, 0x0a5d0, 0x14573, 0x052d0,
0x0a9a8, 0x0e950, 0x06aa0, 0x0aea6, 0x0ab50, 0x04b60, 0x0aae4,
0x0a570, 0x05260, 0x0f263, 0x0d950, 0x05b57, 0x056a0, 0x096d0,
0x04dd5, 0x04ad0, 0x0a4d0, 0x0d4d4, 0x0d250, 0x0d558, 0x0b540,
0x0b5a0, 0x195a6, 0x095b0, 0x049b0, 0x0a974, 0x0a4b0, 0x0b27a,
0x06a50, 0x06d40, 0x0af46, 0x0ab60, 0x09570, 0x04af5, 0x04970,
0x064b0, 0x074a3, 0x0ea50, 0x06b58, 0x055c0, 0x0ab60, 0x096d5,
0x092e0, 0x0c960, 0x0d954, 0x0d4a0, 0x0da50, 0x07552, 0x056a0,
0x0abb7, 0x025d0, 0x092d0, 0x0cab5, 0x0a950, 0x0b4a0, 0x0baa4,
0x0ad50, 0x055d9, 0x04ba0, 0x0a5b0, 0x15176, 0x052b0, 0x0a930,
0x07954, 0x06aa0, 0x0ad50, 0x05b52, 0x04b60, 0x0a6e6, 0x0a4e0,
0x0d260, 0x0ea65, 0x0d530, 0x05aa0, 0x076a3, 0x096d0, 0x04bd7,
0x04ad0, 0x0a4d0, 0x1d0b6, 0x0d250, 0x0d520, 0x0dd45, 0x0b5a0,
0x056d0, 0x055b2, 0x049b0, 0x0a577, 0x0a4b0, 0x0aa50, 0x1b255,
0x06d20, 0x0ada0 };

// ====== 傳回農歷 y年的總天數
final private static int yearDays(int y)
{
int i, sum = 348;
for (i = 0x8000; i > 0x8; i >>= 1)
{
if ((lunarInfo[y - 1900] & i) != 0)
sum += 1;
}
return (sum + leapDays(y));
}

// ====== 傳回農歷 y年閏月的天數
final private static int leapDays(int y)
{
if (leapMonth(y) != 0)
{
if ((lunarInfo[y - 1900] & 0x10000) != 0)
return 30;
else
return 29;
}
else
return 0;
}

// ====== 傳回農歷 y年閏哪個月 1-12 , 沒閏傳回 0
final private static int leapMonth(int y)
{
return (int) (lunarInfo[y - 1900] & 0xf);
}

// ====== 傳回農歷 y年m月的總天數
final private static int monthDays(int y, int m)
{
if ((lunarInfo[y - 1900] & (0x10000 >> m)) == 0)
return 29;
else
return 30;
}

// ====== 傳回農歷 y年的生肖
final public String animalsYear()
{
final String[] Animals = new String[]
{ "鼠", "牛", "虎", "兔", "龍", "蛇", "馬", "羊", "猴", "雞", "狗", "豬" };
return Animals[(year - 4) % 12];
}

// ====== 傳入 月日的offset 傳回干支, 0=甲子
final private static String cyclicalm(int num)
{
final String[] Gan = new String[]
{ "甲", "乙", "丙", "丁", "戊", "己", "庚", "辛", "壬", "癸" };
final String[] Zhi = new String[]
{ "子", "丑", "寅", "卯", "辰", "巳", "午", "未", "申", "酉", "戌", "亥" };
return (Gan[num % 10] + Zhi[num % 12]);
}

// ====== 傳入 offset 傳回干支, 0=甲子
final public String cyclical()
{
int num = year - 1900 + 36;
return (cyclicalm(num));
}

/** */
/**
* 傳出y年m月d日對應的農歷. yearCyl3:農歷年與1864的相差數 ? monCyl4:從1900年1月31日以來,閏月數
* dayCyl5:與1900年1月31日相差的天數,再加40 ?
*
* @param cal
* @return
*/
public Lunar(Calendar cal)
{
// cal.add(cal.get(Calendar.DAY_OF_MONTH),1);
@SuppressWarnings(" unused ")
int yearCyl, monCyl, dayCyl;
int leapMonth = 0;
Date baseDate = null;
try
{
baseDate = chineseDateFormat.parse(" 1900年1月31日 ");
}
catch (ParseException e)
{
e.printStackTrace(); // To change body of catch statement use
// Options | File Templates.
}

// 求出和1900年1月31日相差的天數
int offset = (int) ((cal.getTime().getTime() - baseDate.getTime()) / 86400000L);
dayCyl = offset + 40;
monCyl = 14;

// 用offset減去每農歷年的天數
// 計算當天是農歷第幾天
// i最終結果是農歷的年份
// offset是當年的第幾天
int iYear, daysOfYear = 0;
for (iYear = 1900; iYear < 2050 && offset > 0; iYear++)
{
daysOfYear = yearDays(iYear);
offset -= daysOfYear;
monCyl += 12;
}
if (offset < 0)
{
offset += daysOfYear;
iYear--;
monCyl -= 12;
}
// 農歷年份
year = iYear;

yearCyl = iYear - 1864;
leapMonth = leapMonth(iYear); // 閏哪個月,1-12
leap = false;

// 用當年的天數offset,逐個減去每月（農歷）的天數，求出當天是本月的第幾天
int iMonth, daysOfMonth = 0;
for (iMonth = 1; iMonth < 13 && offset > 0; iMonth++)
{
// 閏月
if (leapMonth > 0 && iMonth == (leapMonth + 1) && !leap)
{
--iMonth;
leap = true;
daysOfMonth = leapDays(year);
}
else
daysOfMonth = monthDays(year, iMonth);

offset -= daysOfMonth;
// 解除閏月
if (leap && iMonth == (leapMonth + 1))
leap = false;
if (!leap)
monCyl++;
}
// offset為0時，並且剛才計算的月份是閏月，要校正
if (offset == 0 && leapMonth > 0 && iMonth == leapMonth + 1)
{
if (leap)
{
leap = false;
}
else
{
leap = true;
--iMonth;
--monCyl;
}
}
// offset小於0時，也要校正
if (offset < 0)
{
offset += daysOfMonth;
--iMonth;
--monCyl;
}
month = iMonth;
day = offset + 1;
}

public static String getChinaDayString(int day)
{
String chineseTen[] =
{ "初", "十", "廿", "卅" };
int n = day % 10 == 0 ? 9 : day % 10 - 1;
if (day > 30)
return "";
if (day == 10)
return "初十";
else
return chineseTen[day / 10] + chineseNumber[n];
}

public String toString()
{
return /* cyclical() + "年" + */(leap ? "閏" : "")
+ chineseNumber[month - 1] + "月" + getChinaDayString(day);
}

public String numeric_md()
{// 返回阿拉伯數字的陰歷日期
String temp_day;
String temp_mon;
temp_mon = month < 10 ? "0" + month : "" + month;
temp_day = day < 10 ? "0" + day : "" + day;

return temp_mon + temp_day;
}

public String get_month()
{// 返回陰歷的月份
return chineseNumber[month - 1];
}

public String get_date()
{// 返回陰歷的天
return getChinaDayString(day);
}

public String get_Big_Or_Small()
{// 返回的月份的大或小
return Big_Or_Small[month - 1];
}

}

❼ java 堆棧問題

獻丑了：
1、java中所有變數(包括你上述提及的str引用類型變數)的存放位置都取決於該
變數的聲明位置，而New出的對象則始終被JVM存放在堆中，創建的字串常
量則始終被JVM存放在數據段區常量池中。
2、你對第一個str引用變數存放位置的解釋有一點欠妥的地方，准確的說這個
str的存放位置不一定在棧中，這要看str的聲明位置，如果str是方法參數中
聲明或方法內局部變數聲明則存放位置就是你說的在棧中，但如果在類的成
員變數中聲明則是存放於堆中。「abc」是一個字串常量被存放於常量池中而
該常量返回的引用地址被存放於str變數中，str變數的位置取決於str的聲明
位置。
3、第二種方式String str = new String("abc")；其實上是創建了兩個對象，
與上述相同，字串常量對象被放在常量池中，這個常量「abc」與上面第一個
創建的「abc」是同一個abc，常量池中不能保存相同面值的常量，而New出的
新對象new String("abc")則存放在堆中，這里的「abc」的位置存在於堆
中，與上述常量池中的「abc」不是同一個「abc」，這里一定要注意啊，而
str變數的存放位置與第一個str的存放位置都是取決於該str的聲明位置。
4、解釋引用變數存放位置的原理：對象在創建時將為所有的成員變數分配內存
空間以及為所有的成員方法分配入口地址，因為對象是對屬性及方法的封裝
而對象在創建時被分配到堆中的空間，因此成員變數被分配在堆中，而方法
時在調用時為局部參數或變數臨時分配內存空間，在此，方法在調用時被JVM
線程載入至棧中，於此局部變數及參數的所在位置存在與棧中，這些局部變
量及參數所佔空間是臨時的，一旦方法調用結束其臨時空間將被釋放，所以
內存棧區空間是為變數分配的臨時存貯空間，這個你可以參考馬士兵的堆棧
視屏教程，他講述的很清楚，我可能還沒有他表達得清楚。
5、最後再強調一點：變數不是都放在棧中，這取決於該變數的聲明位置，我的
這種說法你能理解嗎？只有理解了這一點，在出現堆棧問題或緩存遺留問題
時才能根據問題的出發點找到問題的出處。

❽ java開發的缺點有哪些

我認為Java語言的10大問題是：
1、缺少閉包（closure）：我想這個不需要解釋了。函數式編程已經存在幾十年了，但最近幾年，它們獲得了越來越多的關注，最主要的原因，是它可以自然地編寫並行程序。我部分的同意Joshua Bloch強調在Java中引入閉包的問題需要再想一想（BGGA提議的方式真的很糟），至少閉包的缺失，使得在Java中做任何真正的函數式編程都是不可能的。
2、缺少一等函數：這個問題與前一個有些關聯，但我認為它更糟糕。在Java里，要達到類似效果的唯一方式，是使用著名的、醜陋悲慘的單方法匿名內部類，但這看上去的確是一個拙劣的方法。甚至在C#中，也通過代理機制，提供了一個更好的實現。
3、原生類型（Primitive types）：如果在Java中一切皆對象，那是多麼完美啊，但他們偏偏不這樣設計。因而，這一點導致了一些問題，比如，不能把一個int放到集合（Collection）里，這個在Java5中通過自動裝箱特性得到了解決（下面會提到）。它也造成了傳值與傳引用上的困擾，原生類型數據是通過值傳給方法的（復制一份拷貝，然後傳給函數），而真正的對象是通過傳遞（譯註：其實是復制對象地址再傳遞，因此應該也是傳值方式，只是由於函數內部可通過這個對象地址訪問對象，因此效果上類似傳引用）。
4、自動裝箱（Autoboxing）和自動拆箱（autounboxing）：這個特性是為了解決因原生類型的存在所導致的問題，在Java5引入的。它允許靜默地轉換原生類型到相應的對象，但這常常導致其它的問題。比如Integer可以為null，但int不能，因此這時JVM只能拋出一個難以調試的空指針異常（NullPointerException）。此外，它還可能導致其它奇怪的行為，就像下面的例子，我們就很難理解，變數test為什麼是false：
Intger a = new Integer(1024);
Intger b = new Integer(1024);
boolean test = a < b || a == b || a > b;
5、缺少范型具類化：范型是Java5引入的一個很酷的特徵，但是為了保持與舊版本Java的兼容性，導致缺失某些重要的特性，尤其是不能在運行時反省范型的類型。例如，你有一個方法，接受List參數，如果傳進來一個List，你卻不能知道運行里該范型的確切類型。同理，你也不能創建范型數組。這意味著，盡管下面的代碼看起來很自然，但卻不編譯不了：
List[] listsOfStrings = new List[3];
6、不可避免的范型警告：你有發現過自己陷入不可能去掉的關於范型的警告么？如果你像我一樣大量使用范型，我打賭你碰到過。事實上，是這個問題的規模化症狀，讓他們認為需要引入一個特定的註解(@SuppressWarnings("unchecked"))來處理這種情況，我覺得，范型應該可能被設計的更好。
7、不能傳void給方法調用：我得承認，這種給方法傳遞void的需求，乍一看有些怪異。我喜歡DSL，當我實現自己的DSL庫（lambdaj）的一個特定特性時，我不得不需要一個方法聲明成這樣的簽名：void doSomething(Object parameter)，這里為這個方法傳進來的參數parameter，是另一個方法調用的結果，它唯一的目的，是注冊調用（的對象）自身，以可以在以後執行它。讓我吃驚的是，即使println方法返回void，看上去也並沒有一個好理由，不允許我把代碼寫成這樣，：
doSomething(System.out.println("test"));
8、沒有原生的代理機制：代理是一種非常有效和應用廣泛的模式，但Java提供的代理機制，只針對介面，而不是具體類。這是為什麼象cblib這樣提供這種機制的庫，被如此多的主流框架，如Spring和Hibernate，採用的原因。此外，由於cglib通過運行時創建被代理類的子類來實現的，因此這些種方式有一個眾所周知的限制——不能代理final類，比如String。
9、差勁的Switch...case語句：Java規定，switch...case只能選擇int和enum（Java5開始）。這一點如果跟更現代的語言如Scala相比，看起來簡直太弱了。
10、受檢查異常（Checked exception）：類似原生類型，受檢查異常也已經成為Java的一個罪孽之源。它迫使程序員必須做下面兩件極其糟糕討厭的事情中的一個：讓你的代碼里充斥大量的、糟糕難讀的、容易出錯的try...catch語句，而這樣做的最大意義，只是將捕獲的異常，包裝成運行時異常，然後再重新拋出；或者是讓大量的拋出聲明子句污染你的API，讓介面缺少靈活性和可擴展性。
真正的問題是，這里我提到的這幾大主要問題，唯一的解決辦法，是要做一個痛苦的決擇，定義一套新的語言規范，放下當前版本的向後兼容性。我猜他們永遠也不會這么做，雖然我相信，如果編寫一個能夠自動轉換舊Java源碼的程序，讓它們與假設的新版本兼容，並不是很困難。最後，這就是我決定開始尋找一個更好的JVM兼容語言的原因。