java 1.5和1.6中的新特性

JDK5新特性(与1.4相比)【转】

1 循环

for (type variable : array){ body}

for (type variable : arrayList){body}

而1.4必须是:

for (int i = 0; i < array.length; i++){ type variable = array[i];    body}

for (int i = 0; i < arrayList.size(); i++){type variable = (type) arrayList.get(i); body}

2 泛型

以ArrayList为例,包括创建一个容器对象和取得容器内对象操作:

1.5 ArrayList<Type> arrayList =new ArrayList<Type>(); arrayList.get(i)

1.4 ArrayList arrayList =new ArrayList();  (Type) arrayList.get(i)

3 自动装箱拆箱

在JDK5.0以前,在原始类型与相应的包装类之间的转化是不能自动完成的。要完成这种转化,需要手动调用包装类的构造函数,在JDK5.0环境中,可以自动转化:

1.5 int a = 0; Integer wrapper = a;    int n = wrapper;

1.4 Integer wrapper = new Integer(n);    int n = wrapper.intValue();

4 可变的返回类型

在JDK5.0以前,当覆盖父类方法时,返回类型是不能改变的。现在有新的规则用于覆盖方法。如下,一个典型的例子就是clone()方法:

1.5 public Employee clone() { ... }

    ...

    Employee cloned = e.clone();

1.4 public Object clone() { ... }

    ...

    Employee cloned = (Employee) e.clone();

5 静态导入

静态导入功能对于JDK 5.0以前的版本是不支持的。

import static java.lang.Math;

import static java.lang.System;

...

1.5 out.println(sqrt(PI));

1.4 System.out.println(Math.sqrt(Math.PI));

6 控制台输入

JDK 5.0先前的版本没有Scanner类,只能使用JOptionPane.showInputDialog类代替。

1.5 Scanner in = new Scanner(System.in);

    System.out.print(prompt);

    int n = in.nextInt();

    double x = in.nextDouble();

    String s = in.nextLine();

1.4 String input = JOptionPane.showInputDialog(prompt);

    int n = Integer.parseInt(input);

    double x = Double.parseDouble(input);

    s = input;

7 格式化输出

JDK5.0以前的版本没有printf方法,只能使用NumberFormat.getNumberInstance来代替。

1.5 System.out.printf("%8.2f", x);

1.4 NumberFormat formatter= NumberFormat.getNumberInstance();

    String formatted = formatter.format(x);

    for (int i = formatted.length(); i < 8; i++)

    System.out.print(" "); System.out.print(formatted);

8 内容面板代理

在JDK5.0先前的版本中,JFrame,JDialog,JApplet等类没有代理add和setLayout方法。

1.5 add(component);  setLayout(manager);

1.4 getContentPane().add(component);getContentPane().setLayout(manager);

9 StringBuilder类

jDK 5.0引入了StringBuilder类,这个类的方法不具有同步,这使得该类比StringBuffer类更高效。

 

JDK6的新特性(转)

1 SystemTray类

在JDK6中 ,AWT新增加了两个类:Desktop和SystemTray,前者可以用来打开系统默认浏览器浏览指定的URL,打开系统默认邮件客户端给指定的邮箱发邮件,用默认应用程序打开或编辑文件(比如,用记事本打开以txt为后缀名的文件),用系统默认的打印机打印文档;后者可以用来在系统托盘区创建一个托盘程序.

2 使用JAXB2来实现对象与XML之间的映射

JAXB是Java Architecture for XML Binding的缩写,可以将一个Java对象转变成为XML格式,反之亦然。

3 新增StAX

StAX(The Streaming API for XML)是JDK6.0中除了DOM和SAX之外的又一种处理XML文档的API

4 新增Compiler API

可以用JDK6 的Compiler API去动态编译Java源文件。这个特性对于用到动态编译的应用程序相当有用, 比如JSP Web Server,当我们手动修改JSP后,是不希望需要重启Web Server才可以看到效果的,这时候我们就可以用Compiler API来实现动态编译JSP文件

