丑数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兼容语言的原因。