Go语言视频零基础入门到精通

水中月

jdk 1.5新特性说明
“JDK1.5”的一个重要主题就是通过新增一些特性来简化开发，这些特性包括泛型，for-each　循环，自动装包/拆包，枚举，可变参数,　静态导入　。使用这些特性有助于我们编写更加清晰，精悍，安全的代码。
一． 首先简单介绍一下各种特性及其使用
1.泛型(Generic)
C++通过模板技术可以指定集合的元素类型，而java在1.5之前一直没有相对应的功能。一个集合可以放任何类型的对象，相应地从集合里面拿对象的时候我们也不得不对他们进行强制得类型转换。猛虎引入了泛型，它允许指定集合里元素的类型，这样你可以得到强类型在编译时刻进行类型检查的好处。
“JDK1.5”的一个重要主题就是通过新增一些特性来简化开发，这些特性包括泛型，for-each　循环，自动装包/拆包，枚举，可变参数,　静态导入　。使用这些特性有助于我们编写更加清晰，精悍，安全的代码。
一． 首先简单介绍一下各种特性及其使用
1.泛型(Generic)
C++通过模板技术可以指定集合的元素类型，而Java在1.5之前一直没有相对应的功能。一个集合可以放任何类型的对象，相应地从集合里面拿对象的时候我们也不得不对他们进行强制得类型转换。猛虎引入了泛型，它允许指定集合里元素的类型，这样你可以得到强类型在编译时刻进行类型检查的好处。
1 Collection<String> c = new ArrayList();
2 c.add(new Date());
　　编译器会给出一个错误：
add(java.lang.String) in java.util.Collection<java.lang.String> cannot be applied to (java.util.Date)
2.For-Each循环
For-Each循环得加入简化了集合的遍历。假设我们要遍历一个集合对其中的元素进行一些处理。典型的代码为：
1 void processAll(Collection c){
2 for(Iterator i=c.iterator(); i.hasNext();){
3 MyClass myObject = (MyClass)i.next();
4 myObject.process();
5 }
6 }
　　使用For-Each循环，我们可以把代码改写成：
1 void processAll(Collection<MyClass> c){
2 for (MyClass myObject :c)
3 myObject.process();
4 }
　　这段代码要比上面清晰许多，并且避免了强制类型转换。
3.自动装包/拆包(Autoboxing/unboxing)
自动装包/拆包大大方便了基本类型数据和它们包装类地使用。
自动装包：基本类型自动转为包装类.(int >> Integer)
自动拆包：包装类自动转为基本类型.(Integer >> int)
　　在JDK1.5之前，我们总是对集合不能存放基本类型而耿耿于怀，现在自动转换机制解决了我们的问题。
1 int a = 3;
2 Collection c = new ArrayList();
3c.add(a);//自动转换成Integer.
4 Integer b = new Integer(2);
5c.add(b + 2);
　　这里Integer先自动转换为int进行加法运算，然后int再次转换为Integer.
4.枚举(Enums)
JDK1.5加入了一个全新类型的“类”－枚举类型。为此JDK1.5引入了一个新关键字enmu.　我们可以这样来定义一个枚举类型。
1 public enum Color
2 {
3 Red,
4 White,
5 Blue
6 }
　　然后可以这样来使用Color myColor = Color.Red.
　　枚举类型还提供了两个有用的静态方法values()和valueOf().　我们可以很方便地使用它们，例如
1 for (Color c : Color.values())
2 System.out.println(c);
5.可变参数(Varargs)
　　可变参数使程序员可以声明一个接受可变数目参数的方法。注意，可变参数必须是函数声明中的最后一个参数。假设我们要写一个简单的方法打印一些对象，
util.write(obj1);
util.write(obj1,obj2);
util.write(obj1,obj2,obj3);
…
　　在JDK1.5之前，我们可以用重载来实现，但是这样就需要写很多的重载函数，显得不是很有效。如果使用可变参数的话我们只需要一个函数就行了
1 public void write(Object... objs) {
2 for (Object obj: objs)
3 System.out.println(obj);
4 }
　　在引入可变参数以后，Java的反射包也更加方便使用了。对于c.getMethod("test", new Object[0]).invoke(c.newInstance(), new Object[0]))，现在我们可以这样写了c.getMethod("test").invoke(c.newInstance())，这样的代码比原来清楚了很多。　
6.静态导入(Static Imports)
　　要使用用静态成员（方法和变量）我们必须给出提供这个方法的类。使用静态导入可以使被导入类的所有静态变量和静态方法在当前类直接可见，使用这些静态成员无需再给出他们的类名。
import static java.lang.Math.*;
…….
r = sin(PI * 2); //无需再写r = Math.sin(Math.PI);
不过，过度使用这个特性也会一定程度上降低代码地可读性。
二． 重点讲一下泛型
在已发布的Java1.4中在核心代码库中增加了许多新的API(如Loging,正则表达式，NIO)等，在最新发布的JDK1.5和即将发布的JDK1.6中也新增了许多API，其中比较有重大意义的就是Generics(范型)。
1.什么是Generics?
Generics可以称之为参数类型(parameterized types),由编译器来验证从客户端将一种类型传送给某一对象的机制。如Java.util.ArrayList,编译器可以用Generics来保证类型安全。
　　在我们深入了解Generics之前,我们先来看一看当前的java集合框架(Collection)。在j2SE1.4中所有集合的Root Interface是Collection
Collections example without genericity: Example 1
1 protected void collectionsExample() {
2  ArrayList list = new ArrayList();
3  list.add(new String("test string"));
4  list.add(new Integer(9)); // purposely placed here to create a runtime ClassCastException
5  inspectCollection(list);
6 }
7
8
9 protected void inspectCollection(Collection aCollection) {
10  Iterator i = aCollection.iterator();
11  while (i.hasNext()) {
12   String element = (String) i.next();
13  }
14 }
　　以上的样例程序包含的两个方法，collectionExample方法建立了一个简单的集合类型ArrayList，并在ArrayList中增加了一个String和一个Integer对象.而在inspecCollection方法中，我们迭代这个ArrayList用String进行Cast。我们看第二个方法，就出现了一个问题,Collection在内部用的是Object，而我们要取出Collection中的对象时,需要进行Cast，那么开发者必需用实际的类型进行Cast,像这种向下造型，编译器无
　　法进行检查,如此一来我们就要冒在代码在运行抛出ClassCastException的危险。我们看inspecCollection方法，编译时没有问题，但在运行时就会抛出ClassCastException异常。所以我们一定要远离这个重大的运行时错误
2.使用Generics
　　从上一章节中的CassCastException这种异常，我们期望在代码编译时就能够捕捉到,下面我们使用范型修改上一章的样例程序。
//Example 2
1 protected void collectionsExample() {
2  ArrayList<String> list = new ArrayList<String>();
3  list.add(new String("test string"));
4  // list.add(new Integer(9)); this no longer compiles
5  inspectCollection(list);
6 }
7
8
9 protected void inspectCollection(Collection<String> aCollection) {
10  Iterator<String> i = aCollection.iterator();
11  while(i.hasNext()) {
12   String element = i.next();
13  }
14 }
　　从上面第2行我们在创建ArrayList时使用了新语法，在JDK1.5中所有的Collection都加入了Generics的声明。例:
//Example 3
1 public class ArrayList<E> extends AbstractList<E> {
2  // details omitted...
3  public void add(E element) {
4   // details omitted
5  }
6  public Iterator<E> iterator() {
7   // details omitted
8  }
9 }
　　这个E是一个类型变量，并没有对它进行具体类型的定义,它只是在定义ArrayList时的类型占位符,在Example 2中的我们在定义ArrayList的实例时用String绑定在E上,当我们用add(E element)方法向ArrayList中增加对象时,那么就像下面的写法一样: public void add(String element);因为在ArrayList所有方法都会用String来替代E,无论是方法的参数还是返回值。这时我们在看Example 2中的第四行，编译就会反映出编译错误。
所以在java中增加Generics主要的目的是为了增加类型安全。
　　通过上面的简单的例子我们看到使用Generics的好处有:
. 1.在类型没有变化时，Collection是类型安全的。
. 2.内在的类型转换优于在外部的人工造型。
. 3.使Java接口更加强壮,因为它增加了类型。
. 4.类型的匹配错误在编译阶段就可以捕捉到，而不是在代码运行时。
　　受约束类型变量
　　虽然许多Class被设计成Generics，但类型变量可以是受限的
public class C1<T extends Number> { }
public class C2<T extends Person & Comparable> { }
　　第一个T变量必须继承Number，第二个T必须继承Person和实现Comparable
3.Generics方法
　　像Generics类一样，方法和构造函数也可以有类型参数。方法的参数的返回值都可以有类型参数，进行Generics。
//Example 4
1 public <T extends Comparable> T max(T t1, T t2) {
2  if (t1.compareTo(t2) > 0)
3   return t1;
4  else return t2;
5 }
　　这里，max方法的参数类型为单一的T类型，而T类型继承了Comparable，max的参数和返回值都有相同的超类。下面的Example 5显示了max方法的几个约束。
//Example 5
1 Integer iresult = max(new Integer(100), new Integer(200));
2 String sresult = max("AA", "BB");
3 Number nresult = max(new Integer(100), "AAA"); // does not compile
　　在Example 5第1行参数都为Integer，所以返回值也是Integer，注意返回值没有进行造型。
　　在Example 5第2行参数都为String，所以返回值也是String，注意返回值没有进行造型。以上都调用了同一个方法。
　　在Example 5第3行产生以下编译错误:
Example.java:10: incompatible types
found  : java.lang.Object&java.io.Serializable&java.lang.Comparable<?>
required: java.lang.Number
    Number nresult = max(new Integer(100), "AAA");