5 轻量级Http Server

JDK6提供了一个简单的Http Server API,,程序员必须自己实现HttpHandler接口,HttpServer会调用HttpHandler实现类的回调方法来处理客户端请求。

6 插入式注解处理API(Pluggable Annotation Processing API)

插入式注解处理API提供一套标准API来处理Annotations,它把method, package, constructor, type, variable, enum, annotation等Java语言元素映射为Types和Elements, 从而将Java语言的语义映射成为对象。

7 用Console开发控制台程序

JDK6中提供了java.io.Console类专用来访问基于字符的控制台设备.

8 Web服务元数据(Web Services metadata)

9 更简单,更强大的JAX-WS

Java Architecture for XML Web Services的缩写,是一种用Java和XML开发Web Services应用程序的框架。

10 脚本语言支持(Scripting)

JDK6增加了对脚本语言的支持,原理上是将脚本语言编译成bytecode,这样脚本语言也能享用Java平台的诸多优势,包括可移植性,安全等,另外,由于现在是编译成bytecode后再执行,所以比原来边解释边执行效率要高很多。

11 JTable的排序和过滤

原来的JTable基本上是只能显示数据,在JDK6新增了对JTable的排序和过滤功能

一步一个脚印,方便自己复习,该出手时就出手,有错误,一定要指正,非常感谢,共同进步!

==================================================================================

JDK1.5 JDK1.6 各自的新特性

自己一直用JDK1.5,一个同学突然问我JDK1.5和之前的版本有什么区别吗?我无语了,自己感觉对JAVA了解的还可以,可这一个这么基本的问题都不会...,回来再谷歌上百度一下,总结下:

JDK1.5(JDK5.0)

Java2标准版(Java 2 Platform, Standard Edition, J2SE)1.5版本更新不同于以往,它带来了很多里程碑式的革新,SUN将其绰号取名为“虎”。这一次的变革将是Java诞生以来从未有过的,它给我们带来了耳目一新的感觉。下面我们就来欣赏一下其中的部分典型变化:

 

比较JDK版本,JDK 1.5中新增的语言特性:

1.枚举(增加了一个关键字enum);

2.变参(方法参数数量可以不固定多少);

3.泛型;

4.自动拆装箱(基本类型与包装类型可以混用);

5.foreach循环(方法地用于遍历数组和集合);

6.静态导入(可以在使用静方法前不加类名);

7.注释(采用@前缀,这个基本上是为了简化J2EE而准备的,在JavaEE5中的EJB3、JPA等中随处可以看到它的身影)。

在JVM、基本类库、SDK工具和硬件平台支持上都有很多的提高,这个JDK版本的出现可以说是Java中的一次飞越。

具体的解释下:

