Java1.5新特性概览-优快云博客

------- android培训、 java培训、期待与您交流！----------

Java1.5新特性：

一、自动装箱和自动解箱技术

[java] view plain copy

int x = 100;
Integer y = x; // 自动装箱, 把基本数据类型自动当作对象来使用
x = y; // 自动拆箱, 把对象当作基本数据类型使用

二、静态引用概念：
    用 import static 节省以后的书写。
        引入静态属性 import static java.lang.System.out;
        引入静态方法 import static java.lang.Math.random;
        import static 只能引入静态的方法或属性；不能只引入类或非静态的方法。
    如：import static java.lang.System.*;
     out.println(“a”); //等于System.out.println("a"); 由于out是一个字段，所以不能更节省了

三、可变长参数
    一个方法的参数列表中最多只能有一个可变长参数,而且这个变长参数必须是最后一个参数
    方法调用时只在必要时去匹配变长参数。

[java] view plain copy

public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(add(1,2,3,5));
System.out.println(add(2,3,5));
}
public static int add(int x,int ...args) {
int sum = x;
for(int i=0;i<args.length;i++) {
sum += args[i];
}
return sum;
}

四、枚举 enum
    1、定义：枚举是一个具有特定值的类型，对用户来说只能任取其一。
       对于面向对象来说时一个类的对象已经创建好，用户不能新生枚举对象，只能选择一个已经生成的对象。
    2、枚举本质上也是一个类。枚举值之间用逗号分开，以分号结束(如果后面没有其它语句，分号可不写)。
    3、枚举分为两种：类型安全的枚举模式和类型不安全的枚举模式
    4、枚举的超类(父类)是:Java.lang.Enum。枚举是 final 类所以不能继承或被继承。但可以实现接口。
       枚举中可以写构造方法，但构造方法必需是私有的，而且默认也是私有的 private
    5、一个枚举值实际上是一个公开静态的常量，也是这个类的一个对象。
    6、枚举中可以定义抽象方法，但实现在各个枚举值中(匿名内部类的方式隐含继承)
       由于枚举默认是 final 型，不能被继承，所以不能直接用抽象方法(抽象方法必须被继承)
       在枚举中定义抽象方法后，需要在自己的每个枚举值中实现抽象方法。

    枚举是编译期语法，编译后生成类型安全的普通类

[java] view plain copy

public enum Color {
RED, GREEN, BLANK, YELLOW
}

switch
JDK1.6后switch语句支持enum类型，使用枚举，能让我们的代码可读性更强。

Java代码

[java] view plain copy

enum Signal {
GREEN, YELLOW, RED
}
public class TrafficLight {
Signal color = Signal.RED;
public void change() {
switch (color) {
case RED:
color = Signal.GREEN;
break;
case YELLOW:
color = Signal.RED;
break;
case GREEN:
color = Signal.YELLOW;
break;
}
}
}

用枚举实现一周的日期 , 要求返回中文日期

[java] view plain copy

public enum Week {
MON{
public String getLocalString() {
return "星期一";
}
},
TUE{
public String getLocalString() {
return "星期二";
}
},
WED{
public String getLocalString() {
return "星期三";
}
},
THU{
public String getLocalString() {
return "星期四";
}
},
FRI{
public String getLocalString() {
return "星期五";
}
},
SAT{
public String getLocalString() {
return "星期六";
}
},
SUN{
public String getLocalString() {
return "星期天";
}
};
public abstract String getLocalString();
}
/**
* 第二种实现方式
*/
public enum Week {
M("一"),
T("二");
private String day;
Week(String s){
this.day=s;
}
public String getDay(){
return this.day;
}
}

五、新型 for 循环 for-each，用于追求数组与集合的遍历方式统一
1、数组举例：

[java] view plain copy

