A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 丶小天 中级黑马   /  2014-2-19 23:26  /  1039 人查看  /  0 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

一)自动装箱/拆箱(Autoboxing/unboxing):

  自动装箱:基本类型自动转换为包装类;
  自动拆包:包装类自动转换为基本类型。

二)静态导入(Static import):

  无需在使用其他类的静态成员变量前缀其类名.这将使得代码更为简洁。
  JDK1.5 以后新增加一种静态导入语法,用来导入指定类的某个静态属性值或全部静态属性值。
静态导入语句使用 import static 语句,静态导入也有两种语法,分别用于导入指定类的单个静态属性和全部静态属性。
导入指定类单个静态属性的语法格式如下:

  1. import static package.subpackage...ClassName.fieldName;
复制代码


导入指定类的全部静态属性的语法格式如下:

  1. import static package.subpackage...ClassName.*;
复制代码


代码:

  1. import static java.lang.System.*;
  2. import static java.lang.Math.*;
  3. public class TestStaticImport{
  4.         public static void main(String[] args){
  5.         // out 是 java.lang.System 类的静态属性,代表标准输出
  6.         // PI 是 java.lang.Math 类的静态属性,表示 π 常量
  7.                 out.println(PI);
  8.         }
  9. }
复制代码


三)可变参数(Varargs):

  可变参数是jdk1.5提供的新特性,就是一个方法接受的参数个数不固定,下面一个简单的例子:

  1. public class VarParameter {

  2.         public static void main(String[] args) {
  3.                 System.out.println(add(2, 3));
  4.                 System.out.println(add(2, 3, 5, 8));
  5.         }

  6.         public static int add(int x, int... args) {
  7.                 int sum = x;
  8.                 for (int i = 0; i < args.length; i++) {
  9.                   sum += args[i];
  10.                 }
  11.                 return sum;
  12.         }
  13. }
复制代码


输出:5,18

  可变参数的特点:

  1.只能出现在参数列表的最后:
  2. ...位于变量类型和变量名之间,前后有无空格都可以:
  3.调用可变参数的方法时,编译器为该可变参数隐含创建一个数组,在方法体中以数组的形式访问可变参数。

四)增强的for循环(Enhanced For loop):

  减少迭代器(iterator)的潜在错误(error-proneness) 。


五)泛型(Generics):

  为集合(collections)提供编译时类型安全,无需每刻从Collections取得一个对象就进行强制转换(cast) 。

六)枚举(Enums):

  枚举就是要让某个类型的变量的取值只能为若干个固定值的一个,否则,编译器就会报错。枚举可以让编译器在编译时就可以控制源程序中填写的非法值,而使用普通变量的的方式在开发阶段无法实现这一目标。

  用普通类如何实现枚举功能,定义一个Weekday的类来模拟枚举功能:

  1. 私有的构造方法,防止任意实例化。
  2. 每个元素分别用一个公有的静态成员变量表示。
  3. 采用抽象方法定义nextDay就将大量的if else 语句转移成了一个个独立的类(在这里用到了内部类的概念)
  4. 如果想在一个类中编写各个枚举类和测试调用类,可以将枚举类定义成调用类的内部类。

  枚举元素必须位于枚举体中的最开始部分,枚举元素列表的后面要有分号与其他成员分隔。

  枚举的构造方法,必须定义成私有的。默认调用无参构造方法。

  枚举就相当于一个类,其中也可以定义构造方法、成员变量、普通方法、和抽象方法。

  每一个元素分别是枚举类的一个实例:

  1. public class EnumTest {
  2.         public static void main(String[] args) {
  3.         System.out.println(WeekDayEnum.MON.name().toString());
  4.         System.out.println(WeekDayEnum.MON.ordinal());                //ordinal序数从0开始
  5.         System.out.println(WeekDayEnum.MON);
  6.         System.out.println(WeekDayEnum.values().length);
  7.         System.out.println(WeekDayEnum.valueOf("MON"));
  8.         System.out.println(lamp.RED.nextLamp());
  9.         }
  10. }

  11. //定义一个一般的枚举——星期
  12. public enum WeekDayEnum{
  13.         SUN,MON,TUE,WED,THI,FRI,SAT
  14. }
  15.        
  16. //定义一个带抽象方法、构造函数、成员变量、普通方法的枚举——交通灯枚举

  17. public enum lamp{
  18.         RED (50){
  19.                 @Override
  20.                 public lamp nextLamp() {
  21.                         return lamp.GREEN;
  22.                 }
  23.         },GREEN(50) {
  24.                 @Override
  25.                 public lamp nextLamp() {
  26.                         return lamp.YELLOW;
  27.                 }
  28.         },YELLOW (5){
  29.                 @Override
  30.                 public lamp nextLamp() {
  31.                         return lamp.RED;
  32.                 }
  33.         };                                                              

  34.         int time;                                                        //成员变量
  35.         lamp(){}                                                        //无参构造函数
  36.         lamp(int time){this.time=time;}                //带参构造函数
  37.         public abstract lamp nextLamp();
  38.         }
  39. }
复制代码