1.自动包装和解包(Autoboxing and unboxing)
  代码示例
  
  往一个ArrayList中加入一个整数,1.5版本以前的版本写法是:
  
  List list = new ArrayList();
  
  list.add( new Integer( 10 ) );
  
  而在1.5版本中可以写为:
  
  list.add( 10 );
  
  因为,在1.5版本中,对一个整数进行包装,使之成为一个Integer对象(即包装,boxing),然后加入到一个ArrayList中的做法被认为是没有必要的,反之,解包(unboxing)的做法也是没有必要的,这样的代码只是增加了程序的文本长度而已,所以1.5版本支持了自动包装和解包操作,对于bool/Boolean,byte/Byte,double/Double,short/Short,int/Integer,long/Long,float/Float的相应包装/解包操作都进行了支持,从而使代码变得简单。
  
  2.更优化的循环语句(The inhanced for loop)
  代码示例
  
  一个典型的遍历数组的循环语句,1.5版本以前的写法是:
  
  for ( Iterator iterator = list.iterator(); iterator.hasNext(); )
  
  {
  
  Integer n = (Integer)iterator.next();
  
  ...
  
  }//for
  
  而在1.5版本中可以写为:
  
  for ( Integer n : list )
  
  {
  
  ...
  
  }//for
  
  显然1.5版本的写法比以前是大大简化了,但是在需要修改集合,比如删除其中元素时不能采用这种写法。之所以Java1.5版本没有象C#那样干脆定义一个foreach关键词,主要是因为SUN认为增加一个专门的关键词成本太高了(too costly)。但1.4版本中就曾经增加了assert关键词,1.5版本中也新增加了enum关键词,因此这一解释恐怕并不那么令人信服。
  
  3.参数可变的方法和printf
  代码示例
  
  当不能确定一个方法的入口参数的个数时,以往版本的Java中,通常的做法是将多个参数放在一个数组或者对象集合中作为参数来传递,1.5版本以前的写法是:
  
  int sum(Integer[] numbers)
  
  {
  
  int nSum = 0;
  
  for(int i: numbers)
  
  nSum += i;
  
  return nSum;
  
  }
  
  ...
  
  //在别处调用该方法
  
  sum(new Integer[] {12,13,20});
  
  而在1.5版本中可以写为:
  
  int sum(Integer... numbers)
  
  {
  
  int nSum = 0;
  
  for(int i: numbers)
  
  nSum += i;
  
  return nSum;
  
  }
  
  ...
  
  //在别处调用该方法
  
  sum(12,13,20);
  
  显然,1.5版本的写法更为简易,也更为直观,尤其是方法的调用语句,不仅简化很多,而且更符合通常的思维方式,更易于理解。
  
  1.5版本自身就有一个应用该特征的典型例子,即C风格的格式化输出方法——printf。
  
  代码示例
  
  输出一个加法算式,1.5版本以前的写法是:
  
  int x = 5;
  
  int y = 7;
  
  int nSum = x + y;
  
  System.out.println(x + " + " + y + " = " + nSum);
  
  而在1.5版本中可以写为:
  
  System.out.printf("%d + %d = %d\n", x, y, nSum);
  
  以上两种写法的输出结构是一样的,即“5 + 7 = 12”。
  
  这种改变不仅仅是形式上的,printf还可以提供更为灵活、强大的输出功能,比如限定按照两位整数的形式输出,可以写为“System.out.printf("%02d + %02d = %02d\n", x, y, nSum);”,输出结果将是“05 + 07 = 12”。
  
  4.枚举
  代码示例
  
  构建一个表示色彩的枚举,并赋值,在1.5版本中可以写为:
  
  public enum MyColor{ Red, Yellow, Blue }
  
  MyColor color = MyColor.Red;
  
  for ( MyColor mycolor : MyColor.values() )
  
  System.out.println( mycolor );
  
  以往的Java版本中没有enum关键词,1.5版本中终于加入了进来,这确实是一个令人高兴的改进。此外,enum还提供了一个名为values()的静态方法,用以返回枚举的所有值的集合。所以,以上程序的输出结果是把“Red”、“Yellow”、“Blue”分行输出。
  
  而enum提供的静态方法valueOf()则将以字符串的形式返回某一个具体枚举元素的值,比如“MyColor.valueOf(“Red”)”会返回“Color.Red”。静态方法name()则返回某一个具体枚举元素的名字,比如“MyColor.Red.name()”会返回“Red”。类似的方法还有不少。此外,enum自身还可以有构造方法。
  
  5.静态引用
  代码示例
  
  当我们要获取一个随即数时,1.5版本以前的写法是:
  
  import java.lang.Math; //程序开头处
  
  ...
  
  double x = Math.random();
  
  而在1.5版本中可以写为:
  
  import static java.lang.Math.random; //程序开头处
  
  …
  
  double x = random();
  
  静态引用使我们可以象调用本地方法一样调用一个引入的方法,当我们需要引入同一个类的多个方法时,只需写为“import static java.lang.Math.*”即可。这样的引用方式对于枚举也同样有效。

 

 

 

JDK1.6

