JDK5.0 新特性

JDK5.0 叫 Tiger，6.0叫海豚，7.0野马。

J2SE改称为Java SE 。

1.自动封箱。可以直接将基本类型装入到集合中。因为编译器做了变动，可以自动将基本类型和其对应的包装类转换。

2.静态引入。

例如：import static java.lang.System.*;

       在程序中用到System.out.println();时可以写作：out.println();

3.for循环；

统一了数组和集合的遍历；

数组遍历：

String  ss[]= {"123","456","789"};

for(String s:ss){

    System.out.println(s);

}

集合遍历：

 

 

4.可变长参数；在一个方法中最多只能有一个可变长参数，并且该可变长参数必须为参数表中最后一个参数。

public class TestVarARgs{

     public static void main(String args[]){
          m();
          m("abc");
          m("sjfds");
          m("sdf","dfjsafds","dfd","fd");
 }
    public static void m(String...ss){
        for(String s:ss){
              System.out.println(s);
        }
    }

}

5.格式化输入输出：

格式化输出是完全采用了C语言中的输出方式。

格式化输入：Scanner类。

 

四个大的方面新特性：

1.枚举：一个类型，该类型的取值是固定的几个值;该类不能创建对象，只能从现成的对象中选一个。

1.4中定义枚举是这样：

class Season1{

    public static final Season1 SPRING= new Season1();

    public static final Season1 SUMMER= new Season1();

    public static final Season1 AUTUMN= new Season1();

    public static final Season1 WINTER= new Season1();

    private Season1(){}

}

jdk5.0中的枚举也可以这样写（也是编译器语法）：

enum Season2{

  SPRING,

  SUMMER,

  AUTUMN,

  WINTER    

}

/*如果枚举值后面还有别的非静态final类型的属性或者是其他的方法，则WINTER后面加个分号再继续写！！枚举类型的构造方法默认为private类型，写也只能写private，否则可以省略。如果该枚举类型的构造方法为有参构造方法，则需要这样写：

enum Season3{

SPRING("春天"),

SUMMER("夏天"),

AUTUMN("秋天"),

WINTER("冬天");

String name;

Season3(String name){

     this.name = name;

} 

}

*/

 

 

public class TestEnum{

    public static void main(String[] args){

         Season2 s=Season2.SPRING;

         Season2[] s2 = Season2.values();//values()方法返回该枚举类型的数组。

         

   }

 

}

 

枚举类型为final类型，因为所有的类都是Enum的子类，而Java中只允许单继承，所以别的枚举类型之间不允许继承，例如：两个枚举类型A和B，A不能继承B！但是，枚举类型有一个奇怪的特点，就是既然为final类型，却允许枚举类型中有抽象方法，而这些抽象方法必须在枚举的对象中实现！！

枚举：类。

枚举值：对象。

 

 

 

2.泛型

集合是类型不安全的，集合并不能说就一定比其它的数组好，而是集合一定比Object[]强！！

List<String> list = new ArrayList<String>();

list.add("nihao");

list的类型是List，泛型是String，list只能装字符串。这样，从list中返回的对象就不需要再强转了，直接就是String类型。String s = list.get(0);

对于Map类型，它的泛型是两个，用逗号隔开。例如：

Map<Integer,String>  map = new HashMap<Integer,String>();

不同泛型之间不能相互赋值，即List<Object> list = new ArrayList<String>();这种写法是错误的！！！只能是前后的泛型完全一样。

？是泛型中的通配符，主要用在方法的形参上。

如果有一个public void print(List list){***}方法，想让所有的泛型都能作为参数传进去，则可以写作：public void print(List <?>  list ){}此时，所有类型泛型的List都能作为参数传进去。而如果写为：public void  print(List <? extends Number>   list){***}则所有Number或者Number类的子类都可以作为参数。而如果写为：public void  print(List<? extends comparable>   list){***}，则此时所有实现了comparable接口的类的泛型都可以作为参数传进去。

定义泛型方法，在方法的修饰符后，返回值类型之前，加上一个<T>，所有用到T的地方的类型都相同，都依据调用方法时的情况判断。例如：

