"臭名昭著的Java”

以下是从链接“C/C++与Java的较量”中全文复制过来的，是论坛帖子，非我原创。

不知道为什么还要发明Java这种语言。
不就比C++多了几个库，多了几个专职开发Open source源代码的开发商。
classpath是个臭名昭著的问题，一不小心就出问题。
界面是出奇难用，倒退到DOS命令行去了。
速度奇慢，可以出去抽根烟，再回来看结果。
没有一个好的开发环境，虽然开发环境倒是一大堆，可是不是速度慢，就是bug多。
最好的开发环境竟然是ultra_edit，天，最好退回到notepad.exe。
要编程序？动不动带一堆库，安装就要老半天：
开发网页：Tomcat+Velocity+Torque+Ant+......好像还没说JDBC呢。
开发GUI？哼，好像不大可能哎。根本就相当于手工编程。
不是有JBuilder吗？我CALL，我用JBuilder建个程序看看，一堆怪异的代码在那儿，吓死我。用Eclipse?，昏SWT只不过是个Baby，永远也不要忘掉dispose。
如果你是给人家开发库，那么库从底层到顶层都永远要带个释放资源的dispose，别以为Java会管你其他的资源，它除了内存，什么都不管......
文本格式化？老老实实的自己编写。
语法解析？我CALL，你和C++去比比哪个方便。一个字符串都要转换为char[] 数组才行的东西。
功能强大的流化？打字都要打半天,new ( new ......(new.....))。和C++的iostream去比比。
我用Java，我都烦死了。整个一个倒退到史前时代。整个一个手工编程的典范。

还有，不要告诉我Eclipse、JBuilder是用Java写的，
你以为你是谁，会去编写一整个底层的库再来做项目。

要找出一个开发语言的缺点一点也不难.
看赖楼主推崇c++的,不知道你的缓冲区溢出是怎么解决的?
新建一个对象的时候,是不是要告诉系统:"我的孩子需要一个空间,请给我".
也许在你不在需要这个对象的时候会告诉系统:"这个空间我的孩子已经用完了,可以还给你了".但是你有没有把你的孩子忘记的时候呢?不要告诉我你没有过.c++最强有力的东西就是指针.但是你有没有碰到过"该内存只读"之类的"友好"提示呢?也不要告诉我你没有遇到过.

不会用就不要用，又没有人B你！
Java根本就不是用来做你想象当中的那些东西的。

呵呵，楼主基本上点中了java的几个死穴，虽然其中有几点略失偏颇；
楼上的说的也是C++的一个最大的缺憾。
但，它们目前还是各有各的用武之地的。就象自然界的各物种，各有各的存在的道理。

你没类的封装思想，我觉得java比起C++是出奇的方便！字符串要变成char[]吗？不是吧？你以为是C语言？字符串是String类的实例，要求长度要打印，实例方法都有。
开发GUI？那不是JAVA的重点。真强行要来，也不是“手工编程”。

问题当然是有的，而且不少。
我们应当承认，他说的的确是目前比较严重的问题
但是要找出一个完美的语言可能吗？
C++ 已经老了，Java则刚刚起步
过去的辉煌只是过去，不代表未来
拿 C++ 与 Java 比较根本就是个错误
要比也只有 C#
C# 与 Java 骨子里有多少差别大家都清楚
我选择了 Java ，因为我相信它是最好的
即使它现在还不够完美

但是JSP和ASP比要好很多呀！！！

简单地比较不同的语言有点不妥，既然大家知道一种语言的优缺点，就能
根据实际情况选择其最能发挥优势的地方去使用。“百家争鸣，百花齐放”
还是不错的吧？
即便是老如COBOL,PL/I的东西也还在某些地方大量使用。

可惜,楼主说的都是只有菜鸟才会遇到的问题 ...
那些和java的强大专长比起来,真的根本就是无所谓的问题 !!!
windows好用,但只能做个人操作系统..是傻瓜型的
unix你用过吗?? 很难用是不是? 但那才是高级服务器操作系统 !!!
幼稚的评论...
------------------------------------------------------
我们还年轻牛奶会有的奶牛也会有的
可天天在 csdn 混这些会有吗 ??

java是感觉比较烦,东西太多,而且乱.
上次CachedRowSet不能用,变成了abstract的,找了整天的原因,只因为它实现了ResultSet接口(通过RowSet接口继承),而1.4的ResultSet添加了新的方法,搞死人了.
易用性上实在是比不上其它语言,感觉很烦!
JAVA本身实在要好好整整

楼上的，我觉得java封装条理清晰，有什么烦的地方？
弄过C你就知道一个指针，还有指向指针的指针，指来指去有多么复杂难受。相比之下java的数据结构就像积木一样方便清晰。

看你文章好象懂一点java﹐可你爱用不用﹐哪里来这幺多抱怨。本来不想驳你幼稚的言论﹐可又忍不住
"classpath是个臭名昭著的问题，一不小心就出问题。"这能称其为问题吗?就算在你推崇的C++中﹐你不一样要指定你所引用的库文件的位置?(不要告诉我你在用VC或C++builder时从来没有用过路径的设置)
"界面是出奇难用，倒退到DOS命令行去了"这又不知所云﹐如果我告诉你我也可以用DOS命令编译C++程序﹐或我可能用JBuilder编译java﹐你会不会觉得很神奇?
"没有一个好的开发环境，虽然开发环境倒是一大堆，可是不是速度慢，就是bug多。
最好的开发环境竟然是ultra_edit，天，最好退回到notepad.exe。"
这我倒承认﹐java现在的可视化开发环境还不尽如人意﹐不过java才出现多少年﹐C++出现了多少年?如果当年写C++的都是像您这样离了可视化开发环境就玩不转的高手﹐大概现在也没有C++了。
"要编程序？动不动带一堆库，安装就要老半天："讲了这老半天﹐还在说开发环境﹐你最适合用VB﹐太省心了﹐(不过用VB开发复杂一点的程序可能你又要叫烦了)
"开发网页：Tomcat+Velocity+Torque+Ant+......好象还没说JDBC呢。"网上编程用jsp早已超过asp了﹐不知你还有什幺要说的。"好象还没说JDBC呢"?有什幺奇怪﹐好象你用C++开发数据库是直接用C++访问数据库﹐自已写网络协议﹐而不是用ODBC﹐ADO一样。
"如果你是给人家开发库，那幺库从底层到顶层都永远要带个释放资源的dispose，别以为Java会管你其它的资源，它除了内存，什幺都不管......"老大﹐释放资源是C++中麻烦还是java中麻烦﹐如果前面的抱怨还有点影子的话﹐这里就有点挨不到边了。
"语法解析？我CALL，你和C++去比比哪个方便。一个字符串都要转换为char[] 数组才行的东西。
功能强大的流化？打字都要打半天,new ( new ......(new.....))。和C++的iostream去比比。"
语法解析﹐java比C+养眼多了。和JAVA中全是类相比较﹐C++显得过分杂乱了(尽管它的功能强大)。
“一个字符串都要转换为char[] 数组才行的东西”谁告诉你的?只有C++中String才是char[]数组,java中是类。
“功能强大的流化？打字都要打半天,new ( new ......(new.....))。和C++的iostream去比比。？”打字打半天和功能强大有没有关系﹐我现在怀疑你是不是程序员﹐一点逻缉都没有。如果说有关系的话﹐就是你多打一个new就增加一些新功能。
你上面讲了一大堆﹐但根本没有讲到java的优点和它的擅长﹐如果你只是为了做WINDOWS下的GUI开发﹐你用java干吗?从你的言论看来﹐就算是C++你的水平也是初级﹐要不然不会从这幺肤浅的方面讨论一个语言

我最喜欢的语言是C++, 学了两个星期的java, 发现java确实也不错，我觉得java 的类库设计得很好，从中能学习到很好的面向对象的编程思想，如果能将java的一些好的程序设计思想应用到C++ 中，是一个提高自己c++ 程序设计的功力的途径。原来我很看不起Java。现在不同了，我觉得c++ 和 java都有各自的优点和缺点，我们不应该太严厉的去批评某一个语言的缺点或者带有盲目的个人偏执，应该将重点放在他们的优点上。将不同种语言的优点揉合在一起来为我们所用。
我想大多数人都只可能对其中的一个语言有所了解，对另外一门语言也只是泛泛而知（我也包括在内），如果我们只是对一门语言泛泛而知，那我们就不应该盲目的去批评那门语言，或许等到我们深入了解了这门语言后，或许我们会发现我们当初的想法是有失偏颇的。

java 是个很好的东西，楼主的问题我以前也苦恼过，其实针对你的问题java里都有解决的方法。
j

楼主实在是幼稚哦，我来这里看到的是听高手的评论，涨了见识，
对楼主的意见，就当一种“勉励”吧，既有不足，当然还需努力了！
对我而言，c++是艺术，我不敢仰止，java呢，很沉迷，却说不清是什么
，靠他吃饭，靠他实现自己的想法，那么贴近，就是如此！

虽然现在一直在使用Java,也觉得它是一个不错的东西，但是，如果再让我选择的话，我会选择C++ ...

搞vc转c++builder
搞vb的转delphi
搞.net的转j2ee
老板是只要开发效率的。。。。。。。。。。。。。。
JBuilder,c++builder,delphi万岁

两天没来，骂声一片，对storm999做个回复：
classpath问题：我的classpath长度现在已经到达4096字节，不允许我再加了，嘻嘻，你的有多长？我已经出过两三次莫名其妙得问题了，每次都是经过若干次重新启动加上删除开发环境中的缓存文件才解决问题。4096字节不带回车的长字符串要能总是维护正确，实在不易。
界面问题一指java缺乏开发环境，二指java开发出来的程序和平台不够融洽，看看jbuilder就知道，eclipse可以算例外(速度太慢)。
可视化开发环境：我把程序分为两种，内核和界面。内核要求禁得起考验，能够天长地久应用到老，界面(不管是网页还是GUI)要求速战速决，最好不要超过一个礼拜......
VB....嘻嘻，VB是个好东西，我的推荐是VB+C++。VB做界面，C++做内核。
开发网页：jsp是不是超过asp了俺不知道。嘻嘻，按照这种逻辑，html或者xml绝对比任何语言强大的多，普天之下，莫非王土......html万岁。
释放资源问题：作为共别人使用的库，C++中只要一次设计周到，永远OK。而Java很不幸，因为只有到了具体的应用，才能决定该不该释放。
语法解析：大的应用要经过专门设计，这时候java和c++效率差不多（设计时间占多数）。很多时候用到的是一些小的应用，这些应用不适合专门编写个类来处理（功能不聚集，名字也取不好，而且通常这样的解析也不通用），这个时候如果只是indexOf等等又显得不够。只有C++才能两者都提供。
流化：^_^，我可不喜欢打一堆字，烦。
java的优点和擅长？好像是降低成本解决简单应用，其他的应用，俺java用得不多，就不知道了....

classpath问题：我的classpath长度现在已经到达4096字节，不允许我再加了！！！！
//你很行，真的很行，你把所有的JAR包都放classpath里了？
你不会把把库放一个lib目录里用ant编译？别说你还再用CMD javac的编译着
界面问题一指java缺乏开发环境，二指java开发出来的程序和平台不够融洽，看看jbuilder就知道，eclipse可以算例外(速度太慢)。
//Jbuilder、JDeveloper、WSAD做界面不够好嘛？诚然java最GUI确实不是长项，但你有没有区sun的swing站点看看他列举的GUI应用呢？没一个差的
ECLIPSE的SWT GUI速度是非常快的，而且是跨平台的，呢C++做的能做倒嘛？
开发网页：有什么能比JSP和servlet更好的体现MVC呢？
释放资源问题：作为共别人使用的库，C++中只要一次设计周到，永远OK。而Java很不幸，因为只有到了具体的应用，才能决定该不该释放。
//需要嘛？
下面的：我也不喜欢打一堆字，真的很烦的，很烦无知者无畏的
最后一句：既然知道自己用的不多，不知道很多哪就好好学学再来侃

l_walker(苦行僧) :
临时建起来的项目，谁会去写个build.xml来当回事？说实话每个库都要测试一下用起来怎么样的......build.xml只是一个比makefile好一点的makefile而已。
JBuilder据我所知，没有多少人在用。Eclipse的SwT也许是快的，不过Eclipse本身却是慢得要死了。而且swt的设计思路有点类似于mfc，对系统组件做简单封装。功能当然不会强大。C++要做跨平台的GUI当然是可以的，用和swt相同的设计思路就可以做出相同的组件来.....
开发网页：当然java是长项，不过也还嫌烦。
释放资源问题：当然需要。除非是简单应用。
我对java也确实用的不多，实际项目中只做过CRM，其次就是现在的这个GUI的私活了。
C++的做过全文检索，网络爬虫。
只是不知道你用Java做了多少？

我来说一段吧
to: kary(BCBuider回复)
你好
首先我很佩服你的胆量在这里发表这种评论不挨骂才怪
其次我想应该祝贺你因为你已经开始学习 Java 了
下面该谈正题了
你的问题应该是每一个初学者都会遇到的
对于 classpath
呵呵我只有一个 path d:/jdk1.4.1/bin 没有 classpath
自从 1.3 起 Java 就不怎么要 classpath 了
其他我需要的附加库都会 copy 到 project 里面来
看来你还需要仔细了解了解 Java 工作目录以及包的概念
我想对于一个程序员来说了解系统的内部原理是最重要的
而 MS 蒙蔽了太多程序员的思想
我从来不把 VB 看成是一种语言最多只一个 PC 时代的玩具
现在 Java 给你一个机会研究一下界面是怎么做出来的虽不是很深入但总比 VB 强
而且你能指望在 Linux 下还用 VB 的界面？或者就一辈子成为 MS 的奴隶！
其实界面、GUI 等等都是 J2SE 的内容
可谓是 Java 基础中的基础
学习 Java 的 GUI 可以帮助你了解 Java 的一些运行机制以及面向对象的概念
而 Java 的精华还远不在这里
当你学到了 J2EE 或 J2ME 才能体会到 Java 真正的魅力
如果只会拿 Java 去做 GUI 或个人应用程序
那么这个程序员还有很长的路要走
对于开发网页来说你看到的 HTML 也好 JSP ASP 也好
这些只是一个网站的十分之一乃至百分之一
Java 在幕后为之作出的奉献你是看不到的当然也是你无法体会到的
想靠 C++ 的 CGI 来维护一个稳定网站吗？连 MS 都不敢这么说要不然还弄个 C# 出来？
如果把流化只简单的理解为打一堆字
那么我感觉你真的应该花一点时间去理解 Java 对流的封装与修饰
那些都是完美的面向对象的体现
当然还有很多的设计模式在 Java 里同样得以体现
这需要你静下心来慢慢体会
就说这么多了
总之 Java 是一个开放的平台而不仅仅是一种语言
当你全面了解 Java 之后会改变对他的看法的

telenths(_非法操作_) :
哈哈，我这个人，简单，有屁就放，要是自己没觉得好多少，绝不跟风。
Java 工作目录以及包概念：俺家里硬盘40G，但是现在只剩下2个G。空间不足，不能到处放文件。其次的问题是不能到处都有相同东西的备份，不然，下载新库的时候会到处都要替换。
系统的内部原理:如果你想，而且有时间，而且头脑不算太笨，你也可以建立一套GUI系统出来，而不必去研究MS。设计模式那书里不是还给了个可移植编辑器的方案嘛......
面向对象：这方面c++和java差不多，只是C++中你也可以不面向对象（很多情况满有用，如STL），java嘛，要不面向对象也可以.....不过没多大意思。
如果只会拿 Java 去做 GUI 或个人应用程序.......除了B/S结构，Java几乎没办法来展示界面了（除命令行），而程序最终都会要个界面，当然也可以用C++或其他来调用java内核.....
开发网页：C++当然不是这料。我就从不开发网页....除了用Velocity+java来处理过....
修饰方案当然好理解，只是不知道C++的流方案蹩脚还是java的流方案蹩脚。
设计模式：这点C++和Java是一样的，只是C++库比较少，java open source库多一点，专职开发的大公司多一点而已。
说了半天，我的eclipse又出错了，等了它半天了，最后出来一个：java.lang.OutOfMemoryError
今天发了2个帖子，那就是它出错2次了。