简化Web Services
Mustang 将 简化Web services 的开发和发布. XML和Web服务一直都是Mustang的关注重点.. Mustang为此引入了JAX-WS(Java Architecture for XML-Web Services) 2.0 以及JAXB(Java Architecture for XML Binding) 2.0.. 同时还有Streaming API for XML (STaX), 它提供了一个双向API,这个API可以通过一个事件流来读取或者写入XML,其中包括跳过某个部分,然后直接关注与文档中的另外一个小部分的能力。 


Scripting,整合脚本语言
目前来讲,Java 开发者们必须在Java之外独立地额外编码来使用non-Java 脚本语言。这个头痛的问题将被Mustang 消灭,开发者将更加轻松的使用Perl、PHP、Python、JavaScript 和Ruby等脚本语言。新的框架将允许人们操作任意的脚本语言,和使用Java 对象。

Java SE6中实现了JSR223。这是一个脚本框架,提供了让脚本语言来访问Java内部的方法。你可以在运行的时候找到脚本引擎,然后调用这个引擎去执行脚本。这个脚本API允许你为脚本语言提供Java支持。另外,Web Scripting Framework允许脚本代码在任何的Servlet容器(例如Tomcat)中生成Web内容。

Database,绑定Derby
开源嵌入式数据库 Derby(JavaDB) 绑定在JDK 1.6中.具体可以参考:JDK 1.6 将绑定开源数据库 Derby

更丰富的Desktop APIs
Mustang中拥有更多强的桌面API提供给开发者, 开发者可以更简单地开发更强大的桌面应用, 比如启动界面的支持,系统托盘的支持,JTable排序等等

监视和管理
Java SE 6中对内存泄漏增强了分析以及诊断能力。当遇到java.lang.OutOfMemory异常的时候,可以得到一个完整的堆栈信息,并且当堆已经满了的时候,会产生一个Log文件来记录这个致命错误。另外,JVM还添加了一个选项,允许你在堆满的时候运行脚本。(这也就是提供了另外一种方法来诊断错误)

增强的JMX 监视API在MBean的属性值传入了一个特定的参数的时候,允许这个应用程序发送一个事件通告。(这里的属性值可以在很复杂的类型中)

对于Solaris 10的用户,为Solaris提供的Hotspot JVM中,提供了一种通过Solaris DTrace(这是个系统的调试工具)来追踪显示JVM内部的活动情况,包括垃圾收集,类装载,线程,锁等等。

Pluggable Annotations
从Java SE 5   带来得新特性Annotations,将在Mustang继续扮演重要角色.. 

Compiler API:访问编译器
对于Java开发工具, 或者Web框架 等的开发者来说, 利用编译器编译动态生成的代码, 是一个普遍的需求.

Mustang实现了JSR 199,   提供了Java编译器API(应用程序接口),允许你从一个Java应用程序中去编译其他的Java源程序--比如在应用程序中动态生成的一些源代码..

Security:安全性
Java SE 6的安全部分,增加了 XML-Digital Signature (XML-DSIG) APIs, 整合了GSS/Kerberos的操作API,LDAP上的JAAS认证。

Instrumentation 
      利用 Java 代码,即 java.lang.instrument 做动态 Instrumentation 是 Java SE 5 的新特性,它把 Java 的 instrument 功能从本地代码中解放出来,使之可以用 Java 代码的方式解决问题。在 Java SE 6 里面,instrumentation 包被赋予了更强大的功能:启动后的 instrument、本地代码(native code)instrument,以及动态改变 classpath 等等。在 Java SE 5 当中,开发者只能在 premain 当中施展想象力,所作的 Instrumentation 也仅限与 main 函数执行前,这样的方式存在一定的局限性。在 Java SE 6 的 Instrumentation 当中,有一个跟 premain“并驾齐驱”的“agentmain”方法,可以在 main 函数开始运行之后再运行。

Http
    在 Java SE 6 当中,围绕着 HTTP 协议出现了很多实用的新特性:NTLM 认证提供了一种 Window 平台下较为安全的认证机制;JDK 当中提供了一个轻量级的 HTTP 服务器;提供了较为完善的 HTTP Cookie 管理功能;更为实用的 NetworkInterface;DNS 域名的国际化支持等等。
    HTTP Cookie管理可以应用客户操作临时变量的保存,如查询条件,当前状态等


