JDK5引入的新特性

1.静态导入

   静态导入及导入一个类中的某个静态方法。

   Math类是一final类里面定义了两个静态变量和大量提供运算的静态方法。

   当一个类用final来修饰时，及这个类不能被改变，也就是不能被继承。

   当一个方法被final修饰时，这个方法不能被重写。

   当一个成员变量被final修饰时，这个变量为常量，必须赋予初值不能改变。

   当一个参数被final修饰时，这个参数不能被改变。

  在方法的局部变量前加final可以在该方法中的内部类访问。

当java程序运行时，类的字节码文件将被加载到内存，为类中的static方法分配了入口地址，当类创建第一个对象时为类中的实例方法分配入口地址，再创建对象时不再分配入口地址，也就是说方法的入口地址被所有对象共享。

2.可变参数

   一个方法接收的参数不定可用可变参数来实现。可变参数只能出现在参数列表的最后，调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组形式访问该可变参数。例如：

    public static int add(int n,int... is){

int sum=n;

for(int i=0;i<is.length;i++){

sum+=is[i];

}

return sum;

}

 

  方法的重写，在子类中重写父类中的方法时不能降低方法的访问权限，如父类中的protected方法，子类重写时要为protected或public方法，父类的private方法子类不能重写。

   

3.增强for循环

   for(type  变量名：集合变量名){...}

   迭代变量必须在（）中定义！

   集合变量可以是数组或实现了iterable接口的集合类。

   该集合可以使用Iterator<T> iterator()方法获得Interface Iterator<E>迭代器，从迭代器中取出集合元素。

4.自动拆箱和装箱

 自动拆箱：Integer类型的对象可以自动转换成int型与int型数据运算。

 自动装箱：Integer i3=4；

享元模式 flyweight

  在java中有很多使用频繁的对象，我们只创建一次，把不同的属性用方法的参数形式传入（外部状态），相同的属性作为成员变量（内部状态）。在以后每次使用时该对象时不需创建只需调用就可以了。

   -128到127的Integer类型的对象java用享元模式设计。

  比较两个对象是否为同一个对象用==

     Integer i1=7;

     Integer i2=7;

     System.out.println(i1==i2);结果true，享元模式设计引用同一个对象。

     Integer i1=new Integer(7);

     Integer i2=new Integer(7);

     System.out.println(i1==i2);结果fault，分别创建了两个对象

 

     String s3="abc";

     String s4="abc";

     System.out.println(s1==s2); 结果为true，s3和s4引用同一个对象。

     System.out.println(sum(5,4));

     String s1=new String("abc");

     String s2=new String("abc");

     System.out.println(s1==s2);结果为fault，分别创建了两个对象。

5.类型安全的枚举

  用普通类实现枚举类型

    定义枚举类型变量时，首先创建一个类，再类中定义该类型的常量，构造方法设为私有，及不能在类的外部实例化新的对象。

   public abstract class WeekDay {

    //构造方法声明为私有，在外面不能创建新的对象

private WeekDay() {

}

//定义枚举类型对象元素为final，static

public final static WeekDay SUN=new WeekDay(){

@Override

public WeekDay nextDay() {

return MON;

}

};

public final static WeekDay MON=new WeekDay(){

@Override

public WeekDay nextDay() {

return SUN;

}

};

public abstract WeekDay nextDay(); 

public String toString(){

return this==SUN?"SUN":"MON";

}

}

Abstract修饰的类为抽象类，抽象类不能直接实例化对象，要有其子类实例化对象。

抽象类中可以有抽象方法，抽象方法用abstract修饰，不能有方法体，且抽象方法只能在抽象类中出现。

 

 

 

 

用专门的枚举类实现：

枚举相当于一个类，枚举元素相当于该类实例化的对象。

public enum WeekDay{

SUN,MON,TUE,WED,THI,FRI,STA;

}

该枚举类有几个静态方法如values()返回一个装有所有枚举元素的数组。

 WeekDay.valueOf("SUN");方法可以把String类型的name转换成该类型的对象

带有构造方法的枚举:

public enum WeekDay{

SUN(0),MON,TUE,WED,THI,FRI,STA;

        private WeekDay(){System.out.println("first");}

        private WeekDay(int n){System.out.println("second");}

}

创建枚举时带上参数可以指定使用哪个构造方法创建枚举元素。

 

带有抽象方法的枚举类型交通灯实现

    当类中定义抽象方法时，枚举元素便不能有该类产生，要有该枚举类的子类产生，用内部类的方法实现。

//带有抽象方法的枚举类型实现

public enum TrafficLamp{

RED(30){

public TrafficLamp nextLamp() {

return GREEN;

}},

GREEN(40){

public TrafficLamp nextLamp() {

 

return YELLOW;

}},

YELLOW(5){

public TrafficLamp nextLamp() {

return RED;

}};

private int time;

private TrafficLamp(int time){this.time=time;}

//枚举中的抽象方法下一个元素

public abstract TrafficLamp nextLamp();

}

当枚举类型只有一个元素时，可以作为单例模式的一种实现方式。

6.泛型

   所谓泛型：就是变量类型的参数化。