int[] arr = {1,2,3,4,5,6};
for(int i=0; i<arr.length; i++){
System.out.print(arr[i]);
} //以上是以前的 for 循环遍历，比较下面的for—each
for(int i : arr){
System.out.print(i);

2、集合举例：

[java] view plain copy

List list = new ArrayList();
for(Object o :list){
System.out.println(o);
}

注：凡是实现了java.lang.Iterable接口的类就能用 for-each遍历
用 for each 时，不能用list.remove()删除，因为他内部的迭代器无法调用，造成多线程出错。
这时只能用 for 配合迭代器使用。
六泛型

    1、为了解决类型安全的集合问题引入了泛型。
       泛型是编译检查时的依据，也是编译期语法。
      (编译期语法：编译期有效，编译后擦除，不存在于运行期)
    2、简单的范型应用：集合(ArrayList, Set, Map, Iterator, Comparable)

[java] view plain copy

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

       <String>:表示该集合中只能存放String类型对象。
    3、使用了泛型技术的集合在编译时会有类型检查，不再需要强制类型转换。
       String str = l.get(2); //因为List<String> l, 所以 Error
       注：一个集合所允许的类型就是这个泛型的类型或这个泛型的子类型。
    4、

[java] view plain copy

List<Number> l = new ArrayList<Integer> //Error
List<Integer> l = new ArrayList<Integer> //Right
必须类型一致，泛型没有多态

    5、泛型的通配符<?>
       泛型的通配符表示该集合可以存放任意类型的对象。但只有访问，不可以修改。
        static void print( Cllection<?> c ){
         for( Object o : c )
         out.println(o);
        }
    6、带范围的泛型通配符
      泛型的声明约定T表示类型，E表示元素
        (1)、上界通配符，向下匹配：<? extends Number>    表明“extends”或“implements”，认为是 final 的
             表示该集合元素可以为Number类型及其子类型(包括接口);

        (2)、下界通配符，向上匹配：<? super Number>
             表示该集合元素可以为Number类型及其父类型
        (3)、接口实现：<? extends Comparable>
             表示该集合元素可以为实现了Comparable接口的类
    7、泛型方法
        在返回类型与修饰符之间可以定义一个泛型方法，令后面的泛型统一
        这里只能用 extends 定义，不能用 super ；后面可以跟类(但只能有一个，且要放在首位)其余是接口
        符号只有   &    //“＆”表示“与”；逗号表示后面的另一部分
        静态方法里面，不能使用类定义的泛型，只能用自己定义的；因为静态方法可以直接调用；
        所以普通方法可以使用类定义的及自己定义的泛型

[java] view plain copy

public static <T> void copy(T[] array,Stack<T> sta){……}
public static <T,E extends T> void copy (T[] array,Stack<E> sta){…..}
public static <T extends Number&Comparable> void copy(List<T> list,T[] t);

    静态方法不能使用类的泛型，因为静态方法中没有对象的概念。
    在使用接口的时候指明泛型。
     class Student implements Comparable<Student>{…….}

泛型集合类的综合案例

[java] view plain copy

HashMap<String,Integer> hm = new HashMap<String,Integer>();
hm.put("zxx",19);
hm.put("lis",18);
Set<Map.Entry<String,Integer>> en= hm.entrySet();
for(Map.Entry<String,Integer> me : en) {
System.out.println(me.getKey() + ":" + me.getValue());
}

交换数组中的两个元素的位置的泛型方法语法定义

[java] view plain copy

public static <E> void swap(E[] a, int i, int j) {
E t = a[i];
a[i] = a[j];
a[j] = t;

泛型方法的另外一个常见应用就是调用者无需对返回值进行类型转换

[java] view plain copy

public static <T> T[] fill(T[] a, T v) { for(int i = 0; i < a.length; i++) a[i] = v; return a; }

通过反射获得泛型的参数化类型

[java] view plain copy

Class GenericalReflection {
private Vector<Date> dates = new Vector<Date>();
public void setDates(Vector<Date> dates) {
this.dates = dates;
}
public static void main(String[] args) {
Method methodApply = GenericalReflection.class.getDeclaredMethod("applyGeneric", Vector.class);
ParameterizedType pType = (ParameterizedType)
(methodApply .getGenericParameterTypes())[0];
System.out.println("setDates("
+ ((Class) pType.getRawType()).getName() + "<"
+ ((Class) (pType.getActualTypeArguments()[0])).getName()
+ ">)" );
}
}

泛型 DAO 的应用：

[java] view plain copy

public abstract class DaoBaseImpl<T> implements DaoBase<T> {
protected Class<T> clazz;
public DaoBaseImpl() {
Type type = this.getClass().getGenericSuperclass();
ParameterizedType pt = (ParameterizedType) type;
this.clazz = (Class) pt.getActualTypeArguments()[0];
System.out.println("clazz = " + this.clazz);
}
}
public class ArticleDaoImpl extends DaoBaseImpl<Article> implements ArticleDao {
}