JMX与系统管理

管理系统的构架
图 1. 管理系统构架

 

上图分析了管理系统的基本构架模式。其中 Agent / SubAgent 起到的就是翻译的作用:把 IT 资源报告的消息以管理系统能理解的方式传送出去。

也许读者有会问,为什么需要 Agent 和 SubAgent 两层体系呢?这里有两个现实的原因:

管理系统一般是一个中央控制的控制软件,而 SubAgent 直接监控一些资源,往往和这些资源分布在同一物理位置。当这些 SubAgent 把状态信息传输到管理系统或者传达管理系统的控制指令的时候,需要提供一些网络传输的功能。

  1. 管理系统的消息是有一定规范的,消息的翻译本身是件复杂而枯燥的事情。

一般来说,管理系统会将同一物理分布或者功能类似的 SubAgent 分组成一组,由一个共用的 Agent 加以管理。在这个 Agent 里封装了 1 和 2 的功能。

JMX 和管理系统

JMX 既是 Java 管理系统的一个标准,一个规范,也是一个接口,一个框架。图 2 展示了 JMX 的基本架构。
图 2. JMX 构架和其它的资源系统一样,JMX 是管理系统和资源之间的一个接口,它定义了管理系统和资源之间交互的标准。javax.management.MBeanServer 实现了 Agent 的功能,以标准的方式给出了管理系统访问 JMX 框架的接口。而 javax.management.MBeans 实现了 SubAgent 的功能,以标准的方式给出了 JMX 框架访问资源的接口。而从类库的层次上看,JMX 包括了核心类库java.lang.management 和 javax.management 包。java.lang.management 包提供了基本的 VM 监控功能,而 javax.management 包则向用户提供了扩展功能。 JMX帮助开发者监控JVM的信息。

编辑器API

     JDK 6 提供了在运行时调用编译器的 API。在传统的 JSP 技术中,服务器处理 JSP 通常需要进行下面 6 个步骤:

  1. 分析 JSP 代码;
  2. 生成 Java 代码;
  3. 将 Java 代码写入存储器;
  4. 启动另外一个进程并运行编译器编译 Java 代码;
  5. 将类文件写入存储器;
  6. 服务器读入类文件并运行;

     但如果采用运行时编译,可以同时简化步骤 4 和 5,节约新进程的开销和写入存储器的输出开销,提高系统效率。实际上,在 JDK 5 中,Sun 也提供了调用编译器的编程接口。然而不同的是,老版本的编程接口并不是标准 API 的一部分,而是作为 Sun 的专有实现提供的,而新版则带来了标准化的优点。
     新 API 的第二个新特性是可以编译抽象文件,理论上是任何形式的对象 —— 只要该对象实现了特定的接口。有了这个特性,上述例子中的步骤 3 也可以省略。整个 JSP 的编译运行在一个进程中完成,同时消除额外的输入输出操作。
     第三个新特性是可以收集编译时的诊断信息。作为对前两个新特性的补充,它可以使开发人员轻松的输出必要的编译错误或者是警告信息,从而省去了很多重定向的麻烦

一些有趣的新特性: 

1 本地行为 java.awt.Desktop 
比如用默认程序打开文件,用默认浏览器打开url,再也不用那个browserlauncher那么费劲 
了 
Desktop desk=Desktop.getDesktop(); 
desk.browse(new URI("http://www.google.com/")); 
desk.open(file) 
desk.print(file) 

2 console下密码输入 java.io.Console 
再也不用自己写线程去删echo字符了 
Console console = System.console(); 
char password[] = console.readPassword("Enter password: "); 

