黑马程序员---JDK1.5新特性

------- Java、.Net、Android培训期待与您交流！------- 

一、静态导入

        导入某个工具类中的所有静态方法：import static java.lang.Math.* 。不过这个特性用的少，毕竟我们不能把工具类的方法都记住，还是需要通过 类名.  的形式通过内容辅助的快捷键来快速的浏览该工具类的静态方法。

        如：max(2, 5);  abs(3 - 6)

二、可变参数

        特点：① 只能出现在参数列表的最后，所以一个方法最多只能有一个长度可变的参数；

                    ② ... 位于参数类型和参数名之间，前后有无空格均可；

                    ③ 调用可变参数方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数。

        示例：

                     String[] strs = {"a", "b", "c"};
                     List<String> list1 = Arrays.asList(strs);
                     System.out.println(list1);   //打印：[a, b, c]
                     list1 = Arrays.asList("d","e","f");  //可变参数
                     System.out.println(list1);   //打印：[d, e, f]
  
                     int[] arr = {1, 2, 3};
                     List list2 = Arrays.asList(arr);
                     System.out.println(list2);   //打印：[[I@108ea49]
                     list2 = Arrays.asList(4,5,6);  //可变参数
                     System.out.println(list2);   //打印：[4, 5, 6]

        特殊处：集合中存放的都是对象，所以对于基本数据类型的数组只会将数组作为一个对象存入集合中，即引用所指的地址值，而对于其他类型的数组(如 Integer)则会先将数组拆包后，在存入集合中，因为数组中的元素仍是一个对象。对于最后的 Arrays.asList(4,5,6);  JVM 会将可变参数进行装箱后在存入集合中，所以打印出的不是对象在内存中的地址值。

三、增强 for 循环

       语法格式：

              for(变量类型 变量 : 需迭代的数组或实现了Iterator接口的集合){
 
              }

       特点：简化书写。

       该变量可悲一些修饰符所修饰，如 final：for(final int arg : args){ } ，这么定义则该for语句内的内部类就可以访问 arg 变量。局部位置上的内部类只能访问被 fianl 修饰的局部变量，同时还可以访问外部类中的成员变量，因为该内部类还是持有一个访问外部类的引用，格式：外部类 . this 。

       注：增强 for 循环只适合对数据的查询，不能原数据进行修改。所以要对原数据进行修改，只能使用传统 for 循环。

       示例：

                   List list = new ArrayList<>();
                   list.add("abc");
                   list.add("def");
                   for(Object obj : list){
                            obj = "xyz";
                   }
                   System.out.println("list="+list);//打印结果：list=[abc, def]

四、基本数据类型的装箱、拆箱和享元模式

       在JDK1.5之前将一个基本数据封装成对象：Byte b1 = new Byte( 127 );

       JDK1.5之后：Byte b2 = -128;  //装箱：将基本类型数据自动封装成 Byte 类型的对象。

                                byte b3 = b2;  //拆箱：将对象 b2 拆箱转成基本类。

       享元模式  flyweight：很多个小的对象，它们有很多相同的属性，把这些相同的封装成一个对象，把那些不同的属性变成方法的参数，称之为外部状态，那些相同的属性称之为内部状态。降低了对内存的消耗。

       在JDK1.5 中将数值在（-128~127）之间的数据进行了对象的封装，只要某个基本数据类型的对象指向这数值间的一个数，那么这些对象的地址值都指向同一个已经存在的对象，与字符串池中的字符串对象一样的操作。

       示例：Integer a1 = 127;
                   Integer a2 = 127;
                   a1 == a2;  //返回true。

五、枚举

  1、作用：一些程序在运行时，它需要的数据不能是任意的，而必须是一定范围内的值，也就是限定了某个类型 的变量的取值只能是规定的若干个。JDK1.5 前采用自定义类来解决，JDK1.5 以后可以直接采用枚举解决。

  2、普通类实现枚举的方式：以类 WeekDay 为例。

        (1) 将构造方法私有化：private WeekDay(){};

        (2) 每个元素分别用一个公有的静态常量表示；

        (3) 可以有若干个公有方法或抽象方法。例如，提供nextDay 方法，必须是抽象的。这样做方便每个对象分别实现自身特有的功能。

        示例：

                    public static final WeekDay SUN = new WeekDay(){
                            public WeekDay nextDay(){
                                    return MON;
                            }
                    };
                    public final static WeekDay MON = new WeekDay(){
                            public WeekDay nextDay() {
                                    return TUE;
                            }
                    };
                    public final static WeekDay TUE = new WeekDay(){
                            public WeekDay nextDay() {
                                    return WED;
                            }
                    };

  3、枚举的特性

        (1) 枚举是一种特殊的 Java 类。

        (2) 枚举中声明的每一个枚举值代表枚举类的一个实例对象。

        (3) 枚举类中也可以有构造方法，字段，普通方法和抽象方法，但枚举的构造函数必须私有化。

        (4) 枚举也可以实现接口或继承抽象类。

        (5) JDK1.5 扩看了switch 语句，他除了可以接收 int, byte, char, short 外，还可以接收枚举类型。

        (6) 若枚举类只有一个值，则可以当作单例设计模式使用。

  4、常用方法

       java.lang.Enum 是 Java 中所有枚举类的超类。常用方法有：name() ， oridinal()返回枚举常量的序数，valueOf(Class<T> enumType, String name)该方法是讲一个字符串转成一个枚举类对象，values()该方法在JDK文档中找不到，但每个枚举类都具备该方法，用来遍历枚举类的所有枚举常量，并将返回的值封装进枚举类数组中。

       需求：用枚举实现对0~100分进行分段，对应为9-100：优，80-89：良，70-79：中，60-69：及格，0-59：差。

       枚举类部分代码：

       public enum Grade {
              A("90-100") {
                     @Override
                     public String localValue() {
                            return "优";
                     }
              },
              B("80-89") {
                     public String localValue() {
                            return "良";
                     }
              },
              .
              .
              .;
              private String value;
              private Grade(String value) {
                     this.value = value;
              }
              public String getValue() {
                     return value;
              }
              public abstract String localValue();
       }

       测试代码：

       @Test
        public void test(){
              print(Grade.B);
        }
       public void print(Grade value){
              System.out.println(value.ordinal()); //1
              System.out.println(value.name());  //B
              System.out.println(value.localValue());//良
              System.out.println(Grade.values().length);//5
              System.out.println(Grade.valueOf("D").localValue());//及格
       }