Classpath的问题上面有人已经跟你说的很明白(真搞不懂你开发什幺项目﹐4096都不够﹐是操作系统还是数据库?)
“开发网页：jsp是不是超过asp了俺不知道。嘻嘻，按照这种逻辑，html或者xml绝对比任何语言强大的多，普天之下，莫非王土......html万岁。”我没这幺说﹐但你这例子也证明不了什幺。Html或xml应用如此广泛﹐就说明了它们的价值﹐你觉得HTML不强大﹐哪你用C++开发网页去吧。我们的论题是在比较语言的强大吗?
“释放资源问题：作为共别人使用的库，C++中只要一次设计周到，永远OK。而Java很不幸，因为只有到了具体的应用，才能决定该不该释放。”不懂你的意思。
“java的优点和擅长？好象是降低成本解决简单应用”
“降低成本”,对了﹐java更易开发﹐更少出错﹐更易维护(相对C++)。你可能不服气﹐可这是事实。Java的设计者在C++出相近二十年后设计了java﹐其初衷就有避开C++过份复杂的语法和容易出错的地方﹐如指针﹐操作符重载等(而不是JAVA的设计人员太蠢﹐以致于设计不出来)﹐而C++在设计之初﹐为了与C兼容﹐作出了不少妥协﹐也使语言的易用性受到了不小的影响。
“解决简单应用”﹐你认为企业级开发是简单应用吗?不知你见过用JAVA开发的ERP系统吗?我见过ORACLE的用JAVA开发的ERP﹐极其强大和复杂。SAP也开始用JAVA重新作ERP了(我没见过它的产品)。你认为这IBM,SUN﹐ORACLE,BORLAND,SAP这些顶尖级大厂如此不遗余力的支持JAVA是没有原因的吗?你认为这些公司只是解决简单问题的吗?

呵呵。有趣。
kary(BCBuider回复)：几点疑问
1，你不需要加那么长的classpath，如果在dos下用javac操作，你可以指定，如果在一些工具如jb下操作，好像都可以设置classpath，把外部的jar引进来，这种引入是基于项目的。不过我纳闷，怎么可能你的classpath那么长？一般我们的只有一个package,com.公司名.项目名，剩下的全是第三方源代码的路径，不可能有你说的那么长。你说的四处拷贝，嘿嘿。
2，以前很少听说有人专门用java做GUI的（听说过，但是很少），所以对java强求GUI不怎么好--研究GUI的java应用不多。不过你可以去sun看看它做的那几个演示程序哦，好像是applet实现的，还是非常漂亮的。
3，最最重要的：你在c++版说臭名昭著的指针可能还有附和你，在.net版说java的不是能博得一片喝彩，但是在这里你敢说臭名昭著的java，绝对一大堆人骂你。

比这个有什么用处？
无聊！
要不就多学几种语言。
写应用用c++，
web服务用c#，
跨平台用java，
这不是很惬意吗？
谁用eclipse，讨论一下！

新事物开始永远都是被怀疑和被指责的。因为他们不懂，不懂就会在人前矮一截，所以新事物永远都是受到抑制的，被所谓的权威和高手所抑制。但每天太阳还是会升起，什么都阻止不了新事物的发展，也许有一天，一定会有这一天，有人会说“不知道为什么还要发明XXXX这种语言。不就比Java多了几个库，多了几个专职开发Open source源代码的开发商“。到那时，我还是会说”新事物开始永远都是被怀疑和被指责的“，而我，也会永远支持新事物的发展。
（为什么C++有那么多优点而JAVA却少而没有呢，楼主有空给小弟一个回答）

http://www.csdn.net/adv/sReport/

C++ 和 JAVA 的应用领域不同。写网络的就用JAVA(夸平台),
写硬件驱动，大型游戏的就用C++。
没什么可争论的

java的推出，非技术因素含量远远大于技术因素。光说技术层面，C++与java各有优势，但是C++如果有人能给出象给java那么大的力量，让C++更完善一些，我想它会比java好很多。
但是对于市场，尤其是对于sun这类的公司，java比C++好100000000000000倍，因为只有java才能在市场因素上挽回败局

我开始学java的时候几乎每个经典的菜鸟问题都被我碰到，是不是很蠢？我能咋办？自己想办法呗，看javadoc，上google搜，实在不行去坛子，遇到问题就去找问题的根源，别大嚷大叫的，别指望你叫过之后问题就没了，你说最好的环境是u-edit，对，我就是喜欢用它，我甚至不熟悉jb，我就是喜欢手写，就算界面我也喜欢手写，怎样？我没觉得写点代码浪费多少时间！反而开始没有好的思路是最叫人苦恼的，既然学java就别抱怨，不喜欢他你可以选择不学对吧？当你不懂一件事情的时候别评价它，你可以把问题抛出，坛子里自然有很多人帮你解决，自己又能学到更多，何必大喊大叫的？
我是没觉得java有什么好与不好的，都已经学了，就学下去呗，要是说真有什么不好的地方，就是java的东西太多，太乱，太杂，当你以为自己某个部分学得很好的时候，上去看看别人做的东西，你的表情就是：
哇，他妈的这个东西原来还能这样用啊，又学了一招，嘿嘿。。。。。

哈哈，大家还是给java列个做过的项目列表吧。
俺先列自己的：CRM:应用逻辑庞杂，技术层面简单,B/S结构＋数据库，瘦代码层。

难得，这篇帖子很经典
我见过的“骂贴”这个是极少数以笑声结尾的。：）
我很喜欢 java ，真的
为什么喜欢？我也说不上来，也许因为我不会 C++ ！
不要奇怪，我“开窍”不久，java是我第一个努力学习的语言
我喜欢自己手动来，不太喜欢 JB 、VC 这样的图形环境
我想很多一样喜欢java 的也有这习惯吧
所以我机子里一只都是 JCreator （以前是 EditPlus）
我倒是并不讨厌 C++ ，比起 C++ 我比较不喜欢宝蓝
它的东西我觉得很难用(←头脑简单)，而且占资源。
我很喜欢 java 的代码，漂亮的 java 代码有种艺术的感觉 ^_^
当然一个好语言并不只是代码漂亮，
java 的缺点我觉得应该是速度，这是个痛脚，很多人都抓它
“java 不是用来做那种速度要求高的项目的”，这类话也只是在回避而已
没办法，胎里毛病，跨平台的代价
不知道什么时候可以稍微再快点，起码不要让别人老抓它
微软的 jvm 速度就比 sun 的快不少
至于什么时候有好的图形开发环境，
我一直单方面认为这是 sun 在培养 “real programmer”！(←也是在回避事实)
说了这些乱七八糟的，都不知到在说什么
总之，我们不要在窝里斗。自己人有什么好争的？
什么时候干出些成绩来让美国佬瞧瞧，那才是真本事(盗版不算哈)

--classpath是个臭名昭著的问题，一不小心就出问题。
其实我有时候也遇到类似的classpath的问题。尤其是当你装一个不熟悉的库的时候。那感觉真让人发疯。自己开发的话，感觉最好是ant。
不过，这个问题不是语言层面的。而是外部环境的支持问题。
c++为什么这样的问题较少？我想是因为c++有比较流行的出色的ide, 这些ide帮你简化了工作，如果你要自己cc, 用makefile, 一样很烦的吧？（我现在正在试图编译gcc的代码，make给了我上千个错误，还不知道怎么办呢）
java的ide也能做这个的。不过好象没有什么出色的ide。我的希望是：什么人用c++给java做一个好的ide. 可惜，做ide的也都用java来做，单纯追求跨平台，就不肯为各个平台定制ide，忽略了java对桌面程序是不擅长的。ms这个实力强大的公司，又不肯支持java, 只拽后腿。归根究底，不是技术本身有问题，而是现实中的非技术问题作祟。
--界面是出奇难用，倒退到DOS命令行去了。
我也很讨厌java的界面。桌面程序用java来写，似乎搭错了筋。
--速度奇慢，可以出去抽根烟，再回来看结果。
还是指ide慢吧？我的wsad也慢得很。不过我从来不对现在的java ide抱有多大期望，所以也就不那么失望。至少我还可以用我的ultra-edit+javac+java。 :)
--没有一个好的开发环境，虽然开发环境倒是一大堆，可是不是速度慢，就是bug多。
同感。
--最好的开发环境竟然是ultra_edit，天，最好退回到notepad.exe。
同感。不过如果仅做一些不依赖于外部库的纯后台算法（我认为这才是一个程序的灵魂，和外部相连的如web service, ejb都最好是代码越瘦越好），够用了。
--要编程序？动不动带一堆库，安装就要老半天：
安装麻烦，open source一般不提供install shield, 是个讨厌的问题。不过还是外部环境的问题。
--开发网页：Tomcat+Velocity+Torque+Ant+......好像还没说JDBC呢。
web开发本来就挺烦。java社区对web的解决方案又那么多，jsp, struts, cocoon, ejb, jdo, jdbc等等等等，各个库还良莠不齐。有一个统一的标准就好了。不过，open source的精神好象就是variety, 没有权威的。这些库的杂乱，不统一是个问题。但是，这还是一个在语言层面之外的非技术问题。我想这个局面的形成也在于java开发的灵活性，开放性。有得就有失嘛。
--开发GUI？哼，好像不大可能哎。根本就相当于手工编程。
同感。最讨厌awt的那些layout了。如果真要开发gui, 还是最好又一个好的ide来帮你做这些琐碎无聊的事。
--不是有JBuilder吗？我CALL，我用JBuilder建个程序看看，一堆怪异的代码在那儿，吓死我。用Eclipse?，昏SWT只不过是个Baby，永远也不要忘掉dispose。
还是ide的问题。继续同意。
--如果你是给人家开发库，那么库从底层到顶层都永远要带个释放资源的dispose，别以为Java会管你其他的资源，它除了内存，什么都不管......
这就不错啦。什么都管自然更好，不过这在技术上好象暂时还实现不了。如果你要应用oo的各种pattern, 采用面向接口编程的话，不用自己delete就等于节省了99%的资源管理的工作。为什么c++中很多oo的pattern不那么好用，显得比较重，就是因为牵扯进了资源释放问题。
剩下那1%，老兄，做人不能太贪了。
--文本格式化？老老实实的自己编写。
不自己写，等着上帝来写？
--语法解析？我CALL，你和C++去比比哪个方便。一个字符串都要转换为char[] 数组才行的东西。
不懂。javacc, jlex等都可以做呀。简单的东西，StringTokenizer也可以了。虽然不比c++简单，但也不难啊。
--功能强大的流化？打字都要打半天,new ( new ......(new.....))。和C++的iostream去比比。
首先，谁教你这么new啊new的？这对io基本上是不对的。你要记得close()的！
另外，cin, cout虽然方便，但是它们并没有提供方便的扩展接口。为什么你不用给cin, cout套decorator? 因为你不能！这正好证明了c++流库的不灵活。
对了，你的意思可能是c++有<<. >>, 不错，java不支持operator overload.这个决定是否好见仁见智，但是，至少，多打几个字符不是什么大不了的事，如果你的程序的逻辑有一定复杂度，不那么trivial的话。
总的来说，你对环境，ide的意见我都同意（这占了你的牢骚的大部分），最后的几点对语言和库的牢骚我不同意。
你的牢骚也基本没有触及java语言真正的弱点。（如没有generics, 将来虽然会有，也比较局限）

看过不下十次，c++ fans宣称gp比oo优越啦，stl不用oo啦。
言下之意自然是对OO了如指掌，至少知道什么是OO。
但是不才我倒有些糊涂，什么是OO？有什么科学的方法能够说：这是OO, 这不是OO?
按以前最早看到的定义：封装，继承，多态。
其中，继承，分实现继承和子类型。实现继承可以认为并非是OO的必要组成部分，而且可以说是应当慎用的。
子类型和多态有很大的联系，可以说是实现动态多态的必要手段。
那么，看看stl, vector, list, 没有用封装吗？它们内部没有封装私有状态吗?
不错vector, list基本不依赖继承。但这也是“programming against interface”这样一个OO原则所提倡的。
多态呢？stl不用虚函数，是否可以就此说没有多态？错！
stl只是不使用动态多态，但是大量地使用了静态多态。而两种多态只是实现载体不同，但是概念上，设计层面上是一致的。
请问，
list, vector没有iterator pattern?
for_each不是internal iterator pattern?
allocator 不是strategy pattern? less不是个strategy?
loki更是一大堆的strategy.
怎么能为一些不同的语法，不同的名称遮住视线，一叶障目，不见泰山呢？
OO是思想方法，不依赖于具体的实现，否则，c程序员宣称用c实现oo的时候（肯定是函数指针，或者模拟vtable实现多态啦，COM都已经有C的版本了。），不是很可笑?
说gp是OO的一个变种，一个大的子集，一个OO的实现方法，都可以，但是宣称gp比OO好，就有点驴唇不对马嘴的感觉。
c++实现动态多态用vtable, java用查找表，实现上也不一样，那么c++是否也可以宣称自己支持“vtable programming”,简称VP?
说实话，c++堪称独有的，也就是meta programming这种编译时计算，但是，优点有，缺点也不少。
我看好c#的generics.

补充一点，gp说：concept-model。
concept是什么？c++里没有直接的语言结构和它对应。但是，其本意和java的interface是相同的。
model是什么？在c++里是符合concept的类，在java里是实现interface的类。
区别在于，
1。concept-model是静态的，不涉及动态多态。但是局限性也存在，不能应付太灵活的场合。interface-class是动态的，灵活，但是牺牲一定的效率。
2。concept-model在c++中没有语言直接支持，是无形的，需要程序员自己保证类型安全。interface-class在java中由语言明确支持，更简单，不易出错。

我认为出现java是对现有开发语言和平台的一种补充.
当然你可以选择用小刀去砍柴.也可以选择用斧头去砍柴.

没你说的那么麻烦吧.
classpath 已经不用了,要加库,拷贝到
c:/j2dk/jre/lib/ext/ 目录就可以了.
开发环境是比较花内存,但IntelliJ IDEA 3.0.4我一直用,感觉也没什么不好
开发网页:下一个resin别的什么都不要,就可以了.
资源用了都要释放的,那们言语都差不多的.
说到dos方式,其实c++也一样,不过是有个好看的开发环境吧了.
当然我也不是说c++不好,我也很喜欢c++但最重要的是开发对象不同.

楼主，千万别提IE，本来对m$的印象还不错，说到IE我就看它难受了，M$用的手段太shit了
还是说IE，从目前来说Java失去了IE还真不行，但是你知道JNLP吗？这个不错，摆脱了IE的束缚，而且可以实现更多的功能。IE虽好，但是对于程序员和用户来说，编起来和用起来都不爽，所以我现在正在逐步的脱离IE，用SWING，虽然用Layout麻烦些，但是平台独立，很爽，不会因为仅仅是界面的文字改变，就要去重新安排界面，其实用cpp想要达到这样的效果，不比Java简单多少，甚至还要更恶。

总把C++的内存管理说成恶梦——太言过其实了。虽然不如java内存自动回收方便，但是效率很好，使用方便，管理也有章法可寻
总说java好在一处编辑处处运行，我倒请问，这是一个具有普遍性的需求吗？？换一个平台重新编辑一次的工作量有多大？你的系统要换几次平台。用相差n倍的速度的代价来换取是不是真得值得？
所以我说从技术上讲C++优于java很多(尤指C++的潜力)。

