随笔档案(496)

import java.sql.*;
import java.util.*;

class Sql
{
     public static void main(String[] args)
{
      try
     {
         String query="select * from orders";
         String URL="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=Northwind";
         String userName = "sa";
         String userPwd = "14579";
         Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");
         Connection conn=DriverManager.getConnection(URL,userName,userPwd);
         Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
         ResultSet rs=stmt.executeQuery(query);

         int i=0;
         for(i=0;i<10;i++)
         {
            rs.next();
            System.out.println(rs.getString(1));
         }
        //SQLServer2K自带的样例数据库Northwind中，表Orders有多于10条，可能上百条记录，所以只列10条！
      }
      catch(Exception e)
      {
         System.out.println(e.getMessage());
      }
}
}

结果:

运行本程序前需安装SQL Server 2000 Driver for JDBC Service Pack 3

测试代码如下:

// 导入Java SQL包，连接数据库必需；
import java.sql.*;

public class TestDB
{
    public static void main(String[] args)
    {
        String driverName = "com.microsoft.jdbc.sqlserver.SQLServerDriver";
        String dbURL = "jdbc:microsoft:sqlserver://localhost:1433; DatabaseName=pubs";
        String userName = "sa";
        String userPwd = "14579";
        Connection dbConn;

        try
        {
            Class.forName(driverName);
            dbConn = DriverManager.getConnection(dbURL, userName, userPwd);
            System.out.println("Connection Successful!");
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}

运行结果:

          经过数年的“框架大战”，Java界的各种框架找到了自己应有的位置。

         Spring+Hibernate+Struts已成为Java开发的主流体系。在这个体系中，Spring+Hibernate的地位应该说短期内是难以撼动了。除了新兴的Jboss Seam作为挑战者之外，几乎难有劲敌。有趣的是当初Spring、Hibernate作为挑战者，将官方的EJB成功挑落马下；这次反倒是官方的EBJ3成了挑战者，不知结局如何。

         Java B/S编程中历来战火最激烈的其实还在Web层，框架的数量最多，争议最大。
一切由Struts而起，而Struts最终也坐稳了第一个时代的王座。在技术层面，Struts 1.x已经被无数人抱怨过、批评过，但终于还是稳坐王位，这充分说明了习惯的力量。“稳定压倒一切”，这句话在IT技术领域仍旧适用。
         其实IT应用技术，什么新鲜玩意并不难学。难的是标准化和规范化。每个程序员都有自己的思路和习惯，写出来的代码自然是五花八门。Java何以成为编程界的老大，很重要的一点在于Java的规范化。这种规范化很高的语言适用于多人合作的大型项目，便于沟通和理解，也就便于集成和维护。Java世界为什么会框架横飞，说到底还是规范化的需要。纯JSP和Struts写Web谁快，摆明了是JSP。那撑饱了用Struts？原因在于100个人写出来的JSP，有100种写法；而100个人写出来的Struts，基本相似。Struts之成功，正缘于其在Java Web层的规范化方面所做出的贡献。

         然而长江后浪推前浪，Struts 1.x的技术缺陷毕竟是隐患。
         Sun力推JSF，打算一雪Web层框架缺失之耻。可惜JSF既要沿用Swing的技术路线，又要学ASP.NET，还要照顾产商的IDE，结果搞了个四不象，弄得里外不是人。当然Sun的技术实力毕竟是超强的，只要别重蹈EJB的覆辙，拿出点专断的精神（像这两年的NetBeans），做出像Swing那样水准的东西，JSF当大有作为。JSF现在比较有优势的是对Ajax的集成，这一点走在了其他框架的前面。

         而Struts就更没有志气了，把WebWork换了个标签，凑出个Struts2，Bug多多。说实在话，根本不如原版的WebWork。如果不是靠了原先的fans捧场，根本就没得混。不过Struts原本就不是以技术取胜的，靠的是抢占先机带来的习惯优势。如果原先的fans们在这两年内都能转到Struts2，那么Struts二世仍将雄霸天下。

         综上所述，未来两年，JSF与Struts将展开Java Web框架的最终战争。
         以笔者愚见，结局有二：一是不论Struts还是JSF获胜，Java Web层都将结束混战的局面，这对Java Web开发的标准化是非常有利的，并有助于巩固Java在B/S界的地位；二是Struts1.x、Struts2、JSF三分天下，必然从整体上削弱Java在B/S界的竞争力，并将进一步被RoR、ASP.NET、PHP所蚕食。

         以上内容源自CSDN

          2007年5月8日,Sun推出了一种更友好的为消费电子产品编写Java应用软件的方式，其目的是为了挖掘Java的潜力，并在新一代Web应用领域方面拥有更大的发言权。

         在JavaOne会议上，Sun负责软件业务的执行副总裁格林公布了JavaFX Script━━一种用于编写能够在支持Java的PC和手机上运行的应用软件的更简单的脚本语言。

         为了解决手机的兼容性问题，格林详细阐述了JavaFX Mobile━━一种面向手机厂商、提高Java应用软件在不同手机间兼容性的软件包。

         Sun官员还计划发布最后一部分的开放源代码的Java，并阐述与Java相关的开放源代码项目的管理规则。

         Sun计划通过JavaFX Script复兴Java在小型设备和浏览器上的使用。格林说，Java不仅仅面向企业，还面向消费者。我们即将发布的脚本语言将极大地增加能够为这一平台开发内容的人的数量。

         JavaFX Script是一种在生产效率和易用性方面好于Java的脚本语言，能够与Java紧密集成。开发人员可以利用JavaFX Script编写能够在支持Java的PC和手机上运行的应用软件。

GMail Remote Command 可以远程实现关机、运行程序、打开网页，这一切都通过Gmail来实现的。
GMail Remote Command 使用说明：
1.在你想要控制的机器上面，点击运行GRC.exe；
2.输入你的Gmail邮箱和密码(假设Gmail邮箱是test@gmail.com)，点击Sign in，等待….当Sign in变成

Stop时候就OK了，一般几秒就登录成功了；
3.在另外一台机器打开网页进入：http://www.gmail.com，用另外一个Gmai帐号登陆，然后写邮件；
收件人：test@gmail.com 主题:shutdown
然后发送这个空邮件，即可让test@gmail.com的整个机器关机。
命令：
关机 shutdown
运行程序 [open]c:＼windows＼system32＼calc.exe[/open]
打开网页 [open]http://www.yangkui.cn[/open]

JAVA四种基本排序,包括冒泡法,插入法,选择法,SHELL排序法.其中选择法是冒泡法的改进,SHELL排序法是 插入法的改进.所以从根本上来说可以归纳为两种不同的排序方法:即:插入法＆冒泡法

一 插入法:遍历排序集合，每到一个元素时，都要将这个元素与所有它之前的元素遍历比较一遍，让符合排序顺序的元素挨个移动到当前范围内它最应该出现的位置。交换是相邻遍历移动，双重循环控制实现.这种排序法属于地头蛇类型,在我的地牌上我要把所有的东西按一定的顺序规整,过来一个,规整一个.
处理代码如下:
public void sort(int[] data) {
int temp;
for(int i=1; i〈data.length; i++){
for(int j=i; (j〉0)&&(data[j]〉data[j-1]); j--){

temp=date[j];
data[j]=data[j-1];
data[j-1]=temp; }
}
}
二冒泡法:比较容易，它的内层循环保证遍历一次后，集合中最小（大）元素出现在它的正确位置，下一次就是次小元素。。。该方法在集合分布的各种情况下交换移动的次数基本不变，属于最慢的一种排序。实现也是双重循环控制。这种排序法属于过江龙,就是要找到极端,但是过奖龙也有大哥,二哥等,所以他们只能是大哥挑了二哥挑.
处理代码如下:
public static int [] maopao(int[] data) {
int temp;
for(int i=0; i〈data.length-1; i++){
for(int j=i+1; j〈data.length; j++){
if(data[i]〈data[j]){
temp=data[i];
data[i]=data[j];
data[j]=temp;
}
}
}

return data;

三选择法:该方法只是通过遍历集合记录最小（大）元素的位置，一次遍历完后，再进行交换位置操作，类似冒泡，但在比较过程中，不进行交换操作，只记录元素位置。一次遍历只进行一次交换操作。这个对与交换次序比较费时的元素比较适合。这种排序法比冒泡法要城府要深的多,我先记住极端数据,待遍历数据完了之后,我再处理,不像冒泡法那样只要比自己极端一点的就要处理,选择法只处理本身范围内的最极端数据.
public static void xuanze(int[] data) {
int temp;
for (int i = 0; i 〈 data.length; i++) {
int lowIndex = i;
for (int j = data.length - 1; j 〉 i; j--) {
if (data[j] 〉 data[lowIndex]) {
lowIndex = j;
}
}
temp=data[i];
data[i]=data[lowIndex];
data[lowIndex]=temp;
}
}
四 Shell排序：
它是对插入排序的一种改进，是考虑将集合元素按照一定的基数划分成组去排序，让每一组在局部范围内先排成基本有序，最后在进行一次所有元素的插入排序。
public void sort(int[] data) {
for(int i=data.length/2; i〉2; i/=2){
for(int j=0; j〈i; j++){
insertSort(data,j,i);
}
}
insertSort(data,0,1);
}

private void insertSort(int[] data, int start, int inc) {
int temp;
for(int i=start+inc; i〈data.length; i+=inc){
for(int j=i; (j〉=inc)&&(data[j]〈data[j-inc]); j-=inc){
temp=data[j];
data[j]=data[j-inc]
data[j-inc]=temp;
}
}
}

详情见

http://baike.baidu.com/view/8240.htm

2006 年底，Sun 公司发布了 Java Standard Edition 6（Java SE 6）的最终正式版，代号 Mustang（野马）。跟 Tiger（Java SE 5）相比，Mustang 在性能方面有了不错的提升。与 Tiger 在 API 库方面的大幅度加强相比，虽然 Mustang 在 API 库方面的新特性显得不太多，但是也提供了许多实用和方便的功能：在脚本，WebService，XML，编译器 API，数据库，JMX，网络和 Instrumentation 方面都有不错的新特性和功能加强。 本系列 文章主要介绍 Java SE 6 在 API 库方面的部分新特性，通过一些例子和讲解，帮助开发者在编程实践当中更好的运用 Java SE 6，提高开发效率。

Instrumentation 简介

利用 Java 代码，即 java.lang.instrument 做动态 Instrumentation 是 Java SE 5 的新特性，它把 Java 的 instrument 功能从本地代码中解放出来，使之可以用 Java 代码的方式解决问题。使用 Instrumentation，开发者可以构建一个独立于应用程序的代理程序（Agent），用来监测和协助运行在 JVM 上的程序，甚至能够替换和修改某些类的定义。有了这样的功能，开发者就可以实现更为灵活的运行时虚拟机监控和 Java 类操作了，这样的特性实际上提供了一种虚拟机级别支持的 AOP 实现方式，使得开发者无需对 JDK 做任何升级和改动，就可以实现某些 AOP 的功能了。

在 Java SE 6 里面，instrumentation 包被赋予了更强大的功能：启动后的 instrument、本地代码（native code）instrument，以及动态改变 classpath 等等。这些改变，意味着 Java 具有了更强的动态控制、解释能力，它使得 Java 语言变得更加灵活多变。

在 Java SE6 里面，最大的改变使运行时的 Instrumentation 成为可能。在 Java SE 5 中，Instrument 要求在运行前利用命令行参数或者系统参数来设置代理类，在实际的运行之中，虚拟机在初始化之时（在绝大多数的 Java 类库被载入之前），instrumentation 的设置已经启动，并在虚拟机中设置了回调函数，检测特定类的加载情况，并完成实际工作。但是在实际的很多的情况下，我们没有办法在虚拟机启动之时就为其设定代理，这样实际上限制了 instrument 的应用。而 Java SE 6 的新特性改变了这种情况，通过 Java Tool API 中的 attach 方式，我们可以很方便地在运行过程中动态地设置加载代理类，以达到 instrumentation 的目的。

另外，对 native 的 Instrumentation 也是 Java SE 6 的一个崭新的功能，这使以前无法完成的功能 —— 对 native 接口的 instrumentation 可以在 Java SE 6 中，通过一个或者一系列的 prefix 添加而得以完成。

最后，Java SE 6 里的 Instrumentation 也增加了动态添加 class path 的功能。所有这些新的功能，都使得 instrument 包的功能更加丰富，从而使 Java 语言本身更加强大。

Instrumentation 的基本功能和用法

“java.lang.instrument”包的具体实现，依赖于 JVMTI。JVMTI（Java Virtual Machine Tool Interface）是一套由 Java 虚拟机提供的，为 JVM 相关的工具提供的本地编程接口集合。JVMTI 是从 Java SE 5 开始引入，整合和取代了以前使用的 Java Virtual Machine Profiler Interface (JVMPI) 和 the Java Virtual Machine Debug Interface (JVMDI)，而在 Java SE 6 中，JVMPI 和 JVMDI 已经消失了。JVMTI 提供了一套”代理”程序机制，可以支持第三方工具程序以代理的方式连接和访问 JVM，并利用 JVMTI 提供的丰富的编程接口，完成很多跟 JVM 相关的功能。事实上，java.lang.instrument 包的实现，也就是基于这种机制的：在 Instrumentation 的实现当中，存在一个 JVMTI 的代理程序，通过调用 JVMTI 当中 Java 类相关的函数来完成 Java 类的动态操作。除开 Instrumentation 功能外，JVMTI 还在虚拟机内存管理，线程控制，方法和变量操作等等方面提供了大量有价值的函数。关于 JVMTI 的详细信息，请参考 Java SE 6 文档（请参见 参考资源）当中的介绍。

Instrumentation 的最大作用，就是类定义动态改变和操作。在 Java SE 5 及其后续版本当中，开发者可以在一个普通 Java 程序（带有 main 函数的 Java 类）运行时，通过 –javaagent 参数指定一个特定的 jar 文件（包含 Instrumentation 代理）来启动 Instrumentation 的代理程序。

import java.util.*;

public class File extends java.io.File {
    

     File(java.io.File file,String str){
         super(file,str);
     }
     File(String str1,String str2){
         super(str1,str2);
     }
     File(String str){
         super(str);
     }
     File(java.net.URI uri){
         super(uri);
     }
     public static void deleteDirs(java.io.File dir)throws Exception{
         m_root=dir;
         m_dirs= new ArrayList();
         if(!m_root.isDirectory()){
             throw new Exception("Exception:\""+m_root.toString()+"\" is not a director");
         }
         else{
             for(int i=0;i<m_dirs.size();i++){
                 System.out.println(((File)m_dirs.get(i)).toString());
             }
             //delete all director
             try{
                 m_dirs.add(m_root);
                 myDelete();
             }
             catch(Exception e){
                 e.printStackTrace();
             }   
         }   
     }
     /**
      *
      * @param dirPath   String a director file path;
      * @throws IOException if dirPath is not a director file path
      */
     public static void deleteDirs(String dirPath)throws Exception{
         m_root=new java.io.File(dirPath);
         deleteDirs(m_root);
     }
    
     public static void deleteSubDirs(String dirPath)throws Exception{
         m_root=new java.io.File(dirPath);
         deleteSubDirs(m_root);    
     }
    
    
     public static void deleteSubDirs(java.io.File dir)throws Exception{
         m_root=dir;
         m_dirs= new ArrayList();
         //deleteDirs(m_root);
         if(!m_root.isDirectory()){
             throw new Exception("Exception:\""+m_root.toString()+"\" is not a director");
         }
        
         else{
             for(int i=0;i<m_dirs.size();i++){
                 System.out.println(((File)m_dirs.get(i)).toString());
             }
             try{
                 myDelete();
            }
            catch(Exception e){
                    e.printStackTrace();
            }
            }    
     }
     /*
      *   visit all a director and save them in a list
      */
     private static void visitAll(java.io.File tempRoot){
         //m_dirs.add(tempRoot);
         //System.out.println("函数开始处："+m_dirs.size());
        
         java.io.File[] dirs=tempRoot.listFiles();
         if(dirs!=null){
        
         List dirsList=Arrays.asList(dirs);
         //while(dirsList!=null){
             if(dirsList==null){
                 try{
                     tempRoot.delete();
                 }
                 catch(Exception e){
                     e.printStackTrace();
                 }
}
             else{
                
                 m_dirs.addAll(dirsList);    
                 //System.out.println(m_dirs.size());
                 /*
                 for(int i=0;i<dirs.length;i++){//print dirs
                     System.out.println("NO."+ ++counter+":"+dirs[i].toString());
                 }
                 */
                 //System.out.println(m_dirs.size());
                
                 for(int i=0;i<dirsList.size();i++){
                     tempRoot=(java.io.File)dirsList.get(i);
                     visitAll(tempRoot);
                     /*
                     dirs=tempRoot.listFiles();
                     List dirsList= Arrays.asList(dirs);
                     */
                     //System.out.println(tempRoot.toString());
                 }   
             }
             //return true;
         //}
         }
     }
     /*
      * do delete
      */
     private static void myDelete()throws Exception{
         //m_dirs.add(m_root);
         visitAll(m_root);
        
         if(m_dirs!=null){
            
             //System.out.println("删除前:"+m_dirs.size());
             //System.out.println(m_dirs.size());
             for(int i=m_dirs.size()-1;i>=0;i--){
                 java.io.File f= (java.io.File)m_dirs.remove(i);
                 //File f= (File)m_dirs.get(i);
                 //System.out.println(f.toString());
                 String fileName=f.toString();
                
                 if(!f.delete()){
                     throw new Exception("Exception: delete file "+ fileName+" false!");
                     //System.out.println("删除文件/文件夹"+fileName+"失败!");
                 }
             }
         }
         else{
             throw new Exception("Exception: read file list of "+m_root.toString()+"false!");
             //System.out.println("ArrayList==null");
         }
     }
     /*
      * root director
      */
     private static java.io.File m_root;
    
     private static ArrayList m_dirs;
     //private static int counter=0;

     public static void main(String[] args) {//测试类
        
         File file =new File("H:/小说/小四/天亮说晚安");
         try{
             File.deleteDirs("H:/小说/小四/天亮说晚安");
             //File.deleteDirs(file);
             //File.deleteSubDirs("H:/小说/小四/天亮说晚安");
             //File.deleteSubDirs(file);
//File f=new File("F:/test.txt");
             //f.delete();
         }
         catch(Exception e){
             e.printStackTrace();
         }
         System.out.println("删除成功~");
     }    
}

         如果你是一个Java支持者，你一定不会陌生Netbeans，因为大家都是从Netbeans的爱恨交加中走过来的，初识Netbeans还是3.6版本，当时无论从界面还是运行上，真的不敢恭维，但是谁又能说Netbeans会停止它前进的脚步呢?由于开源脚步的加快，Borland提前宣布退出，给了Netbeans更多的机会，也让Netbeans在业界得到专业人士的赏识，但是他真的走出充当配角角色吗?真的像Netbeans高级宣传官所说的那样走出低谷了吗?

　　Netbeans拒绝与Eclipse合并

　　随着开源的兴起，Jbuilder光辉不在，Netbeans的市场份额在今年上半年有了明显的增长，据国外权威调查机构显示，Eclipse 市场份额占45%，Netbeans占 30%，Jbuilder占15% ，其它IDE占5%，从调查分析来看，Netbeans的市场占有率正在上升，原来三国鼎立的局面因为Jbuilder的退出，使Eclipse对决 Netbeans大战提前上演了，都说这是一场势均力敌的战争，倒不如说是两大软件巨头的撕杀，2006年初IBM就开始和Sun公司进行谈判，数月谈判结果给了IBM当头一棒，Sun公司拒绝加入IBM主导的开源项目Eclipse，在宣布放弃Eclipse同时，不久Sun表示，他们不再试图将Sun 发起的NetBeans.org开放源Java工具项目与Eclipse合并。

　　Sun公司认为，加入Eclipse阵营需要打破两个组织之间的技术和组织差别，而这将对NetBeans和Eclipse项目现有的参与者造成不利影响。Sun公司开发平台集团副总裁RichGreen表示，“我们双方都确定我们不希望放弃现有项目”，“我们确定，合作社团相对于削减成本等问题更为重要。”

　　Eclipse和NetBeans开放源项目目的是开发软件以允许不同的Java开发工具在单个编程应用中能够相互嵌和。比如，开发人员可以将一家公司提供的源代码管理工具与其他公司的代码编辑器综合在一起使用。

　　Green称，双方起初讨论放弃NetBeans，但很快转而谈判寻求将两个开放源项目统一在一个单一实体下。理论上，将两个项目和并可以建立一个针对同一技术的更大社团，并确保两个项目不会建立不兼容的代码。但Green表示，如果重写各自的插件系统以及相关的工具平台需要双方花费很长时间和巨大开销。比如，Sun的商业开发工具建立在NetBeans的基础上，如果转而采用Eclipse标准则需要进行重大修改。

　　Sun和IBM Eclipse未能走到一起，在两大开放源工具项目之间建立起一个鸿沟。Green表示，这样也为开发商提供了更多的选择。并且，Sun仍然希望将来与Eclipse重开谈判之门。

　　相对与Sun的内敛相比，Eclipse基金会的执行理事Mike Milinkovich要自信得多，在谈到老竞争对手时，他说这本来就是一场没有悬念的战争，我们已经拥有了足够多的用户，而他们没有，很明显我们会赢得这场战争，我只能祝他们好运。

　　关于两位当事人的观点我们的记者也采访了香港政府IT部门架构师Recher，他说这本身就是一场实力悬殊的竞争，虽然近期 Netbeans是在市场战略上取得一些佳绩，但不能说他们真正的赢得了这场胜利，他只不过是在分享Jbuilder抛弃的市场份额而已，Eclipse 并没有因为它的增加而减少，Sun公司一直在用一种狭隘的心态在抵制自已竞争对手，最近和IBM的谈判崩裂，以及Sun一直都没把OSGI列放JMX的标准中，就是很好的例证。

　　Eclipse未来之路

　 同时Recher也谈到了Eclispe开发在3个方面占胜了Netbeans.

　　1. 在技术上Eclipse是良好的OSGI框架实现(Equinox是OSGi R4 core framework的一个实现，而Eclipse IDE是基于Equinox项目开发的一个典型例子OSGI的好处基本就是面向组件开发，并提供一个十分好用的plugs-in框架，开发性强。况且 Eclipse本身就是一个RCP的容器---为未来RCP应用程序的将来提供不可缺少而且成熟的工具和容器。

　　2. 在市场上Netbeans支持的项目和工具太少了，因为很多开源项目都提供了大量Eclipse的plugs-in组件，这些是其它IDE 工具无法比拟的， 现在的 IBM已经和Eclipse完全整合了(以前的WSAD还不能说完全，但IRAD6.0就已经很完全了)，同时IBM推出RSA(Rational Software Architect)的工具可以把Eclipse+UML+RUP+IRAD比较完美结合，至少我认为它是目前出来最好的工具了，整个RUP都可以涵盖，而且还是支持UML2.0.

　　3. 在背景方面Eclispe的流行完全是IBM在它萌芽阶段进行资金赞助的产物，有了IBM这个蓝色巨人的支持， 它的前途无可限量，但是也不能小看了Sun公司的这个冷面杀手，有Sun这个强有力的后盾，双方以后的竞争会很激烈的.

　　其实对于Eclipse未来，我们国内的架构师们只是在应用的角度上来看得在这个问题，Mike Milinkovich在9月初的Eclipse 2006世界大会指出了Eclipse未来的发展和新技术走向，他告诉我们首先是围绕富客户端平台的继续增长和采用。支持更多的语言。下个季度，我们计划在Eclipse内推出首版的PHP IDE项目，我们认为这是一个非常令人激动的项目。因为无论是对企业开发者还是Web开发者来说，PHP是一门非常重要的语言，因此使得Eclipse工具支持PHP是一件令我们激动的事情。

　　NetBeans未来走向

　　在IDE开发工具竞争激烈的今天，Sun也逐步的调整了Netbeans市场战略,在今年JavaOne大会上，Netbeans高级宣传官 Tim Boudreau也谈到了Netbeans以后发展动向，他告诉我们，自从1998年以来，NetBeans并没有只为Java而<strong onmouseover="isShowAds = true;isShowAds2 = true;ads.Move(this,"http://rad.17luntan.com/UploadImage/36/633148531966718750.jpg","%u4E2D%u534E%u82F1%u624D%u7F51%uFF0C%u6709%u6548%u6C42%u804C%2C%u5E94%u8058%2C%u627E%u5DE5%u4F5C%u5C31%u5728%u8FD9%u91CC%21","43772","工作","%u5DE5%u4F5C","http%3A//chinahrafaad.allyes.com/main/adfclick%3Fdb%3Dchinahrafaad%26bid%3D41818%2C21083%2C187%26cid%3D16880%2C133%2C1%26sid%3D42304%26show%3Dignore%26url%3Dhttp%3A//www.chinahr.com/")" style="FONT-WEIGHT: normal; CURSOR: hand; COLOR: #0000ff; TEXT-DECORATION: underline" onclick="javascript:window.open("http://s4.17luntan.com/ClickPortal/WebClick.aspx?id=43772&k=%u5DE5%u4F5C&siteid=0098295a-e262-40f7-ae50-7a6fbbdb678b&url=http%3A//java.csdn.net/n/20061025/96733.html&gourl=http%3A//chinahrafaad.allyes.com/main/adfclick%3Fdb%3Dchinahrafaad%26bid%3D41818%2C21083%2C187%26cid%3D16880%2C133%2C1%26sid%3D42304%26show%3Dignore%26url%3Dhttp%3A//www.chinahr.com/&parm=2F5B371DE6B4180FC652E69EC2EBF65E7A9AA108AEB8FCBD&alliedsiteid=0");" onmouseout="isShowAds = false;isShowAds2 = false;">工作。它也是C/C++工具的基础，Sun公司已经将它转用于Solaris很多年了，对它的支持正在进行扩展化和通用化，不再仅限于Solaris。NetBeans也是HP公司用于OpenVMS的IDE，支持COBOL, Fortran, C/C++和其它语言。例如在今年JavaOne大会上我们演示的对VB的支持—实际上是读取VB代码，编译成字节码，然后运行，有时会比它本应生成的本地代码运行还要快。因此，我们已经开始了这个项目，也会有围绕脚本方面的开发做更多的努力。NetBeans并不一定要局限于Java IDE平台—它对于Java已经有了很大地支持，那是人们首先要考虑的事情。但是就NetBeans目前的发展来看，它已经成为了一个语言无关的平台。

　　正象我们早期提到的，重要的东西的寿命总是很长。一些人声称Java会在5或10年里死亡，我们都会迎来下一个大的事物。即使真是那样， NetBeans也一样可能会支持下一个事物的到来，但是对一个语言的寿命做假设的时候，有一件重事情要考虑，对于期望任何特殊的程序语言或范例的盛行周期日益变得更长是很实际的，这有两方面的原因。首先，我们在绘制人们如何考虑告诉计算机工作的方式上的蓝图方面正越来越好，其次，一个语言统治的时间越长，它的代码就会越多，因此移植的代价也就越大。于是你不得不紧跟一些事情，这些事情会强迫变化中的语言很丰富多彩。

　　现在有很多有关脚本语言的谈论，但是我期待在主流编程语言中的下一个重大变化是让直觉上类似多核芯片的并行方式成为规范标准。我确信在未来的时间里这些目标将会成我们考虑的主流。

　　从上述的采访中我们明显看到了开发公司的架构师对于Eclipse的钟爱程度，Eclipse已经深入人心， Eclipse的强大是显而易见，记得Ruby刚刚在网上火爆的时候，Eclipse就迅速作出反应，推出了支持Ruby开发插件，可是我们在反观 Netbeas在5.5的版本还没有这样的计划，Java之父Gosling曾说过未来的Netbeans不将是纯粹的Java开发工具，它要涉及各个方面，以后也会支持Ruby开发，可是在他说这些话的时候，Eclipse已经在前进的路上了，这难免令所有支持者感到失望，未来的日子，谁将主宰我们都拭目以待。

         以上内容转自:http://java.csdn.net/n/20061025/96733.html

posted @ 2007-05-21 02:20 jadmin 阅读(61) | 评论 (0) | 编辑 收藏

仅列出标题

共50页: First 上一页 41 42 43 44 45 46 47 48 49 下一页 Last