　　这个错误发生是因为编译器无法确定返回值类型，因为String和Integer都有相同的超类Object,注意就算我们修正了第三行，这行代码在运行仍然会报错，因为比较了不同的对象。
3.通配(Wildcards)
先看以下两行代码是否合法:
List<String> ls = new ArrayList<String>(); // 1
List<Object> lo = ls; // 2
第一行没问题, 关键在第二行代码, 大多数人会认为, "一个String的List自然更是一个Object的List", 因此, 第2行没问题.
好, 接着看以下代码:
lo.add(new Object()); // 3
String s = ls.get(0); // 4: 试图将一个Object赋给一个String!
可见, 通过别名lo, 我们能对ls, 一个String的列表, 进行数据操作(特别是插入一个Object), 从而导致ls不仅仅是容纳了String对象! 这是Java编译器不容许的! 编译时, 第2行会报告一个编译错误的.
通常, 若Foo是Bar的一个子类型(子类或子接口), G是某个泛型声明, 则G<Foo>并不是G<Bar>的一个子类型.
假定要输出一个集合中的所有元素. 以下分别是旧版本及新版本(JDK 1.5)中的写法:
void printCollection(Collection c) {
  Iterator i = c.iterator();
  for( k = 0; k < c.size(); k++) {
    System.out.println( i.next() );
}}
void printCollection(Collection<Object> c) {
  for(Object e : c) {
    System.out.println(e);
}}
问题在于, 新版本反而不如旧版本更有用些. 因为旧版本能使用各种类型的集合作为参数, 但新版本则只能使用Collection<Object>. 而正如上节看到的, Collection<Object>并不是其它各种集合的超类型(父类型).
所有集合的超类型应该写作: Collection<?>, 读作: collection of unknown(未知集合), 即一个集合, 其元素类型可以与任何类型相匹配. 因此称这种类型为"通配类型".
正确实现上述旧版本的代码可以这么写:
void printCollection(Collection<?> c) {
  for(Object e : c) {
    System.out.println(e);
}}
这时, 可以用任意类型的集合来调用此方法. 注意在方法体中, 仍然从 c 中读入元素并赋给了Object, 这是没有错误的, 因此不论类型实参是何种集合, 它的元素都是object. 然而, 如果任意给它增加一个object则是不安全的:
Collection<?> c = new ArrayList<String>();
c.add(new Object()); // 编译时的错误
由于我们不知道c的元素类型是什么, 所以不能给它增加一个object. 方法add()接受一个类型E的参数, 而E与集合的元素类型相同. 当类型实参是?时, 它表示"未知的类型", 我们传递给add的参数必须是这个"未知类型"的子类型. 不幸的是, 既然类型未知, 也就无法决定其子类型, 于是什么也不能作为其参数. 唯一的例外是null, 因为null是所有类型的一个成员.
另一方面, 如果给了一个List<?>, 我们可以调用get()方法并使用其返回的元素. 虽然返回的元素类型是"未知类型", 但它总归是一个object, 因此将get()返回的元素赋给一个Object类型的变量, 或将其传递给一个可接受Object的参数都是安全的.
来自：http://pwosboy.javaeye.com/blog/118756
java SE 6 Beta 2 (Mustang) 有什么新东西? 有什么值得开发者关注?