对不起，是一处编译不是编辑，打错了

今天晚上闲着没事干，把这位同志犯的低级错误一个个列出来。熟悉C++，很好；不熟悉Java，也没什么奇怪的；明明不懂还偏要开口乱说话，这点习惯实在糟糕。
“界面是出奇难用，倒退到DOS命令行去了。”“没有一个好的开发环境，虽然开发环境倒是一大堆，可是不是速度慢，就是bug多。最好的开发环境竟然是ultra_edit，天，最好退回到notepad.exe。”——请问你用过Eclipse吗？请问你编程的时候重构吗？写单元测试吗？如果你的答案是“no”，我很理解你的外行评价。Java的确不是为你这种业余选手准备的。而且我不知道你为什么总说Eclipse慢，到底慢在哪里呢？如果Eclipse都跟不上你敲键盘的速度了，我看你该先换台电脑。
“要编程序？动不动带一堆库，安装就要老半天：开发网页：Tomcat+Velocity+Torque+Ant+......好像还没说JDBC呢。”——只需要在classpath里面配几个包就嫌麻烦？不需要我教你怎么在Eclipse里面设置build path吧？而且在Java里配的每一个包，我都确切知道它是干什么用的，可以随时根据自己的需要替换或增加。当然业余选手通常是没时间也没兴趣去了解这一切的吧。
“文本格式化？老老实实的自己编写。语法解析？我CALL，你和C++去比比哪个方便。一个字符串都要转换为char[] 数组才行的东西。”——除了叹息我还能说什么呢？你在前面说Java“不过是有些open source的资源”，怎么现在又不知道利用了呢？你不知道有种东西叫正则表达式吗？你不知道有种东西叫XML吗？把字符串变成字符数组来解析，我都替你害臊，大学你都学什么了？
“功能强大的流化？打字都要打半天,new ( new ......(new.....))。和C++的iostream去比比。”——再提个问题，你不知道有种叫Decorator模式的东西吗？如果你嫌打字麻烦，不知道有种叫Facade模式的东西吗？当然了，像你这么勤奋爱打字的人，怎么会用设计模式呢，对不对？
“不要告诉我Eclipse、JBuilder是用Java写的”——你知道多少？你知道Eclipse哪些部分不是用Java写的吗？如果你知道，请你明确地告诉我，不然我很难相信你真的不是在胡说。如果我告诉你JBuilder就是一个纯Java的产品，你的下巴会不会掉到地上去？
“classpath问题：我的classpath长度现在已经到达4096字节，不允许我再加了”——sigh，真正的业余选手，不知道你哪来的勇气对Java评头论足。你不会给每个project分别配classpath吗？在C++里，难道你会把所有的library都include一遍吗？我的系统classpath就只有rt.jar和tools.jar，4096字节，are you kidding？
“临时建起来的项目，谁会去写个build.xml来当回事？”——得了，我看你比较适合去写Perl程序。今天刚看了Uncle Bob的一篇BLOG，title好象是“We will not ship shit. ”，你可以到artima去找找。就有那么一些程序员，这个也是“临时的项目”，那个也是“不当回事”。单元测试？偶尔不测也无所谓。重构？偶尔不做也无所谓。自动构建？当然更无所谓了。于是终于“ship shit”。老话说聚沙成塔积腋成裘，你以为shit都是怎么ship出来的？不过你更强一些，不但在代码里ship shit，还到论坛上来ship shit。
最后，非常高兴你对Java丧失兴趣。如果你出门跟人说自己是Java程序员，我会觉得很害臊的。

上面有个同志提了一个问题：“总说java好在一处编译处处运行，我倒请问，这是一个具有普遍性的需求吗？？换一个平台重新编译一次的工作量有多大？你的系统要换几次平台。用相差n倍的速度的代价来换取是不是真得值得？”
我们的系统在Windows 2000下开发，部署环境是IBM小型机，操作系统是Unix，要求24*7不间断服务。整个系统重新编译一次需要花一天左右的时间。请你告诉我，重新编译一次的工作量有多大？这样的需求有没有普遍性？在我看来就有。任何一个真正的企业级应用，都不可能用Windows做服务器，都不可能动不动地停机重新部署，都不可能像玩具应用那样几分钟就完成编译。速度？你知道企业级应用的速度瓶颈在哪里吗？毫无例外地是在数据库和Web服务器。
请这些同志不要拿玩具应用的眼光来看待Java应用了，拜托。如果你只是想做玩具应用，赶快去用VB或者Delphi好了，Java的确不适合你。如果想谈论Java的优劣，先搞清楚企业级应用要做些什么东西再说。

回复人： kary(BCBuider回复) ( ) 信誉：100 2003-7-22 0:12:01 得分:0
l_walker(苦行僧) :
临时建起来的项目，谁会去写个build.xml来当回事？说实话每个库都要测试一下用起来怎么样的......build.xml只是一个比makefile好一点的makefile而已。
/看来你还不知道ant是什么，怀疑你是否用过，和阿，你不知道build文件可以公用的吗？几乎所有项目我都使用的是同一个build文件，项目目录结构是一致的，唯一需要修改的地方只是项目名和release版本号而已
JBuilder据我所知，没有多少人在用。Eclipse的SwT也许是快的，不过Eclipse本身却是慢得要死了。而且swt的设计思路有点类似于mfc，对系统组件做简单封装。功能当然不会强大。
/jbuilder没人用？不说盗版，你去borland问问正版卖出多少套就知道了
C++要做跨平台的GUI当然是可以的，用和swt相同的设计思路就可以做出相同的组件来.....
/请记住，可以做和已经做了是质的区别，你可以写操作系统和你已经写了操作系统的区别你应该明白
开发网页：当然java是长项，不过也还嫌烦。
释放资源问题：当然需要。除非是简单应用。
/资源的过多消耗关键不在程序本身，而在设计，该用singlton的时候用了多个实例就浪费了，经常使用的就需要缓存，有两本书数据库连接池的原理总该理解吧.....
我对java也确实用的不多，实际项目中只做过CRM，其次就是现在的这个GUI的私活了。
C++的做过全文检索，网络爬虫。
只是不知道你用Java做了多少？
/我做java也确实不多，所以我不敢拿出来现，不过比你多那么一点点
问题回完了再补几句，十八搬武器各有所长，每一种都能其强弱，
你可以说某某很强，因为你不会，所以没学会的对你总是强的，
但你不能随便说它弱，因为你不会，所以没有资格评判，
就如你可以说一个人好，即使那个人其实并不好，
但你不能随便说他不好，这需要证据，若无就成了诋毁，诋毁是要负法律责任的
各种语言都有其强弱，而对于程序员其实都仅仅只是工具，重要的是思想，
就如练武若学会了内功心法，用什么样的兵器只在是否顺手而已

恩师语录:
恩师说:"在我当学生的时候,总爱对自己不熟悉的语言挑毛病,好象自己用的最熟的语言才是世界上最好的语言,我的导师给我的这种情结下了一个结论:懒!".
恩师说:"把你排斥的语言学一年再回来和我讨论,即便是我错了,我也愿意看到你进步".
恩师说:"产生----->发展----->繁荣----->衰败------>灭亡,世上万事万物都要遵守这一轮回,我们,还有我们用的语言都不例外."
恩师说:"现在,JAVA在发展,C++在繁荣,下一个5年呢,JAVA在繁荣,C++在衰败,又一个5年呢,JAVA在衰败,C++已灭亡,再一个5年呢,你们这些在这里争论JAVA和C++谁优谁劣的狂妄小子在干什么,你们在被后来的人耻笑!就象JAVA和C++被淘汰一样,你们被后人淘汰了,可IT技术进步了,社会进步了,就是这样."
恩师说:"凡人为学,不日进,必日退,因为后人的起点永远比你高!".
恩师说:"被淘汰的命运不可阻挡,就象你们将淘汰我们一样!".
恩师说:"从教书育人的角度讲,我希望看到那一天,从我个人的角度讲,我会尽最大努力让那天晚点儿到来!".
恩师说:"你们要尽自己最大的努力,让自己被淘汰的那一天晚点儿到来".
恩师说:"现在你们明白争论那些东西毫无意义了吧".

PC？what is PC？企业级应用可能在PC上做吗？are you kidding？我现在所有的项目都是在Linux或者小型机上的，如果有人说Java不好，我想请他帮我想一个解决方案。

PC?俺还真见过架设在PC上运行linux的省级宽带系统，不过不是普通的PC而是PC服务器。后来性能不行了，换成sun的服务器了。:)
2000年曾经参加的省级项目，知道用的什么吗？数据库服务器是Sun E6500，业务服务器是2台E4500和2台E3000，支撑千万级用户。谁能说怎么换成PC机？:)

to: 回复人：tyzyx(tyzyx)
你说的恰恰相反... java做的系统很少是在PC上的 !!!
你只学过一点c++,不知道java是做什么的,就不要多说了 :)
银行要不要安全? 你知道银行的系统都是什么语言写的?
另外,一个人根本不可能设计出一个完美的系统的..一个人设计的系统,绝对不会完美 ...
否则,为什么一个windows系统要用300人来写?? 而且,windows系统完美吗?
我不是高手,但java精品都是pc以外的系统上的 !!!
------------------------------------------------------
我们还年轻牛奶会有的奶牛也会有的
可天天在 csdn 混这些会有吗 ??

补充楼上一点：
俺只是老土一个，但是知道pc以外的系统不光有java精品，也有java垃圾。
俺们不妄自菲薄说java如何如何牛，关键是看什么人在做这些系统。
用java能做出精品，也能做出垃圾。
用cpp能做出精品，也能做出垃圾。

to ajoo(聪明的一猪) :
c++ fans宣称gp比oo优越啦，stl不用oo啦。----------不知道你从哪儿听来的，两者都重要。
concept是什么？c++里没有直接的语言结构和它对应。但是，其本意和java的interface是相同的。
---------不知道abstract类和interface到底有多大的区别，对于我来说，用interface方便一点
而已。如果没有interface，java里不行，因为不能多重继承。可C++里是可以的。
CAYU(中原) ：说得不错。
welcomyou(我想有钱) ：JNLP不知道，以后学学。Swing编程主要问题是资源和代码没有分开，其次
缺乏ide。
sobingman(丧尸) ：是啊，内存管理对于熟练的C++程序员，算是最简单的问题了。我自己就编写了检查
内存漏洞的类，当写完程序的时候，把这个类加到工程中，再运行，就可以报告内存漏洞了。
Schlemiel(维特根斯坦的扇子) ：
如果Eclipse都跟不上你敲键盘的速度了，我看你该先换台电脑。－－－如果是这样的问题，那么是
操作系统的问题了。我对你的建议是你该重新熟悉Windows或者unix的使用了。
.......Eclipse里面设置build path.....-------看来你从来不运行命令行，我是两者都要用的。
.......正则表达式......XML.......----------正则表达式我在java程序中用的时候，公司的java程序员说
“这个太难用了.....能不能别用啊？” “XML”:真替你害臊，由于某种目的我做过html解析和XML解析（无法用公用库），请问
还没有XML的时候如何做XML解析？？其次，即使有XML库了，我倒想请教一下，怎么用它来解析一个DDL语法或者其他语法？
4096字节，are you kidding？-------没开玩笑，我用一个库，就往classpath加一次，加到后来就变成一堆了。请问classpath和path路径的区别是？
临时建起来的项目，谁会去写个build.xml－－－－－－－－－－临时做的测试代码等，当然不会去做build.xml了，甚至连命令行都懒得运行了。
如果你出门跟人说自己是Java程序员，我会觉得很害臊的。-------真替java程序员难过......
Schlemiel(维特根斯坦的扇子) :
一处编译处处运行的含义是编译的时间问题？好像关键问题是可移植性吧？
你知道企业级应用的速度瓶颈在哪里吗？毫无例外地是在数据库和Web服务器。－－这又说错了。怎么这么轻松的就怪罪到数据库和Web服务器上了？你说说Apache或者Oracle哪儿设计有问题，浪费了资源？
l_walker(苦行僧) :
本来不想回你了，再回一次：
临时建起来的项目－－－－已经答过，见上。
JBuilder---------JBuilder卖了多少拷贝你知道？你还知道它其他产品卖了多少？
跨平台的GUI------知道QT吗？为什么你现在还没听说过它？原因何在？
释放资源问题－－－－你应该对sun公司开发人员说：为什么你们不把socket.close()或者其他方法取消掉，用singleton解决不就得了.......
我做java也确实不多，所以我不敢拿出来现，不过比你多那么一点点-------说来听听？我有两年时间一直在做全文检索的产品，而我的另一同事做了足有10个，因为他的只要2个月做一个项目就够了。
zyymmm(为成为VC高手而奋斗) ：比较有意思。

to kary：
怪罪？Apache和Oracle不需要任何设计问题，任何一个企业级应用的性能瓶颈必定是在它们那里。这是IO性能和内存性能的区别，IO处理比内存处理天然地慢好几个数量级。莫非你不懂？
至于编译时间有没有问题，就算我不知道吧。我给你提个问题好了。我们的系统在Windows下开发，客户环境是Unix和Linux（各种版本），以及部分Windows，需要安装的客户可能有5000-8000家（一个省级机关下属的所有单位）。能不能请你帮我想个解决方案？
我不是一个为爱好而编程的人。我所做的每件事、选择的每种技术，目的只有一个：在客户认可的成本范围内，按时交付客户需要的软件。所以，虽然Java是这么差劲，由于我的孤陋寡闻，还没有找到一个合格的替代品。既然你见多识广，就是上面这个问题，请你指教。

Apache和Oracle不需要任何设计问题，任何一个企业级应用的性能瓶颈必定是在它们那里--------web服务器何数据库通常都已经优化到极点，它当然费时间，可是你又有什么办法优化它？可是如果你能够减少数据库连接的次数，减少需要动态分析的网页，速度仍然能上去。
我以前看到过广州一家单位的需求，很简单，要求做一套系统，能够检索2～3年约400G的数据，有同事分析说，如果需要达到秒级查询，那需要Sybase的一个核心数据库来做的，价格约40万美元。
可是我说你应该分析查询的特点，直接用Berkeley DB之类的数据库（是个核心API），做成分布式的，每台机器上按照一定的划分方法（比方说入库时间等）实现。价格可以降低到＃◎◎＃！如果只知道用人家的数据库，那么如果数据量不是400G，而是4GGG，那该怎么办？
编译时间问题：
^_^，我估计你的5000-8000家单位所有系统的也不过20种吧(我还列不出20种不同操作系统呢)？那么用C++只要编译20次－－－－－是不是C++也是“一次编译到处运行”了呢？
很赞同你对技术的看法，我也是觉得只要是实用的，能满足需求的就是好的。

题个问题：
你在windows下开发c++程序，怎么会不用windows api和MFC那?
你怎么拿到其他平台编译那？

to baitianhai(hong) :
我们的全文检索能够在windows、linux、sun 、DEC、hp、ibm小型机上使用。你说怎么做的呢？虽然在Unix系列下不提供GUI，可是仍然用到了线程等，这又怎么做的？而且做的工程文件中，只要把整个系统目录端到我说的任何平台下， make一下就可以使用了。
核心和界面是分开的，一则界面多变，二则没有必要自己去开发GUI库。
Oracle、mysql或者其他的软件,或者许多其他的open source等，不都是这么做出来的？java的jre不是为每个平台都提供了版本，如果这些版本不是通过相同的代码编译出来的，它如何维护不同平台版本之间的一致性（会不会出现在某个平台下能够运行你的代码，换个平台系统就说“No,你的代码有问题”）？