3 获取磁盘空间大小 java.io.File的新方法 
File roots[] = File.listRoots(); 
for (File root : roots) { 
System.out.println(root.getPath()+":"+root.getUsableSpace() 
+"/"+root.getTotalSpace()); 


4 专利过期,可以提供合法的lzw的gif encoder了 
ImageIO.write(input, "GIF", outputFile); 

5 JAXB2.0 增加了java-to-xml schema,完成java bean,xml间转换非常容易 

6 xml数字签名 javax.xml.crypto,记得以前似乎只有ibm有个类库实现了 

7 编译器,以前是com.sun.tools.javac,现在是javax.tools.JavaCompiler 
有人写了完全在内存里的生成源文件,编译,反射运行的过程,比较好玩。 

8 脚本引擎,javax.script,内嵌的是Mozilla Rhino1.6r2 支持ECMAScript1.6

=================================================================================

JDK1.5、1.6、1.7新特性

开发过程中接触到了从jdk1.5---jdk1.7的使用,在不同的阶段,都使用过了jdk的一些新特性,操作起来更加方面啦!特此总结了下,与喜欢it 的朋友共勉!呵呵

以下是测试代码:

JDK1.5新特性:

1.自动装箱与拆箱:

Integer iObj = 3;

System.out.println(iObj + 12);
   Integer>范围时,为true);
   Integer>范围时,为true);

   System.out.println(i1 == i2); //false,但是括号中时却返回ture,原因是Integer采用的是享元模式

   Integer>    Integer>    System.out.println(i3==i4);//同上,另一种包装形式

 

2.枚举(常用来设计单例模式)

public class EnumTest {


public>    System.out.println(weekDay.nextDay());
   WeekDay>    System.out.println(weekDay2);
   System.out.println(weekDay2.name());
   System.out.println(weekDay2.ordinal()); 
   System.out.println(WeekDay.valueOf("SUN").toString());
   System.out.println(WeekDay.values().length);
   new Date(300){};
}

public enum WeekDay{

   SUN(1),MON(),TUE,WED,THI,FRI,SAT;
   private WeekDay(){System.out.println("first");}
   private WeekDay(int> }
}

3.静态导入

import static java.lang.Math.*;

public class StaticImport {
public>    try {
    x++;
   } finally {
    System.out.println("template");
   }
   System.out.println(x);
  
  
   System.out.println(max(3, 6));
   System.out.println(abs(3 - 6));
  
}
}
4.可变参数

public class VarableParameter {


public> 
  
   for(int>    }
   return sum;
}

}
5.内省

ReflectPoint pt1 = new ReflectPoint(3,5);

BeanInfo beanInfo = Introspector.getBeanInfo(pt1.getClass());
   PropertyDescriptor[]>    Object>    for(PropertyDescriptor>      retVal = methodGetX.invoke(pt1);

   }

   jdk1.6新特性:

1.Web服务元数据

Java 里的Web服务元数据跟微软的方案基本没有语义上的区别,自从JDK5添加了元数据功能(Annotation)之后,SUN几乎重构了整个J2EE体 系, 由于变化很大,干脆将名字也重构为Java EE, Java EE(当前版本为5.0)将元数据纳入很多规范当中,这其中就包括Web Services的相关规范, 加入元数据之后的Web Services服务器端编程模型就跟上面看到的C#片断差不多了, 这显然比以前的JAX-RPC编程模型简单(当然, Axis的编程模型也很简单).这里要谈的Web服务元数据(JSR 181)只是Java Web 服务规范中的一个,它跟Common Annotations, JAXB2, StAX, SAAJ和JAX-WS等共同构成Java EE 5的Web Services技术堆栈.

package WebServices;

import java.io.File;
import java.io.IOException;
import javax.jws.Oneway;
import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebResult;
import javax.jws.WebService;
import javax.xml.ws.Endpoint;