public　static　＜T＞　void copyFrom(List<T>  list,T[]  ss){

    for(T ts:list){

       *****

    }

}

 

3.反射

反射是一种底层技术，是从1.0就开始的。

   类加载的时候会把加载的类的信息封装在一个类对象中，这个类对象的类就是Class。类加载只需要一次。

   类的对象是该类的一个实例，而类对象是类加载器加载该类的时候用于封装该类的信息的那个对象。

   三种用于获得类对象的方法：

   1.Class  c1 = ArrayList.class;

   2.Object l = new ArrayList();

       Class c2 = l.getClass();

   

   3.String className = "java.util.ArrayList";

      Class c3 = Class.forName(className);//以后会用Class.forName(className);方法去让虚拟机加载一个类。

 

一个类的构造方法会封装在Constructor类的对象中，有几个构造方法就在加载时产生几个Constructor类的对象，因为，一个构造方法的信息封装在一个Constructor对象中。

同理，一个类的属性会封装在Field对象中，一个类的方法会封装在Method对象中。

可以通过一个类的类对象获得该类的构造方法对象、方法对象、属性对象。Constructor、Method、Field这个三个类都在java.lang.reflect包（反射包）中。

 

Class类的方法：getMethods()返回该类的所有公开方法，包括从父类中继承来的公开方法。

                      getDeclaredMethods()方法返回该类的所有方法，包括私有的，但是不包括从父类中继承来的方法。

 

反射不只是获得类对象，还可以通过类对象获得类的对象，通过对类对象调用newInstance()方法可以获得类的对象。

  Class c=Class.forName("Student");//获得Student类的类对象。
  Object o2=c.newInstance();          //获得Student的对象。
  Method m1=c.getDeclaredMethod("study");/*为了调用study()方法（ 无参的study()方法），需获得Student类的study()方法的方法对象。*/
  m1.setAccessible(true);//如果study()方法是private的，通过这样的设置，可以调用study()方法。
  m1.invoke(o2);//对o2对象调用m1这个方法对象所对应的study()方法。
  Method m2=c.getDeclaredMethod("study", String.class);//获得Student类的study(String course){***}方法的方法对象。
  m2.setAccessible(true);
  m2.invoke(o2,"CoreJava");//对o2调用 有参的study()方法。

 

4.注释：5.0之前的注释是描述代码的文字。5.0的注释是描述代码的代码。5.0的注释也叫annotation。

JDK5.0中Java一共有四种类型：类，接口，注释，枚举。

　１.有的注释没有属性，称为标记注释。例如：@Override

　２.有的注释有一个属性，称为单值注释。

单值注释这样写：＠注释名（属性名＝属性值）　　　但是，如果该注释只有一个属性，并且属性名为value，则可以简写为：＠注释名（属性值）

　３.多值注释：＠（属性１＝属性值，属性２＝属性值，·····）

如何自定义注释类型？

　 public　＠interface TestCase{}

　定义注释时的注释叫做元注释。元注释有四种:

　１.Target注释：Target注释是为了描述自己定义的注释可以用于注释什么类。Target注释是单值注释，属性value的值是一个ElementType类型的数组。其中有八个枚举值，只能从中选择。例如：自己定义TestCase时写了@Target({ElementType.Constructor,ElementType.METHOD})则TestCase可以用于注释构造方法和普通方法。

 2.Retention注释：Retention注释是用于设置该种类型的注释的有效时间，即保留多久。

例如：

import java.lang.annotation.*;

@Target({ElementType.METHOD,ElementType.Constructor,ElementType.PARAMETER})/*设置该TestCase注释可以用于注释构造方法、普通方法、参数声明。*/

@Retention(RetentionPolicy.RUNTIME)

public @interface TestCase{

  String parameter1();

  String parameter2() default "liucy";//定义TestCase的属性parameter2,其默认值为"liucy"其实，parameter2既是属性又是方法，因为，可以在利用反射的时候，对TestCase对象调用parameter2()方法，类的信息封装在类对象中，注释的信息封装在注释对象中。

}

　　　　　　　

5.并发：

java.util.concurrent.*;

5.0中有了线程池，锁、等待队列等也都成了对象。5.0中的并发有个了解就行了。