偏激对一个做技术的是一件好事。
如果不喜欢Java就不要用哦。
自认为很NB写C写汇编也可以啊。
Java不是用来写GUI的。也没有多少人在用Java写GUI，
而且我是找不到理由为什么要用Java去写GUI.
在批评一个东西之前最好多了解一下，否则不要轻易去评价。
因为你还没有到哪个水平。
你说Java很垃圾，好你写一个比Java好的语言出来。
写不出，闭上你的嘴。好好学习。
Java之所以有现在的成绩，一定有他的原因，换句话说一定有可取之处。
你有没有仔细去看他的可取之处呢？
如果没有你绝对应该检讨自己。
用就用他的可取之处。不好的地方就想办法绕啊。
我不和你讨论Java的优劣，因为这是多余的。
下面的话你觉得需要好好看一下，如果你觉得放屁就当没说
1:)不要随便去否定一种语言。存在就有合理性。
2:)语言本身没有优劣，但人有。但语言的使用有选择，你不会用Java去写OS吧。
3:)不管你水平有多高，谦虚很重要。
4:)在对别人要求严格的时候记得对自己要求也严格。
5:)付出和收获在一定时候是有比率的。要提高自己的Java水平，要好好学习。

kary(BCBuider回复) :
个人认为：这场争论早该结束了。
虽然我对c++懂得太少了，java也不咋地，但是我还是觉得很多比方不如你想得那么简单：
“一处代码，到处运行”：
java里面有jvm，但是c++里面甚至不同的编译器有不同的指针长度。jvm耗费了很多前辈的心血，才有了java的跨平台，技术含量没有想象的那么低。c++怎么跨平台我不知道，最基本的：怎么处理不同平台，不同编译器之间的字长不一致的矛盾？typeof?我没有见过一个typeof满天飞的c++程序，更多的我无法明了的细节就更不用说了。只是我听到一位高手说过：c++平台间的移植，远远超过ejb在不同的app server间的移植，就像一场噩梦。
因为c++程序从来就以考虑跨平台为设计的出发点，所以你如果一定要开发一个“到别的平台上只要编译一下就可以良好运行的程序”，我觉得，实验室允许，企业不允许；小程序允许，大应用不允许。
内存泄漏和资源释放：
我觉得java里面做得够好了，起码它一定限度的管理了内存。“java只管理了内存”，我记不清是上面哪个朋友的抱怨了，知足吧，c++里面连内存都不管（当然我只能说这是给c++程序员更大的自由度，但是内存是仅次于cpu的最重要的资源，jvm来管理确实减轻了java程序员不少的负担）。但是即使如此，java里面还是存在内存泄漏的危险。
我不明白为什么楼主那么自信可以轻松搞定c++的内存泄漏。“是啊，内存管理对于熟练的C++程序员，算是最简单的问题了。我自己就编写了检查内存漏洞的类，当写完程序的时候，把这个类加到工程中，再运行，就可以报告内存漏洞了。”，这更像一个测试的方案而不是一个程序设计的方案。关键不是内存有没有泄漏，而是在哪里产生了泄漏，怎么样避免，杜绝泄漏！不是我信任楼主有这个能力，而是这个问题，那么多人抱怨，甚至包括一些大家公认的高手。
Socket.close(),更多的以为这是一个笑话，不是吗？
企业应用性能的“瓶颈”：
java的里面企业应用性能的“瓶颈”确实在server上，特别是app server上，情况远远不像楼主说的 app server和database server之间的配合达到了极至。集连，负载平衡，工作流，可以列举出来，需要列举出来的名词很多，需要改进优化的地方多得不得了。oracle没有问题，apache也没有问题，配合起来同样没有问题，但是性能呢？能不能运行是一回事，运行起来是否表现优异又是一回事。
减少动态内容，这是一个设计的范畴，设计的时候在满足客户需求的情况尽可能的减少动态内容，但这是个治标不治本的措施，如果客户要求那么多动态内容呢？减少数据库连接的次数，一般应用中使用的都是DataSource操作，减少数据库连接的效果远不如直接连数据库的时候那么直接。当然，作为一个好的程序员，努力提高自己的代码质量是份内的事，但企业应用中个人的作用真的有限。
上面说到一个你说的采用分布式来处理数据库的例子，我认为您是高手，我不怀疑您的设计提高了性能。但是即使是我对您产生了崇拜，我都绝对不会认为分布的算法是绝佳的。即使是你设计的那个算法一段时间内满足了用户对数据请求的最优化响应，过一段时间未必好使，动态平衡的算法优化，是一个永恒的话题。
abstract class 和interface
java版的好贴不多，但这方面确实有几个好贴子。oo设计里面更倾向于集合而不是继承。我不认为不支持多重继承是java比不上c++的地方。相反，我认为这样，单亲，java里面oo的思想更贯彻一些。而且interface或多或少的弥补了java这方面的实现上的缺陷。
GUI:
不要指望GUI跨平台，个人的理解：跨平台的GUI，效果不会达到最好。每个平台有自己的显示模式，大家都照顾点了，效果就不要奢求了。这一方面native总是占优势的。
Swing缺乏好的IDE我同意，我最深刻的记忆是一个在jb里面画好了的窗体加上look and feel后显示起来变了大样。我也不明白说的资源和代码的分离是什么一个概念，要是做到像vc里面那样，swing完全可以做到（至少用jb开发可是做到），关键是看你怎么实现了，怎么组织你的代码。
classpath：
上面已经有很多人指出了其中的问题。看看吧，别人说的未必都不对。
Ps:在企业应用的时候从来不运行命令行不是一件什么丢人的事，毕竟工具配置比命令行更高效，更可视，而且还有个版本控制的问题。只有在某些环境，比如我认识个朋友在unix下vi+javac+appche+ant开发他的程序的时候才用,不得不用命令行。
字符串的解析：
我看了半天没弄明白，这和java有什么关系？个人觉得java对字符串的处理还是做得不错的，至少比c++强。C为什么写CGI程序比不过perl，就是因为字符串处理能力弱。我刚准备敲一段说c++这方面做了些改进，我有个做c++的同事说：STL的string做参数传递时有问题的，少用啊，如果不是必须，还是尽可能的用char[]，我晕倒。
不要因为一个对正则表达式产生畏惧的java程序员而就说java处理字符的能力弱，的确jdk1.4 以前java不支持正则表达式，但是jdk1.4开始已经支持了。即使是jdk1.4以前，java的字符处理能力也已经很强了。Jdk里面本身也没有解析xml的实现，更多的依据第三方，但是差不多形成了事实的标准了。做java项目的时候，引入第三方源代码好像是件很平常的事。解析.ddl,嘿，不多说了，没有你想象的那么困难。
杂七杂八的想法：
更多的时候是修改buil.xml而不是自己重新写一个。
全文检索系统，我无法猜测它需要实现的功能。但是至少目前我疑问你为什么不用c++去做这个系统？全文检索根本就体现不了java的优势，相反它反而可能比c++要慢一些。事务，安全，持久性，也许java这些方面更好些，更有价值些。
Btw:
希望大家更多的是讨论技术问题而不是对人本身进行诋毁。

我们的全文检索能够在windows、linux、sun 、DEC、hp、ibm小型机上使用。你说怎么做的呢？虽然在Unix系列下不提供GUI，可是仍然用到了线程等，这又怎么做的？而且做的工程文件中，只要把整个系统目录端到我说的任何平台下， make一下就可以使用了。
================================================================================
你这个系统准备怎么设计?b/s ?c/s?你报了那么多平台，是准备在那么多平台上运行客户端，还是设计在那么多个平台上运行你的服务器啊（别告诉我是个简单的单机application啊）？不是在几个机器上运行就是有跨平台的要求。
核心和界面是分开的，一则界面多变，二则没有必要自己去开发GUI库。
=======================================================================
界面多变？你是设计系统还是炫耀技术和精力？无论在哪个平台上，同一个系统的GUI的look and feel应该尽可能一致。我想着该是一个原则吧。
Oracle、mysql或者其他的软件,或者许多其他的open source等，不都是这么做出来的？java的jre不是为每个平台都提供了版本，如果这些版本不是通过相同的代码编译出来的，它如何维护不同平台版本之间的一致性（会不会出现在某个平台下能够运行你的代码，换个平台系统就说“No,你的代码有问题”）？
==================================================================================
不要想当然，平台间的移植不是你想象的那么简单。

问题应看发展。
面向对象是趋势。。
虽然C++也面向对向。
但没有SUN那套好呀。

zengsiyu(绝代编手) :
同意，并不一定要使用java，学习java完全是由于它
强大而有效的设计理念。。。我用vc2年多可，现在学习java
感觉里面确实有东西，前几天把webservice和xml技术看了一个低草天
，现在正在攻读ejb，ejb完了看系统的j2ee，这样将来编程时就可以无形
中使用它的设计理念，，，，
希望大家不要上来就说xx语言不好，xx出现本身就有意义，，，，
特别希望楼主不要这样。。。。（我也是一个c++程序员）

企业级应用非java默数

http://www.tiobe.com/tpci.htm
看看这个就知道了，荷兰有家公司（TIOBE）每个月发布一次编程语言的受关注程度的排行榜。

asdmonster(努力学习VC，讨回失去的信誉分) :
继续，继续，^_^
怎么处理不同平台，不同编译器之间的字长不一致的矛盾？typeof?我没有见过一个typeof满天飞的c++程序－－－－－你有时间的时候应该看看mysql的代码。它里面几乎很少用到uint16，我搜索了一下，216处（我当时为了看mysql核心，有些代码已经剥离掉了，所以我工作环境中mysql代码没有5M的。不过俺没看完，看了1/3没时间看了:-)）。要知道这是数据库，它为了效率的原因不得不这样做的。java当然不需要考虑这种问题，因为还没看到谁用它来做高效率数据库的。大多数情况下，基本不需要考虑类型的字节大小问题。产生字节大小的问题有：1）网络程序（网络API各个平台比较混乱）2）存储，如果直接将一个结构的内存块保存到硬盘文件中，那么这个数据文件拷贝到另一平台也许没法用 3）强制类型转换，例如把char*直接转换为一个int(会引起可移植问题，例如如果指针地址没有8字节对齐，则在Dec这样的64位平台下出现异常)。后两个问题除非做特殊的应用，例如设计一个mysql这样的数据库，否则很难遇到，除非是新手。
我觉得，实验室允许，企业不允许；小程序允许，大应用不允许。－－－－－你觉得mysql、jvm......是小应用？企业不能做？
这更像一个测试的方案而不是一个程序设计的方案。关键不是内存有没有泄漏，而是在哪里产生了泄漏，怎么样避免，杜绝泄漏！－－－－－－是啊，这更像测试方案。不过设计时同样要尽量做到“谁分配，谁释放”，对象职责一定要清晰。否则，即使报告了内存泄漏，也不容易找到。出现内存问题时，我调试时间基本上不会超过2个小时，说实话要完全避免出现这种问题不可能。反倒是有些其他的问题更难处理，我调试过这样一个错误：fstream in("xxx",ios::binary|ios::in)，不幸的是我把“|”写成了“||”，所以文件总是以流方式打开的，当碰到ASCII为26的字符的时候，就认为文件结束了，而那个错误发生概率很小，需要测试很多文件才发生一次......调试那个错误费了我两天时间，而且还是同事帮助下发现的。
Socket.close()：如果客户程序员能够不用调用它，那该多好！你永远只要new出来，而不需要考虑它的关闭问题。库开发人员是非常希望他们的库简洁好用的。C++提供了这种可能。
我都绝对不会认为分布的算法是绝佳的。即使是你设计的那个算法一段时间内满足了用户对数据请求的最优化响应........一般产品考虑的适用时间长一点，项目短一点罢。
abstract class 和interface：没错，“有一个”比“是一个”关系更加好用。有人还建议继承不要超过5层，是有点道理的。我也不认为不支持多重继承是java比不上c++的地方，毕竟单根结构简单多了。MFC弄了个CObject，BC弄了个TObject，如果自己再弄几个，这26个英文字母都要搞光了^_^。interface很好，我就觉得C++还应该加个interface，表面上看起来有点冗余，实际方便了程序员。还有java里所有没加final的方法都是可重写的，这也方便了语言的使用。C++当然也可以给每个方法加上virtual关键词，可毕竟不是缺省virtual。当缺省不是virtual时，程序员的思路是“我要不要将这个方法改为virtual的，用户会不会需要修改它”。而当缺省是virtual时，程序员的思路是“我要不要将这个方法改为virtual的，以免用户修改它”。当然这只是导致了习惯思路有所不同而已，没什么大不了。
classpath：很多人意见都是对的。我于java毕竟是初学而已。
字符串的解析：C很弱，C++可不弱。STL的string做参数传递时有问题的－－－－这话太含糊，不知道是什么问题，好像不应该有什么问题。我自己写过类似于MFC的CString，效率非常高，但是那玩意才有一个问题：如果程序生命期中使用CString的内存高峰值是50M，那么这50M从此不会释放，除非程序终结。但这个问题只能说是为了效率的问题而产生的。不过字符串解析绝不是指使用string就能处理的东东。
用正则表达式表达式么，大概各个语言里面都差不多。C++ boost有regex。
需要自己做XML解析肯定是出于特殊的目的的。
解析.ddl很简单，之所以说到ddl是因为上面的朋友说用XML做字符串解析，不明白了。
全文检索系统，我无法猜测它需要实现的功能。但是至少目前我疑问你为什么不用c++去做这个系统-----本来就是用C++写的，因为不敢用java。如果lucene效率高的话，那我会很佩服lucene作者了，他敢做。
asdmonster(努力学习VC，讨回失去的信誉分)：
你说google的后台是什么？
不要想当然，平台间的移植不是你想象的那么简单：当然不会很简单，平台移植只有有经验的程序员才能做好的。另外，我的全文检索现在处于维护阶段，要不然我哪有时间去学java？
zfive5(醉马不肖):接受意见。
其实本贴不能算是争论贴，而是牢骚贴。java确实很多地方方便了很多。程序员的成本就是例子。好的C++程序员通常需要好几年的功力还要自己能学才行，而java程序员几乎只要3个月培养（当然两者都不是说架构设计师，而只是指能做点好事情的程序员，比较聪明的不在此列）。不过java还不够方便。

“好的C++程序员通常需要好几年的功力还要自己能学才行，
而java程序员几乎只要3个月培养”
一般初学Java的程序员在java 前已经有其它程序语言,甚至是oo语言的基础
而初学C++的程序员一般只有 C 的基础。
还有就是系统的库以及java的一些“方便”因素导致“几年”与“3个月”的时间差
但是“几年”与“3个月”仍然有质的差距，
要达到有几年开发经验的C++程序员水平，java程序员起码也要1年以上
因为那3个月完全是由java的系统库撑起来的“能力”
像我一样的初学者应该由体会吧
太依赖于现有方法，反而成了个伪程序员
我所说的不是java的弱点，而是强处。
只是我怕它会宠坏一些新手(包括我自己)，所以提出来一下而已 : )

既然仅仅是牢骚帖，继续up一下也不错啊。^-^
onefox(一品狐):
我没有你想象的那么强，甚至可能还不如你呢。要真的照你那么说，今后我可不敢在csdn提问甚至是发言了。计算机知识浩如烟海，真的，学得越多，感觉自己懂得越少。常常，回想起自己以前说过的一些毫无根据的断言，不禁独自发笑。还是好好学习，常来csdn灌灌，多向真正的高手学点东西实在啊。
kary(BCBuider回复) ：
很多东西我现在还不懂，就像google是怎么实现的。我仅仅是个一般的java程序员。我希望说出我自己理解的一些东西和大家交流，能让自己懂得更多。
在说下面的话前，我首先申明的是java是我的饭碗。如果可能，我会把java学得尽可能好，c++仅仅是我的业余爱好——我不自信我有能力把两种语言都精通然后和大家一起比较二者的优劣细节。