@WebService(targetNamespace="http://blog.csdn.net/chinajash",serviceName="HelloService")
public>自定义该方法返回值在WSDL中相关的描述    
     @WebMethod
     public String>          return "Hi,"+name; //@WebParam是自定义参数name在WSDL中相关的描述
     }    
     @Oneway //表明该服务方法是单向的,既没有返回值,也不应该声明检查异常
     @WebMethod(action="printSystemTime",operationName="printSystemTime")//自定义该方法在WSDL中相关的描述
     public>          wsPublisher.start();
     }    
     private static class WSPublisher implements Runnable{
         public void run() {
             //发布WSProvider到http://localhost:8888/chinajash/WSProvider这个地址,之前必须调用wsgen命令
             //生成服务类WSProvider的支持类,命令如下:
             //wsgen -cp . WebServices.WSProvider
             Endpoint.publish("http://localhost:8888/chinajash/WSProvider",new WSProvider());
         }        
     }
}

如果想看到Web Services Engine生成的WSDL文件是否遵守上面的元数据, 我们没有必要将上面的WSProvider部署到支持JSR-181的应用服务器或Servlet形式的Web Services Engine,现在JDK6已经提供了一个很简单的机制可以用来测试和发布Web Services,下面讲讲如何在JDK6环境下发布Web Services和查看生成的WSDL
1.将<JDK_HOME>/bin加入path环境变量
2.在命令行下切换当前目录到WSProvider的class文件所在的目录,运行下面命令
wsgen -cp . WebServices.WSProvider
在这个例子中会生成以下3个类的源代码文件及class文件
SayHi
SayHiResponse
PrintTime
3.执行如下代码发布WSProvider到http://localhost:8888/chinajash/WSProvider,在这里可以执行WSProvider类的main方法就可以
Endpoint.publish("http://localhost:8888/chinajash/WSProvider",new WSProvider());
4.在浏览器输入http://localhost:8888/chinajash/WSProvider?wsdl就可以看到生成的WSDL文件,为了节省篇幅,这里就不把生成的WSDL文件贴上了,大家可以自己动手试试.
2.脚本语言支持

JDK6增加了对脚本语言的支持(JSR 223),原理上是将脚本语言编译成bytecode,这样脚本语言也能享用Java平台的诸多优势,包括可移植性,安全等,另外,由于现在是编译成bytecode后再执行,所以比原来边解释边执行效率要高很多。加入对脚本语言的支持后,对Java语言也提供了以下好处。
1、许多脚本语言都有动态特性,比如,你不需要用一个变量之前先声明它,你可以用一个变量存放完全不同类型的对象,你不需要做强制类型转换,因为转换都是自动的。现在Java语言也可以通过对脚本语言的支持间接获得这种灵活性。
2、 可以用脚本语言快速开发产品原型,因为现在可以Edit-Run,而无需Edit-Compile-Run,当然,因为Java有非常好的IDE支持,我 们完全可以在IDE里面编辑源文件,然后点击运行(隐含编译),以此达到快速开发原型的目的,所以这点好处基本上可以忽略。
3、通过引入脚本语言可以轻松实现Java应用程序的扩展和自定义,我们可以把原来分布在在Java应用程序中的配置逻辑,数学表达式和业务规则提取出来,转用JavaScript来处理。

Sun的JDK6实现包含了一个基于Mozilla Rhino的脚本语言引擎,支持JavaScript,这并不是说明JDK6只支持JavaScript,任何第三方都可以自己实现一个JSR-223兼容的脚本引擎使得JDK6支持别的脚本语言,比如,你想让JDK6支持Ruby,那你可以自己按照JSR 223的规范实现一个Ruby的脚本引擎类,具体一点,你需要实现javax.script.ScriptEngine(简单起见,可以继承javax.script.AbstractScriptEngine)和javax.script.ScriptEngineFactory两个接口。当然,在你实现自己的脚本语言引擎之前,先到scripting.dev.java.net project 这里看看是不是有人已经帮你做了工作,这样你就可以直接拿来用就行。

Scripting API

--------------------------------------------------------------------------------
Scripting API是用于在Java里面编写脚本语言程序的API, 在Javax.script中可以找到Scripting API,我们就是用这个API来编写JavaScript程序,这个包里面有一个ScriptEngineManager类,它是使用Scripting API的入口,ScriptEngineManager可以通过jar服务发现(service discovery)机制寻找合适的脚本引擎类(ScriptEngine),使用Scripting API的最简单方式只需下面三步
1、创建一个ScriptEngineManager对象
2、通过ScriptEngineManager获得ScriptEngine对象
3、用ScriptEngine的eval方法执行脚本