以上是JDK1.5的六个基本新特性,接下来继续介绍JDK1.5另外一个秘密武器,新的注释语法(Annotations):

  其实说起注解语法,对于任何一个Java开发人员来说都已经耳熟能详了,我们每天都在使用着 @author, @param,等等编写注释,然后用javadoc生成文档。Java的这种方便的文档生成方法受到了开发者的普遍赞誉。而从JDK1.5开始,注释语法提供了更为强大的功能。

  我们先谈谈注释语法本身,它有时候也称为meta-data  :“描述数据的数据”。一般来说它们可以被用来生成文档,检查代码间依赖关系,帮助编译器作语法检查。时下比较流行的工具有Xdoclet等。对于文档生成早已经有了javadoc工具的完美表现,而对于代码检查,如今java也提供了语言级的支持。
   
  我们知道,javadoc是通过提取java源文件中的标签信息来生成文档。所以要学习新的注释语法,们首先要熟悉的就是新增的标签。新的注释语法支持两种标签,系统标准标签和用户自定义标签。标签的符号也原先一样,@符号加上标签名字。我们先从JDK1.5自带的标准标签说起。

  首先介绍@override,也不用多罗嗦,顾名思义了,就是用来说明方法覆载的。我们假设有一个子类必须要覆载父类的方法:

  1. public class Parent{

  2.     public void foo(){
  3.         System.out.println("Original Implementation of foo");
  4.     }

  5. }

  6. public class Child extends Parent{

  7.     @Override
  8.     public void foo(){
  9.         System.out.println("Overide Implementation of foo");
  10.     }

  11. }
复制代码


目前为止我们看不出来这个@Override给我们带来了任何好处,所以我们先说说加个这个标签后,我们用javac编译的时候编译器执行了些什么呢?编译器会检查这个方法,然后从父类查找是否有这个方法,否则就编译出错。这个特性可以帮助我们避免一些低级错误。上面这个例子,子类想覆载foo()方法,不过你可能一时疏忽把它写成了fob(),对于这样的“低级错误”,如果你没有在前期就发现的话,到系统集成测试的时候,可能会化上你几个小时甚至一两天去找出这样的bug。现在好了,编译器在编译的时候就会给出错误:

   Child.java:3: method does not override a method from its superclass
   @Override
    ^
  1 error

  怎么样,这个功能还不错吧。

  看过了标准标签的使用方法,我们来看看用户自定义标签。首先介绍@interface, 它用于定义新的注释类型(annotation type)。新建一个注释类型看起来和定义一Interface 没有什么两样,

  MyTag.java用于新建一个用户自定义标签,代码如下,

  1. package tiger.annotation;
  2. /**
  3. * 用户自定义标签:MyTag
  4. */
  5. public @interface MyTag { }

  6. 定义了一个tag之后,我们就可以在任何java文件中使用这个tag了,
  7. import tiger.annotation.MyTag;
  8. public class TagTest{
  9.    
  10.     @MyTag
  11.     public void testTag(){
  12.     }
  13. }
复制代码


注释类型还可以有成员变量,

  1. package tiger.annotation;
  2. /**
  3. * 用户自定义标签:带有成员变量的MyTag
  4. */
  5. public @interface MyTag {

  6.     String name();
  7.     int age();
  8. }
复制代码


  然后我们可以这么使用这个标签,

  1. @MyTag(name="MyTag",age=1)
  2.     public void testTag(){
  3.     }
复制代码


使用标签最终是为了帮助开发人员提取注释信息,然后根据不同需求做进一步处理,下面我们来看看如何获取注释信息。

  1. import java.lang.annotation.Annotation;
  2. import tiger.annotation.MyTag;
  3. public class TagTest{
  4.    
  5.     @MyTag(name="MyTag",age=1)
  6.     public void test(){
  7.     }

  8.     public static void main(String[] args){
  9.         TagTest tt = new TagTest();
  10.         try {
  11.             Annotation[] annotation =tt.getClass().getMethod("test").getAnnotations();
  12.             for (Annotation tag :annotation)  {            
  13.               System.out.println("Tag is:" + tag);
  14.               System.out.println("tag.name()" + ((MyTag)tag).name());
  15.               System.out.println("tag.age()" + ((MyTag)(tag)).age());
  16.              }
  17.          } catch(NoSuchMethodException e) {
  18.              e.printStackTrace();
  19.          }
  20.     }
  21. }
复制代码


需要注意的一点是,在执行这段代码之前我们还有一点小工作要做,还需要给我们的自定义标签MyTag加上一个说明标签,@ Retention, 表明注释信息将可以在运行时刻通过反射机制得到。如果不加入这个标签,上面的代码将没有任何输出。修改以后的MyTag如下:

  1. /**
  2. * 用户自定义标签:带有成员变量的MyTag
  3. */
  4. @Retention(RetentionPolicy.RUNTIME)
  5. public @interface MyTag {

  6.     String name();

  7.     int age();
  8. }
复制代码


然后我们执行TagTest可以得到输出如下,

   Tag is:@tiger.annotation.MyTag(name=MyTag, age=1)
   tag.name()MyTag
   tag.age()1

  好了,Tiger新的注释语法基本用法就这么简单,基本用法虽然简单。

评分

参与人数 1技术分 +1 收起 理由
何伟超 + 1

查看全部评分

0 个回复

您需要登录后才可以回帖 登录 | 加入黑马