1，跨平台
不管mysql怎么实现，我都不会认为c++程序简单的重新编译一下就可以。16，32,还有8位，将来还可能有64位。java可以开发一个8位或者64位的jvm，有了这两个jwm，几乎所有的程序就可以移植了（改动甚小）。而c++呢？每一个程序都需要在编译（这还是理想的状况）。sizeof()的使用是强制的使用定长，类似于jvm虚拟机的实现（但是毫无疑问，这样会降低效率）。这仅仅是一个细节。（当然我讨论这个细节没有任何说服力——我也就是个c++的人门者。）
很少有朋友说他们为设计基于多个平台的c++程序，据说（我从来没有实践过），他们一般是基于某个特定平台设计他们的c++项目，然后如果想开发别的平台的产品，在原有的基础上进行修改，良好的方案设计来保证将这种修改量最小。
其实在跨平台这一点上，java和c++的区别是：java面对的是提供了统一得调用接口的各种jvm,而c++面对的是各式各样的底层结构。我说在企业和大项目中不允许是那种只要把源代码拿到别的平台上简单的编译一下就可以出货的c++产品。你不觉这样的状态太理想了吗？（如果真有这么理想，java绝对不敢再鼓吹它的跨平台了——c++可以和它做得一样好，而且更快）
2，内存泄漏
我指的不是指你说的那种泄漏，个人觉得那种泄漏倒还容易察觉。内存泄漏的例子很多，就像上面有位朋友说的：相互间得多重引用。这种泄漏照你说的方法倒是可以查出来，但是解决起来可就麻烦了。java里面非法的引用会出错，c++里面压根儿就不管，指针爱指哪指哪。要是整个项目一个人写，如果有足够的精力和能力，也许还能查出个所以然来，但是一个项目里面几个人协作，只怕纠错纠不那么容易了。sun那些工程师写的java api里面还有内存泄漏呢（是java.util里面的一个类，具体我记不得了。）

3，socket.close()
socket自己调用关闭，我觉得是个好想法，但是仅仅是个好想法。
仅仅思考一下可能出现的一种情况：socket使用的时候发生了异常。这时候应该是关闭socket的，但是这时候jvm怎么判断？socket还作为一个有效实体存在，仅仅是它内部的内容已经废弃了。这种情况jvm是没法判断的。不能指望像c++的那样析构函数——这样发生异常的socket永远不会被关闭——除非jvm关闭（注意：这里我说的socket指的是可以调用close()的socket类的实例，而不是在网络间传递的socket）。其实网络上可能发生的事情还有很多,还是自己动手释放资源吧，api不能释放，也释放不了。不要为难sun的工程师。 :-)
4，string
STL的string当作dll的参数传递的时候会出问题，常常掉东西，这是我的同事给我的最新的注解（他忙，问题又和现在的工作无关，不敢问得更多）。（至于mfc的CString,说真的，我不太喜欢讨论m$的东西，无论好坏一律扁之。）
其实我就没觉得xml解析有什么好办法：dom太慢，sax又是事件触发而不是面向对象，以前有人说不知什么公司有一种新的解析方式，基于sax,而且是面向对象，只是没见识过。

其实我挺同意zfive5(醉马不肖)他们所代表的意见：用java的设计思想写c++的程序。这是个理想境界。

STL的string当作dll的参数传递的时候会出问题，常常掉东西---------这么做通常不死才怪！
如果java调用我C++的一个类似于string的东西，然而资源释放函数却调用另一个人写的东西，你说会正确的吗？
dll之类的边界上更要注意谁分配，谁释放的问题。

呵呵好久没有这么经典的帖子了
我想不清楚怎么会有那么多的人这么的喜欢java，并不惜为之“付出一切”
有些人口口声声强调企业级的应用，很吓人的，
问一下，你所说的企业级的到底是什么样子的
以前曾经见过一个类似的帖子，不过比的是vb 和 delphi,说什么delphi是拿
来开发企业级的，呵呵，现在在这里delphi也不行了。
不知道为什么这些人这么喜欢java,而这么不喜欢microsoft,
难道都是所谓的正义感吗？呵呵，搞笑，这些东西在这个商品社会已经不流行了
其实java 也好.vb 也好，delphi也好， c++也好，还是一句很俗的话，
都是工具，都有自己的位置，或者说都是不相关的，大家又何必呢
正所谓世上本无事，庸人自扰之
但是偏偏很多人却以次为乐
再说一句：Eclipse 并不是纯java写的， Eclipse的基础swt的特性就是使用jni,呵呵，所以说eclipse是纯java的那位......（现在swt也有C#的实现）
还有很多，感觉好想真的有很多自命不凡的“高手”，其实我只想说一句
“高手”们，不要动不动就搬出一堆“专业”的词汇来，还是务实一点吧，
如果确实有空去陪居委会的大妈聊聊天也好，不要在这里误人子弟了。

不知道为什么还要发明Java这种语言。----> 发明这种语言的目的是为了给便携式电器使用的。
不就比C++多了几个库，多了几个专职开发Open source源代码的开发商。----> 并不多，C++世界的类库更多，只是标准不统一，每个开发组都有自己的类库。但java所有的类库都符合同一个标准。
classpath是个臭名昭著的问题，一不小心就出问题。-->没办法，windows程序默认寻找当前目录的dll，所以很容易放一个同名的来替代系统的。这也是设置classpath的优点，就像linux下运行当前目录程序都要 ./xxx 才行一样，避免了一些危险的情况。
界面是出奇难用，倒退到DOS命令行去了。----> cli 可以胜任任何事情，在linux/unix下我也用命令行，虽然windows的dos box出奇的难用不过在xp已经开始向bash靠拢了，这不是后退是前进。所有系统都通用的。
速度奇慢，可以出去抽根烟，再回来看结果。----> java client做的界面是公认的速度不行，但java server也是公认的效率好。
没有一个好的开发环境，虽然开发环境倒是一大堆，可是不是速度慢，就是bug多。---> 你为什么依赖集成环境呢？我觉得一个好的文本编辑器+命令行编译+makefile就足够了。
最好的开发环境竟然是ultra_edit，天，最好退回到notepad.exe。---> 我更喜欢editplus和vi ，包括写c++程序。你不适应只能说你太依赖环境了。
要编程序？动不动带一堆库，安装就要老半天：---> java的方便之处就在于库可以直接跨平台使用，C++一大不足就是没有丰富的标准类库(现在虽然有STL，但还显不足)。如果你安装过一套类库了，你就可以跳过这部分，除非你不能分辨。
开发网页：Tomcat+Velocity+Torque+Ant+......好像还没说JDBC呢。---> 这也是从unix带来的优点，不同公司不同小组的产品可以很容易的整合在一起，其他语言则必须要使用针对该软件开发的插件或者软件才可以。
开发GUI？哼，好像不大可能哎。根本就相当于手工编程。---> 你可以试试Glade.免费的。
不是有JBuilder吗？我CALL，我用JBuilder建个程序看看，一堆怪异的代码在那儿，吓死我。用Eclipse?，昏SWT只不过是个Baby，永远也不要忘掉dispose。--->要是机器生成的代码你都看不懂，我就没办法和你争了。
如果你是给人家开发库，那么库从底层到顶层都永远要带个释放资源的dispose，别以为Java会管你其他的资源，它除了内存，什么都不管......---> 已经比C++轻松多了。要是他什么都管，你还需要做什么呢？
文本格式化？老老实实的自己编写。----> 不明白你在说什么。
语法解析？我CALL，你和C++去比比哪个方便。一个字符串都要转换为char[] 数组才行的东西。---〉这点我同意，我也喜欢C++里面直接就能用。
功能强大的流化？打字都要打半天,new ( new ......(new.....))。和C++的iostream去比比。---> 恩，这个就不同了。如果new的是基本类库的，那好像敲起来比较麻烦，你可以建立自己的factory,但要是你自己写的类，C++每个都要有对应的delete 你就不觉得累了？
我用Java，我都烦死了。整个一个倒退到史前时代。整个一个手工编程的典范。---> 我还没有见到过不需要写代码的语言。哦，不对，自然语言就不需要写代码。
总的来说，你的思路不错，如果能做出一种不需要写代码，就能产生结果的开发工具，真的就太棒了。不过我怕有了这种工具，普通程序员会失业，只有做相关工具开发的高手才有饭吃，那不惨了？

Bravo!
http://www.csdn.net/adv/sReport/

JAVA---跨平台---企业级分布式应用
不得已采用解释执行的方式
使得JAVA速度上比C++慢一个数量级
再加上安全性考虑
就有了诸多限制，少了许多灵活性
所以，尽管国外众多大公司对J2EE趋之若鹜，还是免不了被C++ Fans们笑话
但是，请注意，JAVA并不是生作GUI Developer Kit的
当初它一露面就受到业内许多大公司们的疯狂追捧，全都是因为---跨平台啊

yayv(yayv) :
java的类库都符合同一个标准是因为语言本身就使你没有选择。再说，大都用的也是sun的东西。
path目录搜索的方法并非缺点。classpath我想之所以不做成搜索的，恐怕是因为效率的原因，java不能再慢了哦。
命令行并不好，偶尔有效率高的地方。xp没用过。提供bash并不说明命令行比GUI好。如果没有windows，只怕现在用电脑的人数要去掉80％。正如正则表达式，有时候用一下还真方便，但是会用的少之又少。
好像web server端效率最高的是asp吧？
你不觉得用文本编辑器+命令行编译+makefile效率不是太低了点么？如果写完程序，鼠标一点就全部格式化好了，方便么？
库只要安装一次，那倒是的，要不然我的classpath不会那么长。我每次用一个库，就往里加一次。不过后来出了3次莫名的错误，现在全部删掉了。不过下次用到的时候又要设置了。
......这也是从unix带来的优点，不同公司不同小组的产品可以很容易的整合在一起，其他语言则必须要使用针对该软件开发的插件或者软件才可以......好像不是java或者unix的优点产生的结果吧。web server、数据库、php、javascript、asp、java.....这些东西你怎么整合都可以，难道这些东西是java或者unix带来的好处？
......你可以试试Glade......呵呵，我怎么就成了人家的测试人员了？要是不好用，岂不是又要推倒重新学过？一生有多少时间啊？
如果机器生成的代码不好看，你会用它么？满机器都是机器语言，你怎么不看？
........永远要带个释放资源的dispose........不爽ing，
{
fstream in("file",ios::in);
auto_ptr<A> a = new A();
while(in){
reading....
}
//in.close()；这句可以不要，你忘了没关系。java能这样做么？
//delete a?
}
文本格式化不明白？哦，java不用，访问数据库，处理一下业务流程，其他不是java的事,,难怪你不知道。
C++每个new都要有对应的delete 你就不觉得累了？－－－－>这种new和delete都封装在类中，当在使用该类的时候，不再需要new和delete了(可你能把java的流库封装一下，以便不需要close吗？)。而且上面的代码里面你也看到了。再说并不是什么时候都能把内存当作取之不尽的资源的。昨晚用outlook接收一封80M的邮件(分解为每封2M)，并进行组合，结果花了我整整一个晚上，机器几乎没有任何响应，最后还是出错了。如果用java写个和outlook一样的程序，估计结果也是一样的。我现在的CRM中也有处理邮件的，不过那服务器不错，2G内存......
不需要手工写代码的语言是没有，不过不需要手工安排界面上组件的显示的工具倒出现过很多。

谁说java不好，c#还copy java呢

kary(BCBuider回复)
市面上用的最广的java工具和产品都不是sun的，是ibm和apache的。
path目录搜索的方法并非缺点。classpath我想之所以不做成搜索的，恐怕是因为效率的原因，java不能再慢了哦----> 你是用c++的，如果你写编译器和jvm，你是在装载时扫描一次呢，还是每用到一个类库就扫描一次呢？
关于命令行，咱们讨论的是开发，不是使用。我给最终用户如果是java的，我会最好快捷方式或者启动用的shell脚本。
关于整合，这一点你说的很对，的确不是java或者unix带来的好处，只是他们的习惯。微软的东西也很看重整合，虽然重点是他自己的产品，而且接口一般都比较神秘。这方面C++的STL的确很有优势，但也有缺点就是过于爆露。
Glade 是 c++的工具。开发的窗体使用Xml表达的。一种很新的思路而已，没想到你连看都不看就开始批判。这个也算是我错了，我不该向你推荐我认为比较好的东西。
//in.close()；这句可以不要，<-- 你写一个in::~in()就知道为什么不需要 in.close()了(当然，你肯定写过，不然不会拿这个跟我争的)，java没有析构函数，所以呢需要一种主动释放资源的方法，正所谓有得必有失。因为java语言上减少了很多麻烦和容易混淆的东西，所以java更看重设计模式，而在c++版就没有设计模式，并不是c++不用，而是c++程序员能达到熟练运用语言就已经很不容易了。
这种new和delete都封装在类中，当在使用该类的时候，不再需要new和delete了<---这部分我不理解，向您请教，最好给出代码。希望不是类厂。
80M的东西你也用邮件来收，只能说你使用的工具不合适。工具本身自有他的设计目的。其实呢，我们也可以用java写一个操作系统来呀(当然还要依赖一些环境)。或者用asm来写WebServer,都是很有趣的事情。
不需要手工写代码的语言是没有，不过不需要手工安排界面上组件的显示的工具倒出现过很多。<---------对，尤其C++ java C# 的多，当然还有object pascal, 其他的我就孤陋寡闻了~

