黑马程序员-java高新之1.5新特性

--------------------- android培训、java培训、java学习型技术博客、期待与您交流！ -------------------

JDK1.5新特性

概述：2004年sun发布了我们期待已久的jdk1.5同时，将jdk1.5命名为j2se5.0，sun之所以将版本号1.5改为5.0，也就预示着较之前的版本有着很大的改变，jdk1.5的一个重要主题就是增加了一些新特性来进行开发，包括泛型、增强for循环、枚举、静态导入、可变参数、自动拆装包等

Java升级三要素

1提高效率

2简化书写

3提高安全性

泛型：

概述：java在1.5之前一直没有相对应的功能，在集合中可以存放任何类型的对象，相应的从集合中那对象时，我们也不得不对它们进行强制转换得到数据类型。一般来说，集合中存放的都是同一类型的对象，而具体存放的是什么对象，在java1.5之前只能由程序员通过主观判断来确定存放的对象类型，比较麻烦。1.5加入泛型之后，它可以指定集合中存储的对象的类型，这样在编译时，如果强制转换出了问题就会在编译时指出，不会等到客户拿到代码啊行时报错

格式<T> 当类或接口中带有<T>时，在使用该类或接口时，必须在<>中传递一个具体的引用数据类型

特点：将运行时出现的问题转移到了编译期，方便于程序员解决问题，让运行时问题减少

代码示例：

class GenericAdvanceDemo

{

public static void main(String[] args)

{

              ArrayList<String> al = new ArrayList<String>();

              al.add("abc");

              al.add("hehe");

              ArrayList<Integer> al2 = new ArrayList<Integer>();

              al2.add(5);

              al2.add(67);

             

}

}

定义位置

泛型类定义的泛型，在整个类中有效，泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了

为了让不同方法操作不同类型，而且类型还不确定，可以将泛型定义在方法上，当类上定义的泛型与方法上定义的泛型冲突时，以方法上定义的泛型为主。

特殊之处

静态方法不可以访问类上定义的泛型，如果静态方法操作的数据类型不确定时，可以将泛型定义在方法上。

代码示例将泛型定义在接口上

interface Inter<T>

{

       public void show(T t);

}

class InterImpl implements Inter<String>

{

       public void show(String str)

{

              System.out.println("show :"+str);

       }

}

代码示例将泛型定义在静态方法上

       class inter<String>

{

public static<String>void show1(String s)

{

       System.out.println(s);

 

}

 

public static <char>void show2(char a)

{

       System.out.println(a);

}

}

通配符：也可以理解为占位符，可以解决当具体类型不确定时，这个通配符就是?；

泛型限定：

              <? extends E>可以接受E和E的子类类型上限

<? super E>   可以接受E和E的父类类型下限

代码示例

public static void printCollection(Collection<? extends Person> al)

{                                                                                                                                                 Collection<Student> al = new ArrayList<Student>()

              Iterator<? extends Person> it = al.iterator();

             

              while(it.hasNext())

{

                     Person p = it.next();

                     System.out.println(p.getName()+":"+p.getAge());

              }

}    

注意：

        使用带泛型的类创建对象时，等式两边指定的泛型必须一致

增强for循环

1概述：foreach语句，简化了for循环，当取出集合中的元素时也可以用高级for循环来替代迭代器，简化操作,被迭代的容器必须实现Iterable接口。

2格式：

              for(元素类型变量名：被迭代的单列集合或数组)

{

       执行语句

}

注意：在迭代时增强for是不能改变容器中的元素的

 

3高级for循环和传统for循环的区别：

高级for循环在使用时，有局限性，必须要明确被遍历的目标。这个目标，可以是Collection集合或者数组，且遍历时只能进行取出操作

如果遍历数组，还需要对数组元素进行操作，建议用传统for循环因为可以定义角标通过角标操作元素。如果只为遍历获取，可以简化成高级for循环，它的出现为了简化书写。

增加for循环迭代数组代码示例

int[] arr = {1,2,3};