下面是一个Hello World程序

public>

         ScriptEngine>

             engine.eval_r("print('Hello, Scripting')");//Step 3

     }

     }运行上面程序,控制台会输出Hello, Scripting上面这个简单的Scripting程序演示了如何在Java里面运行脚本语言,除此之外,我们还可以利用Scripting API实现以下功能1、暴露Java对象为脚本语言的全局变量2、在Java中调用脚本语言的方法3、脚本语言可以实现Java的接口4、脚本语言可以像Java一样使用JDK平台下的类下面的类演示了以上4种功能

          package Scripting;import java.io.File;

            import javax.script.Invocable;

                    import javax.script.ScriptEngine;

              import javax.script.ScriptEngineManager;

                 import javax.script.ScriptException;

                   public class ScriptingAPITester {

                 public>

         ScriptEngine>

         testScriptVariables(engine);//演示如何暴露Java对象为脚本语言的全局变量         testInvokeScriptMethod(engine);//演示如何在Java中调用脚本语言的方法

          testScriptInterface(engine);//演示脚本语言如何实现Java的接口         testUsingJDKClasses(engine);//演示脚本语言如何使用JDK平台下的类

     }

         public static void testScriptVariables(ScriptEngine engine) throws ScriptException{

         File>

         engine.put("f", file);

         engine.eval_r("println('Total Space:'+f.getTotalSpace())");

             }

         public>

 return 'Hello,' + name;

}";

         engine.eval_r(script);

         Invocable>

         String>

         System.out.println("res:"+res);

     }

         public static void testScriptInterface(ScriptEngine engine) throws ScriptException{

         String>

              obj.run = function() {

             println('run method called');

   }";

         engine.eval_r(script);

         Object>

         Invocable>

         Runnable>

         Thread>

         th.start();

     }

         public static void testUsingJDKClasses(ScriptEngine engine) throws Exception{

         //Packages是脚本语言里的一个全局变量,专用于访问JDK的package

         String js = "function>

f.setSize(400,300);f.setVisible(true);}";

         engine.eval_r(js);

         Invocable>

         inv.invokeFunction("doSwing", "Scripting Swing" )

;     }}Scripting Tool

--------------------------------------------------------------------------------
SUN提供的JDK6中有一个命令行工具??jrunscript,你可以在<JDK6_Home>/bin下面找到这个工具,jrunscript是一个脚本语言的解释程序,它独立于脚本语言,但默认是用JavaScript,我们可以用jrunscript来测试自己写的脚本语言是否正确,下面是一个在命令行运行jrunscript的简单例子
jrunscript
js>println("Hello,JrunScript");
Hello,JrunScript
js>9*8
72.0
js>
3.JTable的排序和过滤

原来的JTable基本上是只能显示数据,在JDK6新增了对JTable的排序和过滤功能,下面代码演示了这两个功能


public>          {"China","Beijing","Chinese"},
         {"America","Washington","English"},
         {"Korea","Seoul","Korean"},
         {"Japan","Tokyo","Japanese"},
         {"France","Paris","French"},
         {"England","London","English"},
         {"Germany","Berlin","German"},
     };
     static String>      public>          JTable>          final TableRowSorter>
         t.setRowSorter(sorter); //为JTable设置排序器
        
         JScrollPane>          sPane.setViewportView(t);
        
         JPanel>          p.setLayout(new BoxLayout(p,BoxLayout.X_AXIS));
         JLabel>          final JTextField>          JButton>          p.add(l);
         p.add(tf);
         p.add(b);
         b.addActionListener(new ActionListener() {
             public>                      sorter.setRowFilter(null);
                 }else{
         

阅读更多
文章标签: java
个人分类: IT-编程语言-Java
上一篇调度算法基础
下一篇Java 自动装箱与拆箱(Autoboxing and unboxing)
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