市面上用的最广的java工具和产品都不是sun的，是ibm和apache的。
－－－－－－－－呵呵，老是把他们混为一谈，大概潜意识里我把他们看成一伙的了。
你是用c++的，如果你写编译器和jvm，你是在装载时扫描一次呢，还是每用到一个类库就扫描一次呢？-----------不知道jvm怎么实现的。不过如果考虑到类库可能很多，内存里根本放不下，我想不大可能只扫描一次，也许可以参考dll的做法，cache加上扫描，不知道是不是这样。
关于命令行，咱们讨论的是开发，不是使用。我给最终用户如果是java的，我会最好快捷方式或者启动用的shell脚本。--------------给用户用的产品和你说的基本差不多，因为到目前为止我公司的UNIX用户还没有用户界面的需求（网页方式的界面需求倒是有的）。至于开发时候的命令行，有时候也不够方便的，至少公司里的java程序员也都是在Windows下用ultraedit或者eclipse开发linux下用的程序，开发的运行环境和测试环境也都在linux下。毕竟windows下要查个资料什么的都比linux下方便。有时候是不是方便对产品的推广影响太大了。java因为去掉了很多繁杂的东东，所以用了比C++短得多得时间，用户数量就达到了相当得水平。当年html规格出台得时候，制定规格的人员也没有想到会短时间红遍全世界，以至于后来xml都几乎推广不起来了(好像热倒满热，真正应用的倒少)。
Glade ......没想到你连看都不看就开始批判..........如果真是好东西，我才愿意学，主要是要费很多时间的。当年java出台的时候，我就没有去跟着学，C#出笼了，我也没有跟着去学。我好像不是喝头口水的人，所以发不了财:-)。我大概95年开始学C++，96年VC热，我没有去学，仍然用BC，99年我才开始用VC。大学毕业的时候是96年，那时候最擅长的是编程，却跑去搞建筑搞了若干年，然后才转到计算机开发，感觉人生都倒过来了。也许俺该改改吧？
......而在c++版就没有设计模式，并不是c++不用，而是c++程序员能达到熟练运用语言就已经很不容易了........你说的对，不过不能说C++没有设计模式。俺正想骂C++程序员呢:-(，不过既然在这儿，就骂java程序员吧。不错，在java程序员中最常听到的是模式、模式、模式。可是除了使用j2ee提供的几个设计模式，很多java程序员好像就不会在自己的程序中应用模式了。我看到的很多java代码......倒还真不少，约10来万行，很多代码模块都长达千行，有时候单个函数就有3、4百行。大多数类的方法是static的，这是用java来设计面向过程的代码？即使有经验的C程序员，他们开发的代码大都也是5、6十行代码一个函数，（不过整个文件的长度达千行的倒是很多的）。还有最近在学SWT，看了一个fileviewer的代码（org.eclipse.examples.fileviewer），好像是ibm的程序员编写的。我觉得这个例子的代码就很糟糕的。和http://www-900.ibm.com/developerWorks/cn/linux/opensource/os-ecgui1/index_eng.shtml中的例子相比，简直就差远了。
不过骂归骂，千万别说“你写个给俺看看”，自己没这水平，没底气.....不过我的代码中一个方法一般不超过100行，一个文件一般不超过200行，这个还是有底气的。我想说的是，模式、模块化都很重要的，如果真学好了，不至于写的这么长。如果真的想学好模式，可以看看自己的代码，如果哪个文件太长了，哪个函数太长了，是不是可以拆解一下，模式什么的也就不自觉的学到手了。
这种new和delete都封装在类中，当在使用该类的时候，不再需要new和delete了－－－－这个嘛，我是指大多数时候是在栈上分配的。我最初写代码的时候new用的很多，可是这种认为内存取之不尽的观点很不好，有可能内存过度分配，一个程序处理个百把兆文件，就占用了几十兆内存的，不算好程序。好像看到过的内存处理最好的代码是Berkeley DB的代码，好像可以利用平台的映射文件，然后把它当作内存来进行分配，而且还有如果分配失败了，会释放掉其他不用的部分，然后再次尝试......不过我没看多少，所以说不上多少。

真是无聊呀！
我发现中国的程序员对于语言这个东西怎么这么看重呀?
是Java好还是C++好,这样的讨论我已经看过n回了,讨论来讨论去有什么意义吗?
语言,他终究是个工具。不论什么语言，都是一样的，都是为实现功能服务的。有什么区别？
为何不能站得更高一点来看问题呢？
中国的软件产业还是刚刚起步呀！还需各位的努力呀！

to: yayv(yayv)
从 C++ 到 Java 属于创新思维
从 Java 到 C# 属于技术剽窃（说的难听了点）

“我看到的很多java代码......倒还真不少，约10来万行，很多代码模块都长达千行，有时候单个函数就有3、4百行。大多数类的方法是static的，这是用java来设计面向过程的代码？即使有经验的C程序员，他们开发的代码大都也是5、6十行代码一个函数，（不过整个文件的长度达千行的倒是很多的）。”
=========================================================
我虽是个新手，我也知道 static 方法的利弊，知道代码块过大的后期麻烦。
我不知道你这“约10来万行”的代码从哪儿来，我觉得这已经不单是“讨伐”Java
语言那么简单了，做出这些代码的家伙连基本的oo思想都不具备。
如果说java程序员里有这类现象，那么 C++ 里就没这类人了？
还有，看代码块是否过于庞大，不能只是看行数。

创新.........代码行.........还有个痴呆男人扔了一堆鸡蛋的.............................算了，我们已经争论的太久，我都累了。只是这一歇，不知道猴年马月才又来扔篇帖子。我上论坛的次数大概是半年一次，比女人的那玩意还来的慢^_^，来聊的都算有缘。

Java也不是新手，但是用在JSP中调用CRYSTAL REPORTS 工作是头一回，以前在。NET中用过，这次死活搞不定。到GOOGLE上搜了几天，也找不到相关的资料，真他们憋气。配置来配置去，连个SAMPLE都RUN不动。简直是怀疑自己。要不是因为JAVA跨平台，早仍它娘的一边。

to: yayv(yayv)
逃避？实在是累了。不过今天又来了点劲。只是今年这次好像特持久.....
哪儿是创新？哪儿又是剽窃？
C++都不能算创新（前面不是有smalltalk吗？好像smalltalk才算鼻祖）。充其量只能算组装。不过就算这些是创新。既然大家都是在前人基础上稍做改进，又如何单单C#戴上剽窃的恶名？
10来万行代码--------这个就不说了，本来已经写了对它漂亮的架构设计（当然首先是torque、Velocity等设计思路不错）和细节问题的评价，只是又删掉了，不想让同单位的同事看出来俺在褒贬他们。
C++里面更多。只是发在java版，所以批java程序员。
看代码块是否过于庞大，不能只是看行数--------这话当然放之四海兼准，只是缺乏点新意了，缺乏点挑起事端的......
肯德基说：we do chicken right.
编程序就应该：一个函数只做一件事；一个模块只做一件事；一个程序只做一件事；当然要做就做好，做不好干脆回家种大白菜。绝不要既做婊子又立牌坊.......^_^，说点粗话。
关于microsoft.....microsoft厉害啊，你看可供程序员利用的编程资料有多少？那msdn...不知道哪家公司能提供这么丰富的资料的,linux能吗？java有吗？我觉得这就是摆地摊的和开商场的之间的区别.......当然linux说，我有原始代码哦....屁，你有代码大部分人也没那闲功夫看!

C++里面更多。只是发在java版，所以批java程序员。
这话当然放之四海兼准，只是缺乏点新意了，缺乏点挑起事端的......
=======================================
大家都看到了，看来不止是技术上，品性方面都偶点问题

to onefox(一品狐):你还真当是吵架了？也难怪，嘲笑人家吃饭的家伙，多少会.....
to eric_chenwei(PDA程序员):用C语言不是挺好！俺大学时汇编可以算一高手，做过反汇编器，破过密码，可惜这么多年过去了，都忘了，什么时候有空了还真想重新捡起汇编呢。

看到深夜，不说几句是对不起楼上大众了。几个月不来了，来了就看到吵架。
java和C++的讨论看过很多了，以前是旗帜鲜明的扔砖头，后来扔累了，发现看热闹更有趣些。楼主的精神实在可佳，身陷曹营，勇往直前。
牢骚可发，但如此不辞辛苦的辩个谁是谁非，又毫无结果，不显得无事生非。贴子再长一倍，还是老样子。既然如此，不如实在些，在下虽然不才，对于楼主的问题，能解决的还是帮着解决。结果就没搜到问题贴，都是牢骚贴。可见楼主是带着有色眼镜看问题的。既然如此，也不好说了。
站的高一些，看的远一些。

我学JAVA的主要目的---就是为了能看懂一些有关软件设计的技术资料.
作为一个OO教学语言----JAVA的确优秀(因为它简洁).
实际工作中用C++,但JAVA的设计思想给;了很大帮助!

to nil2000(我爱北京天安门):^_^，本来就是无事生非
正而八经提个问题:File.listFiles()用起来是很方便的。可是如果某文件夹下文件有几万个，那么每次listFiles都会浪费很多时间。我现在需要有一定的效率，我需要两个方法，第一个方法是要求高效检查一个目录下是否有文件，另一个方法是每次枚举到一个文件，就执行一些其他的操作，是不是可以在FileFilter中抛出异常来实现？代码已经写了，只是暂时还不会去测试，先问问。代码如下：
StopIteratorException.java文件：
package com.util;
public class StopIteratorException extends RuntimeException {
public StopIteratorException() {
}
public StopIteratorException(String message) {
super(message);
}
}
FileUtil.java文件：
package com.util;
import java.io.*;
public class FileUtil {
public static boolean isDirectoryEmpty(File directory) {
try {
directory.listFiles(new FileFilter() {
public boolean accept(File file) {
throw new StopIteratorException();
}
});
return false;
} catch (StopIteratorException ex) {
return true;
}
}
public static void enumDirectory(File directory, FileFilter filter) {
try {
directory.listFiles(filter);
} catch (StopIteratorException ex) {
}
}
}

还有在enumDirectory方法中调用的filter具体编写时如下写：
public class MyFilter implements FileFilter{
public boolean accept(File file){
//如果不继续枚举，则throw StopIteratorException
}
}

还有一个是关于线程的。我需要一个线程，能随时给它任务执行，也能随时停止。但是Thread的stop、pause等均不安全，例如如果一个对象构造了一半，却被stop了，不知道这对象算是完成了还是没完成。所以做了下面一个类：
package com.util;
import java.util.*;
public class SafeThread {
private static Map m = new HashMap();
private Thread thread;
private boolean isPaused;
private boolean isStopped;
private final Object lock = new Object();
public SafeThread() {
thread = null;
}
//开始执行一个任务。
public void start(Runnable job) {
stop();
thread = new Thread(job);
isStopped = false;
isPaused = false;
m.put(thread, this);
thread.start();
}
//恢复执行一个任务
public void resume() {
if (thread == null) {
return;
}
synchronized (lock) {
lock.notifyAll();
isPaused = true;
}
}
//暂停一个任务
public void pause() {
if (thread == null) {
return;
}
synchronized (lock) {
isPaused = false;
}
}
//终止执行一个任务。
public void stop() {
if (thread == null) {
return;
}
resume();
synchronized (lock) {
isStopped = true;
}
try {
thread.join();
} catch (InterruptedException e) {
}
thread = null;
m.remove(thread);
}
public static boolean isTimeToStop() {
SafeThread manager = (SafeThread) m.get(Thread.currentThread());
if (manager == null) {
return false;
}
synchronized (manager.lock) {
if (manager.isPaused) {
try {
manager.lock.wait();
} catch (InterruptedException e) {
}
}
return manager.isStopped;
}
}
}
使用方法如下：
cass Job implements Runnable{
public void run(){
while(!SafeThread.isTimeToStop()){
//do something.
}
}
}
new SafeThread().start(new Job());
.....
new SafeThread().start(new Job());
本来是想不用上面这个类的，因为如果能够把任务分解成需要时间很短的Job的话，那随时new一个Thread去执行也没什么，因为线程很快就停止运行了。可是分解任务比较麻烦，程序结构影响也比较大。而且我根本不知道如何把上面的enumDirectory分解成每次只检查一个文件的任务。
不知道这么做有什么问题，上面的代码中有什么不妥当的地方。什么意见都虚心接受！

楼主,你知道我最崇拜你哪两点吗?
1.就是在被驳的体无完肤之时还能顽强的保持微笑. ^_^
2.适时转移话题.
坚持,坚持住,等JAVA版的高手都懒的理你的时候,你就是这场无聊争论的胜利者了.

呵呵，没做过很多java io的东西。很惊讶File类居然只有internal iterator。
throw exception好像也是没办法的办法了。虽然感觉很别扭。
也许别的库有更好的函数可以用，也许没有。（或许在OS级别就已经决定一次只能读整个目录的信息？）
这个线程的问题，不是很明白。java只支持cooperative的线程交互。正在执行的线程只能是不时检查一下某个标志位，然后在需要停止的时候就停止。但在线程执行任务的时候，你是不能及时终止它的。所以，随时运行当然可以，“随时停止”好像不大可能。你只能把任务拆成若干小段，然后每段的间隔检查标志位。
没有仔细分析你的代码，只看见一个比较明显的bug:
if (manager.isPaused) {
try {
manager.lock.wait();
} catch (InterruptedException e) {
}
}
这个if得换成while的。否则，
synchronized(thread){
thread.resume();
thread.pause();
}
可能就出问题了。我明明resume之后又pause了，但是thread还是被resume了一下。

yayv(yayv) ( )
这种new和delete都封装在类中，当在使用该类的时候，不再需要new和delete了<---这部分我不理解，向您请教，最好给出代码。希望不是类厂。
>>>>>>>>>>>>>>>>>>>>>>
没有用过std::auto_ptr<>吧?STL有auto_ptr, loki有smartptr，还有其他厂商提供适用于各种不同情况的智能指针。auto_ptr被加入C++标准已经有好多年了，希望你不是第一次听到。
它的技术主要基于RAII资源分配即初始化, 也就是在于构造栈上对象的生命期控制堆上构造的对象的生命期.因为在智能指针的内部,存储着堆对象的指针,而且在构析函数中调用delete行为.
智能指针大致的代码是这样的：
template< typename T>
class auto_ptr{
public:
explicit auto_ptr(T* p) { m_PTR = p;}
private:
T* m_PTR;
~auto_ptr() { delete m_PTR; }
};
当然还有其它异常处理，防止隐藏转换以及其它功能函数等等，存在不同智能指针是因为有很多人对它提出更高的要求，比如支持引用记数的设计策略，支持处理多种资源的管理（不要认为它只管内存），线程安全，所有权问题等等。
至少上面的代码可以满足所有类型的小要求：
auto_ptr<int> pInt(new int(0));
//dosomething
auto_ptr<CSomeClass> obj(new CSomeClass());
//dosomething
这样你就不用再显式调用delete了，你也不会为效率付出任何的代价。
我还是认为要为这两者语言作客观一些的评价，最好都对它们有一定的使用经验，否则多少都会有失公允.

java, c,c++无所谓,只是工具而已,最重要的是思想,MONEY.......

重新审查了线程代码，发现错误的地方还真不少。
1.大的方面是每执行一个job都要new一个线程。
2.小的方面是pause和resume中的isPaused设置值错误。

为什么每次来都有这种无聊的争论贴子!!会用C就是牛人吗？每个语言都有自己的生存空间的。用功夫研究点其他的吧！！

强烈支持楼主。。
不好就是不好，我决的bill gates评价java的话很对：“java是不错，但是反对将java当作一种宗教信仰”----

to Cowboy22(西部牛仔) :解释的很精彩。
to lwglucky(才鸟) ：^_^，我们的队伍即使在Java版也不弱啊。
to mem_fox(JAVA狐狸) ：既然反对这种争论，为何不审查一下我给出的代码，看看有什么问题，也让偶心悦诚服的。本来在这种争论的时候亮亮自己的代码实在是件愚蠢的事，因为发现bug或者设计有问题后再臭骂一顿，我还不得不服。更何况每段代码总有需要改进的地方，很难做到一次就设计到位。
下面是改进过后的代码，修改的主要目的是线程不会因为需要执行一个job就被频繁创建和删除。
package com.util;
import java.util.*;
public class SafeThread {
private static Map m = new HashMap();
private Thread thread;
private boolean isPaused;
private final Vector jobs = new Vector();
private final Controller controller = new Controller();
public SafeThread() {
}
/**
* 启动线程执行任务，如果没有任务，则等待通知。
*/
public void start() {
stop();
thread = new Thread(controller);
isPaused = false;
m.put(thread, this);
thread.start();
}
/**
* 添加一个任务。
* @param job 任务
*/
public synchronized void add(Runnable job) {
jobs.add(job);
}
/**
* 删除一个任务。
* @param job 任务
*/
public synchronized void remove(Runnable job) {
jobs.remove(job);
}
public synchronized void removeAll(Runnable job) {
jobs.removeAllElements();
}
/**
* 恢复线程执行
*/
public synchronized void resume() {
if (thread == null) {
return;
}
isPaused = false;
notifyAll();
}
/**
* 暂停执行任务
*/
public synchronized void pause() {
if (thread == null) {
return;
}
isPaused = true;
}
/**
* 停止线程
*/
public void stop() {
Thread temp = null;
synchronized (this) {
if (thread == null) {
return;
}
resume();
temp = thread;
m.remove(thread);
thread = null;
}
try {
temp.join();
} catch (InterruptedException e) {
}
}
/**
* 当前线程是否已经被停止
* @return 返回true则表示当前线程被终止。否则继续执行。
*/
public static boolean isTimeToStop() {
SafeThread manager = (SafeThread) m.get(Thread.currentThread());
if (manager == null) {
return false;
}
synchronized (manager) {
while ((manager.thread != null) && manager.isPaused) {
try {
manager.wait();
} catch (InterruptedException e) {
}
}
return manager.thread == null;
}
}
private class Controller implements Runnable {
public void run() {
Runnable job;
while ((job = get()) != null) {
job.run();
}
}
private Runnable get() {
synchronized (SafeThread.this) {
//如果线程没有被停止，而且当前没有任务，或者被pause了则等待。
while ((thread != null) && ((jobs.size() == 0) || isPaused)) {
try {
SafeThread.this.wait();
} catch (InterruptedException e) {
}
}
if (thread == null) {
return null;
}
return (Runnable) jobs.remove(0);
}
}
}
}

无声!

刚才我听管理员叔叔说，这帖太长了，再这样下去，他们服务器也有危险了，准备强行结帖了，我看大家就说到这儿吧，解散！

to kary(BCBuider回复):
这样的SafeThread也没有什么好牛的,就拿出来现宝.基本功能大部分还可以实现,很多小问题就不说了.
给你看看如何让你的SafeThread死锁.大家要是有兴趣可以用junit运行一下.
========================================================
import junit.framework.TestCase;
public class TestSafeThread extends TestCase {
public TestSafeThread(String name) {super(name);}
public void testDeadLoop() {
SafeThread st = new SafeThread();
DeadLockThread dl = new DeadLockThread(st);
st.add(dl);
st.start();
while(!dl.isOver()) {
try{Thread.sleep(3000);}catch(Exception ex){}
}
st.stop();
}
private class DeadLockThread implements Runnable {
private SafeThread st;
private boolean runOver = false;
public DeadLockThread(SafeThread st) {this.st=st;}
public void run() {
st.start();
runOver = true;
}
public synchronized boolean isOver() {return runOver;}
}
}

仔细看了一下,其实也不能叫做什么死锁,而是可以导致内置Controllor线程不会死掉.
其实这也不是什么,你的线程设计根本就不是并行的,而是所有的job都会顺序被执行,那么当然会被这些恶意的job所破坏.(加上SafeThread也没有有效的保护)
比如可以做一个job,在其run方法中执行: st.add(this); 那么这个job就会不断被运行下去.
再说说刚才的哪个恶意的job:
(1) 第一次调用st.start(): Thread thread = new Thread(controllor);
(2) 使用此thread执行任务,就只有一个任务:DeadLockThread dl;
(3) 运行dl.run()方法,会再次调用st.start();
(4) 调用st.start()时,首先调用st.stop()方法;
(5) 在stop中,调用resume,会设置isPaused=false.并且notifyAll();
(6) 回到stop()方法中,resume之后,使用临时变量temp保存thread引用,将thread引用清空.temp.join(). join的作用是什么?Waits for this thread to die. 但是刚才的线程是不会死掉的.实际上是一个很有意思的问题:线程等待自己死掉之后再退出自己.
(7) 所以程序会被阻塞在这个地方.
造成这个问题的关键在于你的Controllor线程的run()方法,是顺序执行任务的:
while(???) {job.run();} 这里的job.run()纯粹就是一个方法的调用,和线程一点关系都没有.所以你使用Runnable接口,其实换成别的什么你自己定义的接口都是一样的.唯一的线程就是Controllor.那这么写除了给人混淆之外还有什么意思?

下面是我的一个朋友对你的SafeThread如果发生上面恶意攻击的评论,俺一起放上来:
俺们观点一致:你做到了一个很大的线程bug,自己等待自己结束.
======================================================
　　很有趣的程序,呵呵,其实不是死锁,而是自己join自己,也就是自己等待自己结束,也就只能永远等待下去了.
调用的流程：SafeThread.start()->SafeThread.stop()->Controller.start()->DeadLockThread->run()
->SafeThread.start()->SafeThread.stop()->Controller.join()
~~~~~~~~~~~~~~~~~这里会永远等待下去了,因为Controller线程永远也执行不完
另外Controller中启动实现Runnable接口的线程的方式是错误的，直接调用run方法不会启动一个新线程。
还有既然用了Vector，Vector的很多方法已经同步了，所以在SafeThread的方法中不需要再同步。
================================================================
将Controller的run()方法改为下面的写法就可以了，
public void run() {
while ((Runnable job = get()) != null) {
new Thread(job).start(); //这里真正的启动了一个线程，而不会出现自己调用join方法
} //等待自己结束的情况。
}

在五四年代，楼主肯定能身先士卒地在第一排挡子弹，各层住户的回贴都是暗流汹涌啊，服，大一字号的“服”字

你的意见我接受，不过请运行一下下列代码：
try{
Thread.currentThread().join();
}catch(Exception e){
}
java有大bug?

to xiaohaiz(老土进城,两眼通红):
从自己最初的设计意图来说，在内部线程中调用SafeThread的方法并未经过审查，实际上代码根本没有运行过。其次，你可能误会我的意思了，SafeThread第二次修改的目的就是避免创建线程和删除线程。Vector同步的问题，不知道是否确切，我还真不太有把握,其次，如果在private Runnable get()方法中的jobs.size() 和return (Runnable) jobs.remove(0)语句之间如果发生add(job)或者remove(job)的时候，肯定有问题。
thanks u anyway.
将stop修改为：
Thread temp = null;
synchronized (this) {
resume();
temp = thread;
m.remove(thread);
thread = null;
if ((temp == null) || (temp == Thread.currentThread())) {
return;
}
}
try {
temp.join();
} catch (InterruptedException e) {
}

m.remove(thread);加个判断：
if(thread ==null)
m.remove(thread);

public void stop() {
Thread temp = null;
synchronized (this) {
if (thread == null) {
return;
}
resume();
temp = thread;
m.remove(thread);
thread = null;
if (temp == Thread.currentThread()) {
return;
}
}
try {
temp.join();
} catch (InterruptedException e) {
}
}

to kary(BCBuider回复) :
try{
Thread.currentThread().join();
}catch(Exception e){
}
这样的代码你认为是java的bug吗？的确，java可能没有一种保护机制来保证线程自己等待自己的问题。但是从某一个方面来说，这本来就是应该使用java的开发者或者设计师应该去避免出现的问题啊。如果你在某人的代码中看到了这些的代码？你是认为是语言的bug还是开发人员的质量不高？语言本身就不可能为我们解决所有的问题。
所以我们作为开发写代码的人来说，才需要提高我们代码的质量。避免这些错误，难道不是吗？Bertrend Meyer在他的《面向对象软件构造》中第一章就为俺们描述了软件的质量，正确和强壮是最基础的质量因素。之所以回您的帖子和您讨论这个问题，因为俺认为SafeThread本身并不能满足质量强壮的因素。发生意外的情况就会阻塞。这难道是语言的bug?恐怕不是吧，而是没有对代码进行保护。(指的是您修改之前的情况)
另外，照俺个人的观点来看，（纯属个人看法），这个SafeThread设计的不伦不类。
(1) 线程有一个设计的理念，作为独立在进程运行空间中的代码，线程应该自己控制自己。也就是说什么时候结束一个线程应该由它自己来决定。所以这也就是stop方法被deprecate的原因之一。外部终结线程也有很多做法可以采用。最简单的就是为之设置标志。（俺们就不再详细讨论了）。但是您的设计和这个一点关系都没有，实际上只是在顺序地执行一系列的任务，而stop方法实质就只是起到了置一个标志位的作用。（当stop被调用之后，执行完当前的任务就会退出）。所以你的命名容易让人产生误会，另外这样使用Runnable做为任务也会产生误会。俺不知道别人怎么看，但是俺很看重这一点的。就是这一点让俺觉得这个类的设计很怪，有点剑走偏锋的味道。
(2) Vector是否线程安全，俺们看来就不需要讨论了，看看其javadoc或者sourcecode就可以了。另外这个地方其实使用List会更好，毕竟Vector是java1.1的遗留物。想使用同步列表也很容易：List jobs = Collections.synchronizedList(new ArrayList());
(3) 在Controllor中的设计也不能防止某些恶意的攻击，俺之前提到过。比如一个任务完成之后再对此jobs列表中增加自己任务。这样会导致循环一直不断。如果您坚持使用顺序执行的机制，也可以在run()方法中jobs.toArray()的方法来取出所有的任务。可以防止不断的死循环。这只是一种方法并不是最好的方法和必要的方法。

另外还有一个很有意思的问题，可以有这么一些捣乱的攻击。
楼主的SafeThread中有这么一个方法：
public synchronized void remove(Runnable job) {
jobs.remove(job);
}
用于从队列中删除一个指定的任务。
但是如果有人比俺更无聊的话写出下面一个任务：
public class SomeTask implements Runnable {
public void run() {}
public boolean equals(Object obj) {throw new UnsupportedOperationException();}
public int hashCode() {throw new UnsupportedOperationException();}
}
这并不是问题。只是remove方法会抛出异常而已。
值得关注的是下面这种情况，对于队列的同步保护有bug.看看俺的单元测试：
public class TestSafeThread extends TestCase {
public TestSafeThread(String name) {super(name);}
private static int count = 0;
private static synchronized void increaseCount() {count++;}
private static synchronized void clearCount() {count=0;}
protected void setUp() {clearCount();}
protected void tearDown() {clearCount();}
public void testRunNormalTaskOnly() {
SafeThread st = new SafeThread();
st.add(new NormalTask(st));
st.add(new NormalTask(st));
st.add(new NormalTask(st));
st.start();
try {
Thread.sleep(1000);
} catch(InterruptedException ex) {}
assertEquals(3, count);
}
public void testRunBadTaskInQueue() {
SafeThread st = new SafeThread();
st.add(new BadTask(st));
st.add(new NormalTask(st));
st.add(new NormalTask(st));
st.add(new NormalTask(st));
st.start();
try {
Thread.sleep(1000);
} catch(InterruptedException ex) {}
assertEquals(4, count);
}
private abstract class BaseTask implements Runnable {
private SafeThread st = null;
public BaseTask(SafeThread st) {this.st=st;}
public void run() {
TestSafeThread.increaseCount();
doTaskBody();
}
protected SafeThread getSafeThread() {return st;}
protected abstract void doTaskBody();
}
private class BadTask extends BaseTask {
public BadTask(SafeThread st) {super(st);}
protected void doTaskBody() {getSafeThread().removeAll(null);}
}
private class NormalTask extends BaseTask {
public NormalTask(SafeThread st) {super(st);}
protected void doTaskBody() {}
}
}
定义作了一个抽象任务类，每次执行任务都会纪录一个标志位，用来作断言。派生出NormalTask和BadTask两个子类，NormalTask什么也不做，而BadTask在运行的时候则会尝试破坏SafeThread中的任务队列，调用的是发布的removeAll方法。
运行两个测试，第一个testRunNormalTaskOnly()执行完成断言没有问题，三个任务都被执行：assertEquals(3, count);而第二个测试testRunBadTaskInQueue()确发生了问题，俺们在队列中加入了4个任务，执行完之后俺们期望完成4个：assertEquals(4, count);但是其中的BadTask则破坏了俺们的意图：
There was 1 failure:
1) testRunBadTaskInQueue(TestSafeThread)junit.framework.AssertionFailedError: expected:<4> but was:<1>
说明了什么？说明在遍历jobs队列的时候，同步保护有问题。