for(int num : arr)

{

    System.out.println(arr[num]);

}

增加for循环替代Iterator迭代器迭代List集合代码示例

List list = new ArrayList();

list.add("aaa");

list.add("abb")

list.add("abc")

for(Object obj : list)

{

      String s = (String) obj;

      System.out.println(s);

}

增强for循环迭代Map集合，Map集合没有实现Iterable接口，是无法使用增强for循环的，但Map集合取出时都是先转成Collection集合，转成Collection后再用增强for迭代

代码示例

for(Object obj : map.entrySet()) {

    Map.Entry entry = (Entry) obj;  // obj依次表示Entry

    System.out.println(entry.getKey() + "=" + entry.getValue());

}

枚举

概述：用关键字enum修饰枚举就相当于一个类，其中也可以定义构造方法、成员变量、普通方法和抽象方法。枚举元素必须位于枚举体中的最开始部分，枚举元素列表的后要有分号与其他成员分隔。把枚举中的成员方法或变量等放在枚举元素的前面，编译器报告错误。

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

       枚举应用代码示例

class EnumDemo

{

       Public enum WeekDay

{

       SUN,MON,TUE,WED,THI,FRI,SAT

}

public static void main(String[] args)

{

       WeekDay weekday1 = WeekDay.TUE;

       System.out.println(WeekDay.nextDay());

       WeekDay weekday2 = WeekDay.SUN;

       System.out.println(WeekDay2.);//打印结果为SUN

       System.out.println(WeekDay2.name());//打印结果为SUN

       System.out.println(WeekDay2.ordinal());//打印结果为6

       System.out.println(WeekDay2.valueOf("SUN").toString());//打印结果为SUN

       System.out.println(WeekDay2.values().length);//打印结果为7

 

 

 

}

}

 

静态导入

概述：import static关键字

导入类时导入的是该类中所有的静态的静态成员

导入包时导入的是该包中所有的静态成员

       当类重名时需要指定包名

       当方法重名时需要指定所属对象或类名

与import的区别

import导入的是的类

import static导入的是静态成员

代码示例

import static java.util.Arrays.*

class StaticImport extends Object

{

       public static void main(String[] args)

{

       int [] arr={6,3,7};

       sort(arr);

       int index = binatySearch(arr,1);

       System.out.println(Arrys,toString(arr));

System.out.println("index ="+ index);

}

}

可变参数

概述：其实就是数组参数的简写形式，java1.5之前只能传数组参数，需要先将要传入的多个参数封装成数组再传入。比如主函数就是传递一个String数组参数。Java1.5之后不再需要手动封装数组，将要传递的多个参数直接传入即可。Java会自动将其封装成数组

注意：可变参数一定要定义在参数列表的最后面

代码示例

class

{

       public static void main(String[] args)

{

       show("liaoxuan",5,6,6,7);

show(5,6,6,7,"liaoxuan");//编译会失败

 

}

       public static void show(String s,int…i)

{

       System.out.println(s.length());

 

 

}

}

自动拆装包

概述：java1.5之前，集合中不能存放基本数据，而有了自动拆装包后，基本数据可以自行装包转换成基本数据包装类，不用手动进行转换。再进行基本数据运算时，基本数据包装类也可以自行拆包转换为基本数据。

自动装包代码示例

 

class IntegerDemo

{

public static void main(String[] args)

{

              ArrayList<Integer> al = new ArrayList< Integer >();

              //自动装包

al.add(5);

              al.add(6);

              ArrayList<Duble> al2 = new ArrayList< Duble >();

              //自动装包

al2.add(5.1);

              al2.add(6.7);

              Interator<Integer>=al.interator(); 

              while(it.hasNext())

{

       System.out.println(it.next()+1);//自动拆包

}

Interator< Duble >=al.interator(); 

              while(it.hasNext())

{

       System.out.println(it.next()+1.0);//自动拆包

}

 

}

}

 

--------------------- android培训、java培训、java学习型技术博客、期待与您交流！ -------------------