`

jdk1.5之后新特性总结

阅读更多

           jdk1.5之后的一些新特性,特此总结一下,在java中,自从jdk1.5之后便出现了一些新特性
包括:泛型(Generic) ,注解,For-Each,自动拆箱和装箱,静态导入,格式化打印,枚举,可变参数...
1.泛型(Generic)和注解 

      泛型:

       在Java SE 1.5之前,没有泛型的情况的下,通过对类型Object的引用来实现参数的“任意化”,“任意化”带来的缺点是要做显式的强制类型转换,而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况,编译器可能不提示错误,在运行的时候才出现异常,这是一个安全隐患。
  泛型的好处是在编译的时候检查类型安全,并且所有的强制转换都是自动和隐式的,提高代码的重用率。
编辑本段规则和限制
  1、泛型的类型参数只能是类类型(包括自定义类),不能是简单类型。
  2、同一种泛型可以对应多个版本(因为参数类型是不确定的),不同版本的泛型类实例是不兼容的。
  3、泛型的类型参数可以有多个。
  4、泛型的参数类型可以使用extends语句,例如<T extends superclass>。习惯上称为“有界类型”。
  5、泛型的参数类型还可以是通配符类型。例如Class<?> classType = Class.forName("java.lang.String"); 
       注解:

       注解是程序向编译器传达某种编译信息的方式。比如对一些过时的方法,编译器在编译的时候会提醒程序员:此方法不推荐使用。但是程序员觉得看到这个提示很不爽,于是说:“哥玩了几十年的程序,这个都不知道吗?你不用给我提示了,我懂滴。”于是程序员在程序中嵌入一句
@SuppressWarnings("deprecated");这行代码表示关闭方法过时提示。于是编译器就乖乖的不提示了。这就是注解!
注解的语法,除了@符号的使用以外,它基本上与java的固有语法一致,java内置了三种
注解,定义在java.lang包中。
      @Override  表示当前方法是覆盖父类的方法。使用这个注解,是告诉编译器,这里必须是覆盖父类的方法。如果你发现不是覆盖父类方法的,请打断它的腿!
      @Deprecated  表示当前元素是不赞成使用的。若在程序中使用了这个注解,编译会提示这个方法过时,但可以运行。
      @SuppressWarnings 叫压缩警告,表示关掉编译器的某些警告。告诉编译器,你少罗嗦,照编译就可以了!
 
2.增强for循环(for-each)

Java代码 复制代码 收藏代码
  1. 用Iterator实现如下:   
  2.     import java.util.ArrayList;     
  3.     import java.util.Collection;     
  4.          
  5.     public class GenericTest {     
  6.         public static void main(String[] args) {     
  7.             Collection c = new ArrayList();    
  8.                 c.add("aa");     
  9.             c.add("bb");    
  10.                for(Iterator i=c.iterator(); i.hasNext();){   
  11.                   String s= (String)i.next();   
  12.                     System.out.println(s);     
  13.                  }   
  14.         }     
  15.     }     
  16.     运行结果:     
  17.     aa     
  18.     bb    


用for-each更简单:

Java代码 复制代码 收藏代码
  1. import java.util.ArrayList;     
  2. import java.util.Collection;     
  3.      
  4. public class GenericTest {     
  5.     public static void main(String[] args) {     
  6.         Collection<String> c = new ArrayList<String>();     
  7.                c.add("aa");     
  8.         c.add("bb");     
  9.                for(String s:c){     
  10.             System.out.println(s);     
  11.         }     
  12.     }     
  13. }     
  14. 运行结果:     
  15.  aa     
  16.  bb    



3.自动装箱拆箱(Autoboxing/unboxing)

例3-1代码
自动装箱拆箱大大方便了基本类型数据和它们封装类地使用。
  自动装箱:基本类型自动转为封装类.(int >> Integer)
  自动拆箱:封装类自动转为基本类型.(Integer >> int)

  在JDK1.5之前,我们总是对集合不能存放基本类型而耿耿于怀,
  现在自动转换机制解决了我 们的问题。
  int a = 3;
  Collection c = new ArrayList();
  c.add(a);//自动转换(装箱)成Integer.

  Integer b = new Integer(2);
  c.add(b + 2);
  这里Integer先自动转换(拆箱)为int进行加法运算,然后int再次转换(装箱)为Integer.

Java代码 复制代码 收藏代码
  1.  public class T {     
  2.       
  3.      public static void main(String[] args) {     
  4.          Integer i1 = 128;     
  5.          Integer i2 = 128;     
  6.          int i3 = 128;     
  7.          int i4 = 128;     
  8.          Integer i5 = 127;     
  9.          Integer i6 = 127;     
  10.              
  11.         Long long1 = 128L;     
  12.         Long long2 = 128L;     
  13.         long long3 = 128L;     
  14.         long long4 = 128L;     
  15.        long long5 = -128L;     
  16.         long long6 = -128L;     
  17.              
  18.        //-128 ~ 127之间数值装箱时会共享内存副本, 超过这个范围,则不会共享引用,即对象地址将不同     
  19.              
  20.         System.out.println(i1 == i2); //实质是比较两个不同引用 false     
  21.        System.out.println(i5 == i6); //实质是比较两个相同(共享)引用true     
  22.        System.out.println(i1 == i3); //先将i1拆箱,然后比较基本类型 true     
  23.        System.out.println(i1.equals(i4)); //先将i4装箱,然后比较基本类型 true     
  24.             
  25.        System.out.println(long1 == long2);//两个引用不同 false     
  26.        System.out.println(long5 == long6);//共用副本 true     
  27.        System.out.println(long1 == long3);//long1先拆箱, 在比较 true     
  28.         System.out.println(long2.equals(long4));//long4先装箱, 再equals, true     
  29.     }     
  30. }    


  31. 4.静态导入(static import)

          要使用用静态成员(方法和变量)我们必须给出提供这个方法的类。使用静态导入可以使被导入类的所有静态变量和静态方法在当前类直接可调用,使用这些静态成员无需再给出他们的类名。
Java代码 复制代码 收藏代码
  1.     //静态导入Math的所有方法     
  2.     import static java.lang.Math.*;     
  3.          
  4.     public class StaticImportTest {     
  5.         public static void main(String[] args){     
  6.             //类中生成随机数数可以直接使用静态引入的random方法了,而不用Math.random()这样调用了     
  7.             System.out.println(random());     
  8. 又:   
  9.                 System.out.println(max(36));//无需写Math.max();   
  10.                  r = sin(PI * 2); //无需再写r = Math.sin(Math.PI);    
  11.         }     
  12.     }    


5.格式化打印(formatted print)

C语言中printf()风格的格式化输出。
这里只举一个thinking in java的一个例子:
例5-1代码

Java代码 复制代码 收藏代码
  1. public class SimpleFormat {     
  2.     public static void main(String[] args) {     
  3.         int x = 5;     
  4.         double y = 5.332542;     
  5.         //The old way     
  6.         System.out.println("Row 1: ["+x+" "+y+"]");     
  7.         //The new way     
  8.         System.out.format("Row 1: [%d %f]\n", x,y);     
  9.         //or     
  10.         System.out.printf("Row 1: [%d %f]\n", x, y);     
  11.     }     
  12. }     
  13.      
  14. 运行结果:     
  15. Row 1: [5 5.332542]     
  16. Row 1: [5 5.332542]     
  17. Row 1: [5 5.332542]      


可以看到,format和printf是等价的,他们只需要一个简单的格式化字符串,加上一串参数即可,每个参数对应一个格式修饰符

6.枚举(Enums)

  JDK1.5加入了一个全新类型的“类”-枚举类型。为此JDK1.5引入了一个新关键字enmu. 我们可以这样来定义一个枚举类型。
当每一类型可取值范围是有限的时候,可以使用枚举,例如每个学生登记只能用ABCD表示,如果直接用E的话,那么编译不会出错,但是却不符合输入要求,而使用枚举增加程序的易读性和健壮性?
Java代码

Java代码 复制代码 收藏代码
  1. public class GradeTest {     
  2.        public static void main(String[] args) {     
  3.         Student stu = new Student();     
  4.         stu.setName("wasw100");     
  5.         stu.setGrade(Grade.A);     
  6.         //输出学生信息     
  7.         System.out.println(stu);     
  8.     }     
  9. }     
  10.          
  11.     /**   
  12.      * 枚举:Grader 学生考试等级   
  13.      * @author wasw100   
  14.      */     
  15.     enum Grade{     
  16.         A,B,C,D     
  17.     }     
  18.          
  19.     class Student {     
  20.         private String name;     
  21.         private Grade grade;     
  22.              
  23.         //重写toString()方法     
  24.         public String toString(){     
  25.             return "name:+"+name+"\ngrader:"+grade;     
  26.         }     
  27.          
  28.         public String getName() {     
  29.             return name;     
  30.         }     
  31.          
  32.         public void setName(String name) {     
  33.             this.name = name;     
  34.         }     
  35.          
  36.         public Grade getGrade() {     
  37.             return grade;     
  38.         }     
  39.          
  40.         public void setGrade(Grade grade) {     
  41.             this.grade = grade;     
  42.         }     
  43.          
  44.     }    


  45. 7.可变长参数(varargs)

    可变参数使程序员可以声明一个接受可变数目参数的方法。
    注意,可变参数必须是函数声明中的最后一个参数。
    假设我们要写一个简单的方法打印一些对象,在jdk1.5以前我们需要重载多个方法

    util.write(obj1);
    util.write(obj1,obj2);
    util.write(obj1,obj2,obj3);


      在JDK1.5之前,我们可以用重载来实现,但是这样就需要写很多的重载函数,显得不是很有效。如果使用可变参数的话我们只需要一个函数就行了

    public void write(Object... objs) {
       for (Object obj: objs)
          System.out.println(obj);
    }
    下面是一个唐僧给悟空讲佛经的例子
     Java代码 复制代码 收藏代码
  1. public class VarargsTest {     
  2.     public void speak(String name, Object... arguments) {     
  3.         System.out.print(name+": ");     
  4.         for (Object object : arguments) {     
  5.             System.out.print(object);     
  6.         }     
  7.         System.out.println();     
  8.     }     
  9.     
  10.     public static void main(String[] args) {     
  11.         VarargsTest vt = new VarargsTest();     
  12.         vt.speak("悟空""人和妖精都是妈生的,");     
  13.         vt.speak("悟空""不同的人是人他妈生的,""妖是妖他妈生的,");     
  14.     }     
  15. }     
  16.      
  17. 运行结果:     
  18. 悟空: 人和妖精都是妈生的,     
  19. 悟空: 不同的是,人是人他妈生的,妖是妖他妈生的,    
分享到:
评论

相关推荐

    JDK1.5中新的语言特征分类介绍

    总结来说,JDK 1.5中引入的一系列新特性极大地改善了Java语言的灵活性和安全性,同时也使得开发者的编程工作变得更加高效和简便。这些特性不仅提高了代码的质量,还增强了程序的可维护性和可读性。

    jdk1.5 线程并发与线程池的使用

    在Java编程语言中,线程并发和线程池是多任务执行的核心概念,尤其是在JDK 1.5及以后的版本中得到了显著增强。线程并发允许程序同时执行多个任务,提高了程序的效率和响应性。线程池是管理线程资源的有效方式,通过...

    Annotation(注解)详细教程,jdk新特性

    Annotation(注解)是Java编程语言的一个重要特性,自JDK 1.5引入以来,逐渐成为编写可维护和可扩展代码的关键工具。注解提供了一种方式,使得程序员可以在代码中添加元数据(metadata),这些数据不直接影响代码...

    JDK源码(sun包)

    虽然在JDK 9及以后的版本中,sun包被标记为非公开和不推荐使用的,但在早期版本如JDK 1.5中,它对开发者具有很高的参考价值。 1. **JDK 1.5 版本特点** JDK 1.5,也被称为Java SE 5.0,引入了许多重要的语言特性,...

    jdk1.8下载附安装教程.zip

    3. `CLASSPATH`:虽然在JDK 1.5之后,Java引入了模块化系统,使得默认的类加载机制更加智能,但为了兼容旧代码,有时仍需配置`CLASSPATH`。一般情况下,无需特别设置,但若有必要,可以添加JRE的lib目录,如`.;%JAVA...

    java JDK1.7版本下载

    - `CLASSPATH`:一般无需手动设置,JDK1.5之后,默认使用`.`作为当前目录,会自动查找。 4. **验证安装**:打开命令行,输入`java -version`,如果显示JDK1.7的信息,表示安装成功。 三、注意事项 1. **兼容性**...

    java遍历特例

    ### Java遍历特例知识点...无论是传统的迭代器还是JDK 1.5之后引入的增强for循环,都为开发者提供了便利的工具来高效地处理键值对数据。此外,通过`TreeMap`还可以实现自动排序的功能,这对于特定的应用场景非常有用。

    经典Java多线程与并发库高级应用

    总结来说,Java多线程与并发库的高级应用,既包括了传统的多线程编程技术,也包含了JDK 1.5之后引入的高级并发工具和特性。掌握这些知识点对于任何想要在Java编程领域深入发展的开发者来说,都是非常必要的。

    java面试八股文java基础知识总结.pdf

    - **jdk1.5之后的三大版本**:自JDK 1.5以来,重要的三个版本包括: - **JDK 1.6**:引入了并发工具类如`ConcurrentHashMap`等改进。 - **JDK 7**:增加了多核心处理器支持,引入了`try-with-resources`语句等。 ...

    javaSE基础笔记

    - **JDK版本**: JDK 1.5(也称为Java 5)是Java的一个重要版本,引入了许多新特性,如泛型、枚举、可变参数等。 - **兼容性**: - 高版本的JDK可以运行由低版本JDK编译的程序。 - 低版本的JDK无法运行由高版本JDK...

    Android SDK 2.2 + Eclipse开发环境图文详解

    - 要求:JDK 1.5及以上版本,推荐使用JDK 6.x。 - 下载地址:[http://java.sun.com/javase/downloads/index.jsp](http://java.sun.com/javase/downloads/index.jsp) - 安装指导:下载后,根据向导完成安装过程。...

    HelloWorld (4).pdf

    此外,CLASSPATH变量用于指定类加载路径,但自JDK1.5起,可不配置此变量,JVM会默认在当前目录下寻找类文件。 编写第一个Java程序是每个Java学习者的重要里程碑。创建一个包含主函数的.java文件后,编写代码并使用...

    J2EE应用开发环境介绍及搭建[收集].pdf

    总结来说,J2EE开发环境的搭建主要包括选择和配置开发工具(如Eclipse和MyEclipse)、安装JDK并设置环境变量、以及选择和配置Web应用服务器(如Tomcat)。这个环境为Java开发者提供了高效、便捷的开发体验,使得构建...

    GEF-whole-upload.pdf

    在使用GEF进行图形编辑时,建议使用JDK 1.5或以上版本,因为较低版本的JDK可能无法完全支持EMF处理XML模型所需的所有功能。EMF是GEF中用于模型管理和元数据定义的关键组件,确保使用兼容的JDK版本可以避免潜在的运行...

    Java枚举(enum) 详解7种常见的用法

    Java中的枚举(enum)是自JDK 1.5版本引入的一种强大的类型,它不仅提供了定义常量的简洁方式,还能实现许多高级功能。以下将详细介绍7种常见的Java枚举用法: 1. **常量用法**: 在JDK 1.5之前,我们通常使用`...

    Java反射机制 Java反射机制

    Java反射机制在JDK 1.1版本中就已经引入,但在JDK 1.5之后得到了进一步增强和完善,增加了泛型支持等功能,使得反射更加安全和强大。 #### 三、Java反射机制的核心概念与应用 1. **核心概念** - **Class对象**:...

    蓝桥杯JAVA试题

    需要注意的是,题目还规定了一些其他的要求,如不使用`package`语句,源程序只能使用JDK1.5及以下版本允许的语法,不能使用1.6或更高版本的特性。这个代码示例遵循了这一要求,没有引入1.6以后的语法。 总结起来,...

    详细的java基础总结

    - 2004年:发布了Java 5(即JDK 1.5),这一版本带来了泛型、枚举、增强for循环等新特性。 - 2006年:发布了Java 6(即JDK 1.6),进一步优化了性能,并添加了一些新的API。 - **Java体系** - **Java SE ...

Global site tag (gtag.js) - Google Analytics