to: kary(BCBuider回复)
我也是好几天没来看这个帖子了，不是逃避。：）
你说的大类和长方法的确是java的缺点，我也想写的小一点，可怎么也小不了。：（，水平问题吧。而且，我看了你发的其他帖子，知道你只是想借讨论来多学习一些东西，我觉得这个主意不错，：）。
“你写个给俺看看”，这句话我没有挑衅的意思，我真的是没这么用过，真心请教的。你说的这种拆解的方法的却不错，我刚好可以用上。
回复： Cowboy22(西部牛仔)
谢谢，我知道只能指针，只是一直没有适合用的地方，所以一直就没有看。谢谢你详细的讲解。
回复： xiaohaiz(老土进城,两眼通红)
谢谢你对那个线程程序的评论，我最近也在考虑一个类似的执行任务队列的一个线程(不是多线程，是一个线程)，学到了不少东西。谢谢。
to: kary(BCBuider回复)
修改之后应该没问题了，以我的能力看不出来了（我很菜的）。

我转帖我们c++的领袖人物B.S的一段话：
/
我发现在电视和出版物中关于Java的鼓吹是不准确的，而且气势汹汹，让人讨厌。大肆叫嚣凡是非Java的代码都是垃圾，这是对程序员的侮辱；建议把所有的保留代码都用Java重写，这是丧心病狂，既不现实也不负责任。Sun和他的追随者似乎觉得为了对付微软罪恶的“帝国时代”，就必须如此自吹自擂。但是侮辱和欺诈只会把那些喜欢使用不同编程语言的程序员逼到微软阵营里去。
Java并非平台无关，它本身就是平台。跟Windows一样，它也是一个专有的商业平台。也就是说，你可以为Windows/Intel编写代码，也可以为Java/JVM编写代码，在任何一种情况下，你都是在为一个属于某个公司的平台写代码，这些代码都是与该公司的商业利益扯在一起的。当然你可以使用任何一种语言，结合操作系统的机制来编写可供JVM执行的程序，但是JVM之类的东西是强烈地偏向于Java语言的。它一点也不像是通用的、公平的、语言中立的VM/OS。
私下里，我会坚持使用可移植的C++作大部分工作，用不同的语言作余下的工作。
“Java is not platform-independent, it is the platform!”

to xiaohaiz(老土进城,两眼通红) :
代价与质量.....有句话：不要化80%的力气来解决20%的问题。当然我发现换一下顺序就可以解决，所以我改写了。
线程有一个设计的理念，作为独立在进程运行空间中的代码，线程应该自己控制自己，所以这也就是stop方法被deprecate的原因之一。......错了，是否停止正是外界需要的，而不是线程自己需要的。假定我的线程是在复制硬盘，用户按了一个“停止”，我CALL，这硬盘还在复制.......你不觉得这样的程序很烂？
如果没有stop,假定线程正在写硬盘，用户却把程序给关闭了，你的程序要么说“不允许你关闭我”（你有看见IE说这样的话么？），要么蹭的一下关掉了，而根本不管线程正在做什么(IE能立即关闭，可是它会导致系统不稳定么？)。
job顺序执行的问题，我觉得你还是不理解设计意图。客户程序员可以通过多new几个safethread来解决问题。然而如果没有顺序执行的机制，客户程序员会发现除了自己另外编写一个类，却没有机会直接用safethread来执行一个顺序执行的任务。
相信Vector是线程安全的，可是我认为j2sdk设计人员设计根本有问题。考虑一下我的代码里面vector本身是否同步对我一点意义都没有。因为当在线程程序中的时候，通常底层的同步保护没什么用。既然用的少，何必加同步？假如我每段代码都无缘无故加上同步，安全是安全，可是除了低效率，还有什么用？你看看stl里面的任何一个容器，它们是同步的么？
在一般性类的设计上，有句话叫“类的线程安全”。
你要说到恶意攻击......实在是要看场所地点的。我不觉得这种恶意攻击，除了不想使用，还有其他什么目的。要说到攻击，任何东西都是不安全的。为什么java不干脆取消线程，一了百了？
to yayv(yayv):“你写个给俺看看”......这话没说你，呵呵。

补充一句，在线程问题上，过渡的分解任务导致的是烂代码。

