jdk1.5新特性

1.静态导入：
    例如：System.out.println();输出语句，静态导入
    import static System.*;以后，只需要写成 out.println();
2.可变参数特点：
    只能出现在参数列表的最后，...位于变量类型和变量名之间，前后有无空格都可以；
    调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式方法可变参数。
3.for循环增强
    for(type 变量名：集合或数组变量名){...}
    如 for(String str: list){System.out.prinln(str);}
    注：集合必须是实现了Iterator接口的集合。
4.基本数据类型的自动拆箱与装箱
    Integer numObj = 3;//在jdk1.5版本以前是会报类型错误的。但是在jdk1.5版本以后，int类型的3，会自动装箱，
                    //提升为Integer类型
    int num = numObj + 2;//此处对numObj进行了自动拆箱操作，原型为Integer，拆箱后为int类型。
    享元模式(flyweight)：有很多个小的对象，他们有很多属性相同，所以把他们变成相同的一个对象，
    那些不同的属性就设为方法的参数。称之为外部状态。相同的属性称之为内部状态。
5.枚举
    //直接使用enum类型
    enum Sex1{
        woman,man;
    }
    案例:1
    //用枚举类型来Grade
    enum Grade{
        a("优秀"),b("良好"),c("一般"),d("及格"),e("不及格");//构造函数.
        private String val;
        public String getVal() {
            return val;
        }
        private Grade(String val){
            this.val=val;
        }
    }
    案例:2, 通过内部类来实现打印对应信息
    enum Grade2{
        a{
            @Override
            public String getInfo() {
                // TODO Auto-generated method stub
                return "优秀";
            }
        }
        ,b{
            @Override
            public String getInfo() {
                // TODO Auto-generated method stub
                return "良好";
            }
        }
        ,c{
            @Override
            public String getInfo() {
                // TODO Auto-generated method stub
                return "一般";
            }
        }
        ,d{
            @Override
            public String getInfo() {
                // TODO Auto-generated method stub
                return "及格";
            }
        }
        ,e{
            @Override
            public String getInfo() {
                // TODO Auto-generated method stub
                return "不及格";
            }
        }
        ;
        //提供一个函数去返回a对应的具体的值.
        abstract public  String getInfo();
            
    }
    案例3:把enum如何使用到 switch
    Grade g=Grade.a;
            
            switch(g){
            case a:
                System.out.println("aaa");
                break;
            case b:
                System.out.println("bbb");
                break;
                
        }
    枚举的几个常用方法举例:
    WeekDay wd=WeekDay.Tue;
    System.out.println(wd.name()+" "+wd.ordinal());
            
    WeekDay wd2=wd.valueOf("Mon");
    System.out.println(wd2.getLocaleDate());
            
    //遍历枚举值
    WeekDay wds[]=wd.values();
    for(WeekDay t: wds){
            System.out.println(t.getLocaleDate());
    }
6.注解：
    注解相当于一种标记，在程序中加了注解就等于为程序打上了某种标记，没加，则等于没有某种标记，
    以后javac编译器，开发工具和其他程序可以试用发射来了解你的类及各种元素上有无何种标记，
    看你有什么标记，就去干相应的事。标记可以加在包，类，字段，方法，方法的参数以及局部变量上。
    @SuppressWarnings("deprecation")//压缩警告：告诉虚拟机，我已近知道我有一个方法过时了。
    @Deprecated 用于标注此方法过时的标记
    @Override 用于标注此方法是覆盖父类的方法。

    注解就相当于一个你的源程序中要调用的一个类，要在源程序中应用某个注解，得先准备好了这个注解类。
    就像你要调用某个类，得先有开发好这个类。
    创建注解类：
    @Retetion(RetetionPolicy.RUNTIME)//表示此注解在内存中运行时被解析
    @Target(ElementType.METHOD)//表示此注解的目标为方法。就是只能用在方法上。
                            //此注解也可以写为@Target(ElementType.MEHTOD,ElementType.TYPE)
                            //表示此注解的目标为方法，或类。具体目标可以参考ElementType枚举的字段。
    @interface A{...}
    注解类上用到的注解成为“元注解”；
    RetetionPolicy.SOURCE、RetetionPolicy.CLASS、RetetionPolicy.RUNTIME：分别对应：
    java源文件-->class文件-->内存中的字节码。