简化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 是管理系统和资源之间的一个接口，它定义了管理系统和资源之间交互的标准。de style="margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 0px; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 0px; border-top-width: 0px; border-right-width: 0px; border-bottom-width: 0px; border-left-width: 0px; border-style: initial; border-color: initial; outline-width: 0px; outline-style: initial; outline-color: initial; font-size: 14px;">javax.management.MBeanServerde> 实现了 Agent 的功能，以标准的方式给出了管理系统访问 JMX 框架的接口。而 de style="margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 0px; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 0px; border-top-width: 0px; border-right-width: 0px; border-bottom-width: 0px; border-left-width: 0px; border-style: initial; border-color: initial; outline-width: 0px; outline-style: initial; outline-color: initial; font-size: 14px;">javax.management.MBeansde> 实现了 SubAgent 的功能，以标准的方式给出了 JMX 框架访问资源的接口。而从类库的层次上看，JMX 包括了核心类库 de style="margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 0px; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 0px; border-top-width: 0px; border-right-width: 0px; border-bottom-width: 0px; border-left-width: 0px; border-style: initial; border-color: initial; outline-width: 0px; outline-style: initial; outline-color: initial; font-size: 14px;">java.lang.managementde> 和 de style="margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 0px; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 0px; border-top-width: 0px; border-right-width: 0px; border-bottom-width: 0px; border-left-width: 0px; border-style: initial; border-color: initial; outline-width: 0px; outline-style: initial; outline-color: initial; font-size: 14px;">javax.managementde> 包。de style="margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 0px; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 0px; border-top-width: 0px; border-right-width: 0px; border-bottom-width: 0px; border-left-width: 0px; border-style: initial; border-color: initial; outline-width: 0px; outline-style: initial; outline-color: initial; font-size: 14px;">java.lang.managementde> 包提供了基本的 VM 监控功能，而 de style="margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 0px; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 0px; border-top-width: 0px; border-right-width: 0px; border-bottom-width: 0px; border-left-width: 0px; border-style: initial; border-color: initial; outline-width: 0px; outline-style: initial; outline-color: initial; font-size: 14px;">javax.managementde> 包则向用户提供了扩展功能。 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