这样的代码你认为是java的bug吗？的确，java可能没有一种保护机制来保证线程自己等待自己的问题。但是从某一个方面来说，这本来就是应该使用java的开发者或者设计师应该去避免出现的问题啊。如果你在某人的代码中看到了这些的代码？你是认为是语言的bug还是开发人员的质量不高？语言本身就不可能为我们解决所有的问题。-------呵呵，我也解决不了你的有意无意的错用问题。
有一次我写了一段代码，公司的C++程序员说，我看不懂啊。我说那是你的问题，我的代码书写规范，清晰可靠，符合C++的标准语法，但并不是为初学者准备的。
说这么多，贴一段C++的代码，和上面的类对等。
#ifndef _SAFE_THREAD_HPP
#define _SAFE_THREAD_HPP
#include <boost/thread/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/condition.hpp>
#include <boost/thread/tss.hpp>
#include <boost/bind.hpp>
namespace util{
class Runnable{
public:
virtual void run()=0;
};
class SafeThread
{
public:
SafeThread(){
pthread = new boost::thread(boost::bind(&SafeThread::execute,this));
}
~SafeThread(){
cond.notify_all();
pthread->join();
delete pthread;
}
void add(Runnable *job)
{
scoped_lock lock(mutex);
jobs.push_back(job);
cond.notify_all();
}
bool remove(Runnable *job)
{
scoped_lock lock(mutex);
for(std::list<Runnable * >::iterator it =jobs.begin();
it != jobs.end(); ++it)
{
if(*it == job){
jobs.erase(it);
delete job;
return true;
}
}
return false;
}
void pause()
{
scoped_lock lock(mutex);
ctl.toPause = true;
}
void resume()
{
scoped_lock lock(mutex);
ctl.toPause = false;
}
static bool isTimeToStop()
{
PSafeThread *pp = ptr.get();
if(pp == NULL)
return false;
PSafeThread p = *pp;
scoped_lock lock(p->mutex);
while(!p->ctl.toStop && p->ctl.toPause ){
p->cond.wait(lock);
}
return p->ctl.toStop;
}
private:
struct Controller{
bool toStop;
bool toPause;
Controller():toStop(false),toPause(false){};
} ;
Controller ctl;
boost::thread *pthread;
typedef boost::mutex::scoped_lock scoped_lock;
boost::mutex mutex;
std::list<Runnable *> jobs;
boost::condition cond;
typedef SafeThread *PSafeThread;
static boost::thread_specific_ptr<PSafeThread> ptr;
void execute(){
ptr.reset(new PSafeThread(this));
Runnable *job;
while( (job = getJob()) != NULL ){
job->run();
delete job;
}
}
Runnable* getJob(){
scoped_lock lock(mutex);
while(!ctl.toStop && (ctl.toPause || jobs.size()<=0)){
cond.wait(lock);
}
if(!ctl.toStop){
Runnable *job = jobs.front();
jobs.pop_front();
return job;
}
return NULL;
}
};
}
#endif

恩，确实是和那段java代码完全一样的。看来 kary(BCBuider回复) 是直接翻译成java代码的。
我刚开始接触Java的时候也是拿它当做解释执行的小巧的C++来用，可是使用过程中发现完全不是那么回事，java就是java，仅仅是语法和C++有点像，毕竟是不同的语言。
现在 kary(BCBuider回复) 的这段代码风格和java真像，不过我想他真正的代码是定义和实现是分开的，那样看来会更清晰，至少我是这么认为的。
我真的很羡慕java有的这么一套通用的类库，虽然c++有stl但还是显得太少了。

呵呵。难得看到这么喜欢帮助debug的好人。
我这里有一个以前写的线程池的库。帮助回收执行完任务的线程的。
不知道能否请xiaohaiz给费心挑挑错？谢了！
http://prdownloads.sourceforge.net/worker/worker_pool.zip?download

呵呵，虽然我现在是一个JAVA程序员了。
但平心而论，
论编程功力，JAVA程序员比C/C++程序员差的很远（特别是CSDN这个论坛里的）。

imkary,
the zip file has a javadoc zip.
Also, it has a Test.java which shows normal usage of the lib.
Basically, it allows you to create a thread pool object, (you can customize the pooling strategy). You can request a thread from the pool, assign it a task. after the task is done, the thread will return to the pool automatically and become available to other requests.

mark
我以前在学校用VC编小程序玩
现在刚到公司用java（以前很排斥）
才不到两个月我就喜欢上java了
其实我个人主要的原因还是因为用intellij idea比较爽
使用起来太爽了，确实也可以保证每次编译的时候肯定不会有错误
~~~~~

不是有JBuilder吗？我CALL，我用JBuilder建个程序看看，一堆怪异的代码在那儿，吓死我。
_________________________________________________________________________________
楼主，自己不懂JAVA，不要怪JBuilder！！！呵呵。。。。我也是低手，但能看懂JBUILDER生成的代码，呵呵。。。

唉，
不好好学好一个东西就乱发什么评论，
单说ECLIPSE
功能的强大不是你能想象哦。
楼主实在没有什么发言权，就知道胡搅蛮缠，
我要告诉你，我现在都已经忘了怎么设CLASSPATH了，
你还在讨论你的CLASSPATH怎么怎么长，不知道真正利用好工具，
明明有打火机，非要钻木取火，不就为了抽根烟嘛。
真是服了。
用不好就到处讨教讨教，有什么牢骚好发的？

还有一种人是就懂一点，什么c++,java啦。井底之蛙，就觉得自己懂那点东西是真理，其它的这也不行，那也不行。别人一对他懂得那点东西表示意见，立刻就跳出来破口大骂。:)

白痴是没药医的
白痴是没药医的
白痴是没药医的
我不想骂人，但有对于白痴，我无可奈何
速度慢，难道你是用JAVA来代替C的工作？？
IDE烂，有种你自己写一个啊？（对语言一知半解，却希望有个万能的IDE来掩饰自己无能的家伙）
不懂就不要狂吠

楼主就是一个希望什么都不用做，有个万能的IDE，然后楼主说“给我做个ERP出来”，那个IDE就唰唰唰，一个ERP出来了，什么classpath，什么流呀的，什么资源呀，都一边去，不烦吧，嘿嘿

我用c/c++很长时间，现在刚开始用java。开始觉得java很不习惯。
1因为习惯了new,delete。对java没有构西函数很费解。java又提供了finalize，是不是对其gc信心不足呢？到现在还在疑惑。
2对java把定义和实现放在一起很不习惯。比如我只要看看定义，还需要用javadoc，有点烦，直接看h文件比较爽一点。
3不能重载操作符有点麻烦，不能用==,=,+
不过java比c＋＋也有强的地方，语言相对简单，不过什么规范太多，jini,jmx,j2ee，弄的我一愣愣的。但总是比在c＋＋的时候自己写socket简单一点，这点老板高兴，降低了成本。可是我好像没有成就感了，呵呵。
自从用了eclipse，觉得很不错，速度很快，界面也不错。不过我的电脑是1G内存，PiV2.4G的，之前跑jb速度也还马马虎虎。

楼主的c++水平怎么样,面象对象的思想学的怎么样?知道虚函数为什么存在?知道纯金虚函数为什么存在?知道要面向接口编成,不要面向实现编成吗?
语言不重要,思想才重要.语言不重要,关键看你你的水平

既然你不喜欢用，那就不要用了，没有人逼你用了，讲这么多废话，现在做JAVA的程序员已经超过C++了，只要去人才市场看看就知道了，比例很大的，我以前就是在人才网站做的

楼主说话界乎有道理/没道理之间

少些争论,多做些事吧!
这可能是当今中国程序员的通病吧!不喜欢一样东西,一定非将它说得体无完肤才行!我们何进才能有一颗平常的、宽容的心呢？

JAVA就是一堆垃圾，
不过为了生存天天得用啊，

虽然缺点不少，但是JAVA方面的公司多啊。
不就是一个工具吗？如果不想用就卡喳一声拎断JAVA的脖了。
我原来也不用JAVA，直接就面试上了，真是倒侮......
-----------------------------------
你是卖方，有买方就行，关键是你行不行....

java和c++好比一巨型肥男和一家庭主妇。
让肥男去穿针线那是有劲没处使，迟早累死。
让主妇去玩象扑那是想使劲都没有，迟早送死。
各干各的，多好

各种语言有其自身的优点
要不然出了那么多语言干什么呀
都学JAVA或C++就OK了呗
JAVA跨平台
C++操作硬件好

java和c++好比一巨型肥男和一家庭主妇。
让肥男去穿针线那是有劲没处使，迟早累死。
让主妇去玩象扑那是想使劲都没有，迟早送死。
各干各的，多好
说的好

其实Java和c++本来就是两个领域的事情,Java主要是服务器端的应用,而c++主要是桌面系统的应用,而且这种格局短时间不会改变,就这样,很简单!!!!!!!!!!

c++程序员:"我的孩子需要一个空间，我已经给他了，不用你管！"
系统:"...." (无语)
c++程序员:"我的孩子不需要这个空间了，我把孩子杀掉了，不用你管"
系统:"...md,简直不当我存在，--该内存地址为只读..--"(郁闷过度)
c++程序员:"靠你丫的，跟我死嗑是不是"
----
开个玩笑.嘎

c++程序员:"我的孩子需要一个空间，我已经给他了，不用你管！"
系统:"...." (无语)
c++程序员:"我的孩子不需要这个空间了，我把孩子杀掉了，不用你管"
系统:"...md,简直不当我存在，--该内存地址为只读..--"(郁闷过度)
c++程序员:"靠你丫的，跟我死嗑是不是"
----
==================================
哈哈，有意思

先说一句，我对Java可能没有什么发言权，最近因为需要才在研究Java，但C++我用了7年，VC我用了4年，因此，在我下面的发言中，我只对我在C++方面的发言负责（只是负责讨论而已，别想多了^_^）.
Java与C++，我的最爱当然是C++。啊，无所不能的C++啊，我爱你，只是这些年你也没少累我。Java 很不错，至少它的很多应用用C++来做，累死人，我才不干呢，谁愿做谁做去。有了开发任务，我才不管Java 还是 C++，谁方便谁省力谁上。
我目前只希望以下几点：
Java:
template -- 我要template，虽然大家都是Object，但我不想总去花精力辨别谁是谁。
Speed -- 速度快一点啊，快一点啊，我等得好心急
C++ :
Platform --- 谁来帮帮我，我我程序想到其它平台上去跑步(Run)
=======================================
to Schlemiel(维特根斯坦的扇子)
不同意你的一句“玩具应用”：什么叫玩具应用，什么叫企业应用，只不过是规模的差距而已，在大众对电脑实际应用中，你所谓的“玩具应用”确是用得最广泛的，接触最多的。有多少用电脑的人每天在与企业应用打交道呢？可我保证它们只要用电脑就在接触“玩具应用”。
所以，请不要乱说什么“玩具应用”。
===============
to ....
"内存管理对于熟练的C++程序员，算是最简单的问题了？？" 这句我也不同意，我想我绝对算得上是熟练的C++程序员，但我不会说内存管理很简单，我只能说：它没想象得那么复杂，从汇编语言角度来看只不过是地址而已，管好它不难；如果你用C++写过几万行代码以上的程序的话，我相信你的程序一定会遇到内存管理的问题。

这个帖子怎么还存在呢？
JAVA主要是为网络而设计的（主要在于其平台无关性、网络移动性和安全性的设计），但是它的应用却也不局限在网络。作为一种编程语言，Java也可以充分利用很多软件技术：
(1) 面向对象；
(2) 多线程；
(3) 结构化错误处理；
(4) 垃圾收集；
(5) 动态连接；
(6) 动态扩展；
Java只是使用一种新的方法把已经在其他语言中得到验证的概念和技术组合在一起。使之成为强有力的工具，可以应用在多个领域。
Java自身也有其优缺点，其最引人注目的原因是它能够提高开发者的效率，它最主要的缺点在于执行的速度。
面向对象技术承诺提高代码的重用率，这个因素使得Java较之过程语言更具吸引力，但是也不意味Java比C++更有价值。
不过，和C++比较，Java还是有一些可以提高开发效率的十分重要的差别：来源于Java对直接内存操作的约束。
(1) 没有使用强制转换指针类型或者通过指针运算直接访问内存的方法；
Java运行时强制严格的类型限制，根本无法以可能导致内存冲突的方式直接管理内存，因此，Java程序中不会出现哪些常使C++程序员降低效率的特定的BUG。
(2) 垃圾收集避免无意破坏内存；
C++项目的大小和复杂性逐渐上升的时候，决定哪一个对象应该被释放或者判断一个对象是否已经释放的难度也随之上升（可能你做的到，但是这是一个概率，不是所有的C++程序员都能做到）。忘记释放可以导致内存泄漏(LEAK)，多次释放可能导致内存冲突。这两种情况都可能导致程序崩溃。而Java不用在内存冲突的问题上纠缠，所以开发效率会更高。
(3) 数组边界检查保护内存完整性；
数据越界可能导致的结果是内存冲突，而在Java中，数组已经发展为完备的对象，每次使用都会检查边界，避免了这个问题。
(4) 总是对对象引用检查保证程序的健壮；
在C++中，使用空指针通常会导致程序崩溃，而在Java中，只是一个NullPointerException。
但是，Java为了达到这样的面向网络的体系结构，同样也付出了相当的代价，主要集中在这几个方面：
(1) 性能问题，Java执行的速度较之C++较低，这也是其为面向网络特性上付出的最主要的代价。
尽管使用Java，程序的速度是令人担忧的事情，但是也有可多方法可以弥补。适当地开发，发布和执行java程序的各种技巧，大多数情况还是能够取得令终端用户满意的速度。只要能成功地解决速度问题，就能够使用Java语言并且认识到它的好处：提高开发的效率，增强健壮性。
(2) 另一个付出的代价是在内存管理和线程调度上的缺陷。
垃圾收集是不确定的，无法确认垃圾收集什么时候执行，无法确认是否开始收集，无法确认持续收集时间。vmspec中关于线程调度的地方也非常笼统，对线程行为的松散规范是为了利于将jvm移植到不同的硬件平台，但是这也使得java程序员无法了解应该如何调度线程，无法控制线程的调度。
(3) Java为了实现平台无关性，也同样付出了代价，最小公分母问题。
如何抉择不同操作系统的共性和特性，这个问题折磨着平台无关性API的设计者。
（以前和别人解释过这个问题，大家有兴趣可以看看，使用JavaAPI无法得到一个文件最后被修改时间。:) 这好像是一个很简单的问题，但是偏偏就是没有这个API，因为并不是所有的操作系统都能支持这个时间戳的获取）
(4) 还付出一个代价，和窃取知识产权相关。
Java Class 文件和java是紧密相关的(Java动态连接特性)。Class文件中包含引用的类名，方法描述，参数数量类型等信息。一个class文件的符号信息，以及字节码指令set和java密切相关，使得把class逆向成为java源码相对容易。为知识产权被轻易窃取提供了方便之门。
BTW, 混淆器来解决这个问题。
总体来说，Java是一种通用的语言，与其他技术相比有明显的优势，特别是，java能在极大程度上提高开发者的效率，增强健壮性。与C/C++相比，具有“过得去”的性能。java的意义在于为网络为中心的计算环境提供了一种工具。Bill Venners如是说。

其实问题不是在语言本身的上面，而在于人的上面，每种语言从它一出生就会面临不同的挑战，选择语言其实根本就不算什么问题，当你到一个层次上，就会发现语言只不过是一种利用的工具，最重要的是一种解决问题的思路，只要思路正确，用什么语言都一样，学一种语言发不了什么时间，我觉得我们最重要的是要把数学，英语，算法,人工智能等东西学好。

有用IntelliJIDEA的吗？JAVA确实不错，它的发展并不会因某些个人的批判而止步。有各种声音，也正是有人关注的原因。

我看楼主指出java的缺点，不代表他不用java不爱java, 恐怕是恨铁不成钢吧。
C++的缺点恐怕也是C++大师们先提出的。
C++/JAVA语言本身各有优缺点。比较喜欢"聪明的一猪"的说法，殊途同归，侧重点不同，实现不同而已。
JAVA很年轻/C++也很年轻, 语言规范将来肯定会有发展变化和完善。
JAVA也不仅是语言。平台？
Java是平台，实现了不同操作系统的跨平台，所谓:Write once, run anywhere.
可.NET也是个

刚注册好帐号直奔Java版就碰到个这么精彩的话题不知楼主何来发此贴的想法是因为java受了什么打击？？pf Storm999 说的很好哦很多东西偶都没有来得及去想受益匪浅

用自己的长处去比较对方的短处是这类文章共同的手段和特点。　要知道存在就有道理!!

"臭名昭著的Java”

悦读