为注解增加属性：
    如下自定义注解：
    @Retetion(RetetionPolicy.RUNTIME)
    @Target(ElementType.METHOD,ElementType.TYPE)
    @interface ItcastAnnotation{
        //如果方法的名为value，则在使用时，可以省略value="..",直接写成"..";
        String color() default "blue";//设定默认值为blue，默认值可以不设定。
        //添加数组的属性
        int[] arrayAttr() default {3,4,5};
    }
    应用到具体类上，如下：
    @ItcastAnnotation(color="red"，arrayAttr={1,2,3})
    class AnnotationTest{
        //获取注解对象
        ItcastAnnotation annotation = (ItcastAnnotation)AnnotationTest.class.getAnnotation(ItcastAnnotation.class);
        //获取注解的对应属性值。如color();
        String color = annotation.color();
    }
    注解中属性的返回值类型也可以是注解类。要用到此注解时，就要用到嵌套注解。
    注解中属性的返回值类型可以有以下几种:java基本数据类型和数组、注解类型、枚举类型、Class类型、String类型。
7.泛型：
    泛型：jdk1.5版本以后出现的新特性，用于解决安全问题，是一个类型安全机制。
    好处：
    1.将运行时期出现的问题ClassCastException，转移到了编译时期。
        方便与程序员解决问题，让运行时期减少问题。
    2.避免了强制转换的麻烦。

    泛型格式：通过<>来定义要操作的引用数据类型。
        在使用java提供的对象时，什么时候写泛型呢？
        通常在集合框架中很常见，只要见到<>就要定义泛型。例如 ArrayList<String> list= newArrayList<String>()
    *什么时候定义泛型类？
        当类中要操作的引用数据类型不确定的时候，早起定义Object来完成扩展。
        现在定义泛型来完成扩展。
    *简单泛型类：
        class Tool<QQ>{
            private QQ w;
            public void setObject(QQ w){
                this.w =w;
            }
            public QQ getObject(){
                return w;
            }
        }
        泛型类定义的泛型，在整个类中有效。如果被方法使用，
        那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
        为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。
    *简单的泛型方法:
        class Demo<T>{
            //此方法与类的泛型一致
            public void show(T t){
                //方法要执行的代码
            }
            //即使类不是泛型类，此方法依然可以存在。
            public <Q> void print(Q q){
                //方法内容
            }
        }
        特殊之处：
         静态方法不可以访问类上定义的泛型。
         如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。
        弊端：在泛型方法中不能使用对象的特有方法。
    *泛型定义在接口上：
        interface Inter<T>{
            void show(T t);
        }
        //在定义实现类的时候也不确定泛型类型，所以把实现类也定义成泛型类
        class InterImpl<T> implements Inter<T>{
            public void show(T t){
                System.out.println("show:"+t);
            }
        }

    *泛型限定：
       *class Person{
           private String name;
           Person(String name){
               this.name = name;
           }
           public String getName(){
               return name;
           }
        }
        class Student extends Person{

        }
        //为了能让以下方法能够被Person和Student类使用，此方法采用了泛型限定
        public static void printColl(ArrayList<? extends Person> al){
            Iterator<? extends Person> it = al.iterator();
            while(it.hasNext()){
                Syste.out.println(it.next.getName());
            }
        }
    *限定方式：？为通配符，也可以理解为占位符。
        <? extends E>：可以接受E类型或者E的子类型，上限。
        <? super E>：可以接收E类型或者E 的父类型。下限。
    *曾经的疑惑
        对于jdk1.6  API中的public TreeSet(Comparator<? super E> comparator)中的<? super E>
        假设E为Student，这里面<? super E>的意思是构造方法TreeSet(comparator)中的比较器，
        接收Student类或者Student的父类Person，都可以实现对Student的比较，
        因为多态可以提升Student的类型为Person。
    *利用反射获取泛型中的参数类型:
        public static void applyVector(Vector<Date> v1){
        }
        利用反射获取以上方法参数中集合的泛型类型
        Method applyMethod = Xxx.class.getMethod("applyVector",Vector.class);
        //获取带有泛型的参数类型的数组
        Type[] types = applyMethod.getGenericParameterTypes();
        //ParameterizedType 为Type类的子类。
        ParameterizedType pType = (ParameterizedType)types[0];
        //打印结果类型并人工验证
        System.out.println(pType.getActualTypeArguments()[0]);