Java新特性（一 · JDK1.5）

这里的Java新特性是从JDK1.5开始，这些新特性主要还是以理解为主。

Java5 - Java10新特性：

一、JDK1.5新特性

1、自动装箱与拆箱

什么是自动装箱拆箱？
简单一点说，装箱就是自动将基本数据类型转换为包装器类型；拆箱就是自动将包装器类型转换为基本数据类型。

Integer i = 10;  //装箱
int n = i;   //拆箱

下面我们来看看需要装箱拆箱的类型有哪些：

在Java中每种基本数据类型都会存在对应的包装器类型，为什么这么设计？

Java是一个面相对象的编程语言，基本类型并不具有对象的性质，为了让基本类型也具有对象的特征，就出现了包装类型（如我们在使用集合类型Collection时就一定要使用包装类型而非基本类型），它相当于将基本类型“包装起来”，使得它具有了对象的性质，并且为其添加了属性和方法，丰富了基本类型的操作。

关于装箱与拆箱常见面试题:

public class Main {
    public static void main(String[] args) {
         
        Integer i1 = 100;
        Integer i2 = 100;
        Integer i3 = 200;
        Integer i4 = 200;
         
        System.out.println(i1==i2);    //true
        System.out.println(i3==i4);    //false
    }
}

为什么会这样呢？看下Integer的valueOf方法的具体实现：

public static Integer valueOf(int i) {
	final int offset = 128;
	if (i >= -128 && i <= 127) { // must cache 
	    return IntegerCache.cache[i + offset];
	}
        return new Integer(i);
    }

而其中IntegerCache类的实现为：

private static class IntegerCache {
    private IntegerCache(){}
    static final Integer cache[] = new Integer[-(-128) + 127 + 1];

    static {
        for(int i = 0; i < cache.length; i++)
	    cache[i] = new Integer(i - 128);
    }
}

由上可知，Integer包装类型如果数值在[-128,127]之间，便返回指向IntegerCache.cache中已经存在的对象的引用；否则创建一个新的Integer对象。

我们会联想到其他的包装类类型是否也有这样的规律，我们看下Double类

public class Main {
    public static void main(String[] args) {
         
        Double i1 = 100.0;
        Double i2 = 100.0;
        Double i3 = 200.0;
        Double i4 = 200.0;
         
        System.out.println(i1==i2);    //false
        System.out.println(i3==i4);    //false
    }
}

为什么比较结果都是false呢？看下Double的valueof方法的实现：

public static Double valueOf(double d) {
        return new Double(d);
    }

想想原因很简单：在某个范围内的整型数值的个数是有限的，而浮点数却不是。

注意，Integer、Short、Byte、Character、Long这几个类的valueOf方法的实现是类似的。Double、Float的valueOf方法的实现是类似的。

对于Boolean类型比较一下就一目了然：

public class Main {
    public static void main(String[] args) {
         
        Boolean i1 = false;
        Boolean i2 = false;
        Boolean i3 = true;
        Boolean i4 = true;
         
        System.out.println(i1==i2);    //true
        System.out.println(i3==i4);    //true
    }
}

源码：

public static Boolean valueOf(boolean b) {
        return (b ? TRUE : FALSE);
    }

TRUE和FALSE都是静态常量

public static final Boolean TRUE = new Boolean(true);

public static final Boolean FALSE = new Boolean(false);

另外还有一点需要注意：当 "=="运算符的两个操作数都是包装器类型的引用，则是比较指向的是否是同一个对象，而如果其中有一个操作数是表达式（即包含算术运算）则比较的是数值（即会触发自动拆箱的过程），对基础数据类型进行运算。对于包装器类型，equals方法并不会进行类型转换。

public class Main {
    public static void main(String[] args) {
         
        Integer a = 1;
        Integer b = 2;
        Integer c = 3;
        Integer d = 3;
        Integer e = 321;
        Integer f = 321;
        Long g = 3L;
        Long h = 2L;
         
        System.out.println(c==d);            //true
        System.out.println(e==f);            //false
        System.out.println(c==(a+b));        //true
        System.out.println(c.equals(a+b));   //true
        System.out.println(g==(a+b));        //true
        System.out.println(g.equals(a+b));   //false
        System.out.println(g.equals(a+h));   //true
    }
}

equals()方法源码

//Integer类中
public boolean equals(Object obj) {
	if (obj instanceof Integer) {
	    return value == ((Integer)obj).intValue();
	}
	return false;
    }

//Long类中
public boolean equals(Object obj) {
    if (obj instanceof Long) {
	return value == ((Long)obj).longValue();
    }
	return false;
}

我们指定equals比较的是内容本身，并且我们也可以看到equal的参数是一个Object对象，我们传入的是一个int类型，所以首先会进行装箱，然后比较，之所以返回true，是由于它比较的是对象里面的value值。当内容和类型都相同时才会返回true。

2、枚举

enum 的全称为 enumeration， 是 JDK 1.5  中引入的新特性，存放在 java.lang 包中。枚举主要用于定义一组可以使用的类对象，这样在使用时只能通过固定的几个对象来进行类的操作。

比如定义一个季节类时，在没有枚举类型前我们通常会使用常量的方式：

/*
 * 季节类
 * 有且仅有4个对象，且对象的属性是固定的
 * 手动实现枚举类
 */

public class Season {
	//季节属性：属性是固定的（外界不可访问，当前类不可以修改）
	private final String SEASON_NAME;
	private final String SEASON_DESC;
	//对象只能由本类提供
	private Season(String season_name, String season_desc) {
		this.SEASON_NAME = season_name;
		this.SEASON_DESC = season_desc;
	}
	public String getSEASON_NAME() {
		return SEASON_NAME;
	}
	public String getSEASON_DESC() {
		return SEASON_DESC;
	}
	
	//在本类中创建4个季节对象（不能修改）
	public static final Season SPRING = new Season("春天","雨想衣裳花想荣，春风芙兰露华荣");
	public static final Season SUMMER = new Season("夏天","接天莲花无穷尽，映日荷花别样红");
	public static final Season OUTUMN = new Season("秋天","月落乌啼霜满天，江枫渔火对愁眠");
	public static final Season WINTER = new Season("冬天","忽如一夜春风来，千树万树梨花开");
	@Override
	public String toString() {
		return "Season [SEASON_DESC=" + SEASON_DESC + ", SEASON_NAME="
				+ SEASON_NAME + "]";
	}
}

测试：

public classs Test{
    public static void main(String[] args){
	//获取Season对象
	Season s = Season.SPRING;
	System.out.println(s);
    }
}

/*
运行结果为:
Season [SEASON_DESC=雨想衣裳花想荣，春风芙兰露华荣, SEASON_NAME=春天]
*/

这样的定义方式并没有什么错，但为了提高类型安全和使用方便性我们引入了枚举类型

//使用enum定义枚举类
public enum SeasonEnum{
	//枚举类的实例，必须要在最前面给出
	SPRING("春天","雨想衣裳花想荣，春风芙兰露华荣"), 
	SUMMER("夏天","接天莲花无穷尽，映日荷花别样红"),
	OUTUMN("秋天","月落乌啼霜满天，江枫渔火对愁眠"),
	WINTER("冬天","忽如一夜春风来，千树万树梨花开");
        //属性：固定，不可修改
	private final String SEASON_NAME;
	private final String SEASON_DESC;
	public String getSEASON_NAME() {
		return SEASON_NAME;
	}
	public String getSEASON_DESC() {
		return SEASON_DESC;
	}
	private SeasonEnum(String season_name, String season_desc) {
		SEASON_NAME = season_name;
		SEASON_DESC = season_desc;
	}
	public String toString() {
		return "Season [SEASON_DESC=" + SEASON_DESC + ", SEASON_NAME="
				+ SEASON_NAME + "]";
	}
}

 测试：

public class Test{
    public static void main(String[] args){
	//获取Season对象
	SeasonEnum s = SeasonEnum.SUMMER;
	System.out.println(s);
    }
}

/*
运行结果为:
Season [SEASON_DESC=雨想衣裳花想荣，春风芙兰露华荣, SEASON_NAME=春天]
*/

 枚举只需要使用enum关键字定义就可以，但是严格来讲，枚举只是类结构的加强而已。因为在Java中使用enum定义的枚举类就相当于默认继承java.lang.Enum类，此类定义如下：

public abstract class Enum>
        implements Comparable, Serializable

 Enum类中定义的方法：

protected  Object	clone()    抛出 CloneNotSupportedException。
int	compareTo(E o)      比较此枚举与指定对象的顺序。
boolean	equals(Object other)     当指定对象等于此枚举常量时，返回 true。
protected  void	finalize()      枚举类不能有 finalize 方法。
Class	getDeclaringClass()       返回与此枚举常量的枚举类型相对应的 Class 对象。
int	hashCode()     返回枚举常量的哈希码。
String	name()       返回此枚举常量的名称，在其枚举声明中对其进行声明。
int	ordinal()    返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）。
String	toString()     返回枚举常量的名称，它包含在声明中。
static > T	valueOf(Class enumType, String name)      返回带指定名称的指定枚举类型的枚举常量。

 实例：

public class Test{
    public static void main(String[] args){
	//获取所有枚举对象
	SeasonEnum[] seasons = SeasonEnum.values();
	for (SeasonEnum se : seasons) {
		System.out.println(se);
	}
	
	//将字符串转成枚举对象
	String s = "SPRING";
	//参数1：枚举类型；参数2：对应字符串
	SeasonEnum se = Enum.valueOf(SeasonEnum.class, s);
	System.out.println(se.getDeclaringClass());
        System.out.println(se);
        System.out.println(se.name());
        //返回枚举常量所在位置
        System.out.println(se.ordinal());
    }
}

/*
运行结果:
Season [SEASON_DESC=雨想衣裳花想荣，春风芙兰露华荣, SEASON_NAME=春天]
Season [SEASON_DESC=接天莲花无穷尽，映日荷花别样红, SEASON_NAME=夏天]
Season [SEASON_DESC=月落乌啼霜满天，江枫渔火对愁眠, SEASON_NAME=秋天]
Season [SEASON_DESC=忽如一夜春风来，千树万树梨花开, SEASON_NAME=冬天]
class se02.day07.enumdemo.SeasonEnum
Season [SEASON_DESC=雨想衣裳花想荣，春风芙兰露华荣, SEASON_NAME=春天]
SPRING
0
*/

常见面试题：请解释一下enum和Enum的关系。

enum是JDK1.5之后定义的新关键字，主要用于定义枚举类型，在Java中每一个使用enum定义的枚举类型实际上都表示一个类默认继承了Enum类。

枚举在switch语句中的使用

• 在JDK1.5之前，switch只能操作int或char型数据；
• 在JDK1.5之后，switch可以操作enum型
• 在JDK1.7之后，switch可以操作String型

示例：

enum Color {GREEN,RED,BLUE}

public class EnumDemo4 {

    public static void printName(Color color){
        switch (color){
            case BLUE: //无需使用Color进行引用
                System.out.println("蓝色");
                break;
            case RED:
                System.out.println("红色");
                break;
            case GREEN:
                System.out.println("绿色");
                break;
        }
    }

    public static void main(String[] args){
        printName(Color.BLUE);
        printName(Color.RED);
        printName(Color.GREEN);

        //蓝色
        //红色
        //绿色
    }
}

枚举与接口

所有的枚举都继承自java.lang.Enum类。由于Java 不支持多继承，所以枚举对象不能再继承其他类。 但可以实现多个接口。

示例1：像一般实现接口规律一样实现接口中的所有方法，同时枚举类中可以重写toString()方法，有自己的属性和方法

interface Inter {
	String getInfo();
}
public enum SeasonEnumImpl implements Inter{
	//枚举类的实例，必须要在最前面给出
	SPRING("春天","雨想衣裳花想荣，春风芙兰露华荣"), 
	SUMMER("夏天","接天莲花无穷尽，映日荷花别样红"),
	OUTUMN("秋天","月落乌啼霜满天，江枫渔火对愁眠"),
	WINTER("冬天","忽如一夜春风来，千树万树梨花开");
	//属性：固定，不可修改
	private final String SEASON_NAME;
	private final String SEASON_DESC;
        public String getSEASON_NAME() {
		return SEASON_NAME;
	}
	public String getSEASON_DESC() {
		return SEASON_DESC;
	}
	
	private SeasonEnumImpl(String season_name, String season_desc) {
		SEASON_NAME = season_name;
		SEASON_DESC = season_desc;
	}
	public String toString() {
		return "Season [SEASON_DESC=" + SEASON_DESC + ", SEASON_NAME="
				+ SEASON_NAME + "]";
	}
	@Override
	public String getInfo() {
		switch(this){
			case SPRING:
				return "春天";
			case SUMMER:
				return "春天";
			case OUTUMN:
				return "春天";
			case WINTER:
				return "春天";
		}
		return null;
	}
}

测试：

public class Test{
    public static void main(String[] args){
	String info = SeasonEnumImpl.SPRING.getInfo();
	System.out.println(info);
    }
}

运行结果为:
春天

 示例2：采用匿名内部类的方式实现接口

public enum SeasonEnumImpl02 implements Inter{
	//枚举类的实例，必须要在最前面给出
	SPRING("春天","雨想衣裳花想荣，春风芙兰露华荣"){
		@Override
		public String getInfo() {
			return "春天";
		}
	}, 
	SUMMER("夏天","接天莲花无穷尽，映日荷花别样红"){
		@Override
		public String getInfo() {
			return "夏天";
		}
	},
	OUTUMN("秋天","月落乌啼霜满天，江枫渔火对愁眠"){
		@Override
		public String getInfo() {
			return "秋天";
		}
	},
	WINTER("冬天","忽如一夜春风来，千树万树梨花开"){
		@Override
		public String getInfo() {
			return "冬天";
		}
	};
        //属性：固定，不可修改
	private final String SEASON_NAME;
	private final String SEASON_DESC;

	public String getSEASON_NAME() {
		return SEASON_NAME;
	}
	public String getSEASON_DESC() {
		return SEASON_DESC;
	}

	private SeasonEnumImpl02(String season_name, String season_desc) {
		SEASON_NAME = season_name;
		SEASON_DESC = season_desc;
	}
	public String toString() {
		return "Season [SEASON_DESC=" + SEASON_DESC + ", SEASON_NAME="
				+ SEASON_NAME + "]";
	}
}

测试：

public class Test{
    public static void main(String[] args){
	SeasonEnumImpl02[] ses = SeasonEnumImpl02.values();
	for (SeasonEnumImpl02 se : ses) {
		System.out.println(se.getInfo());
	}
    }
}

 运行结果为：

春天
夏天
秋天
冬天

示例3：使用接口组织枚举

public interface Food {  
    enum Coffee implements Food{  
        BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO  
    }  
    enum Dessert implements Food{  
        FRUIT, CAKE, GELATO  
    }  
}

测试：

public class Test {
        
    public  static void main(String[] args) {  
        for (Dessert dessertEnum : Food.Dessert.values()) {  
            System.out.print(dessertEnum + "  ");  
        }  
        System.out.println();    
        for (Coffee coffee : Food.Coffee.values()) {  
            System.out.print(coffee + "  ");  
        }  
        System.out.println();  
        //搞个实现接口，来组织枚举，简单讲，就是分类吧。如果大量使用枚举的话，这么干，在写代码的时候，就很方便调用啦。  
        //还有就是个“多态”的功能吧，  
        Food food = Food.Dessert.CAKE;  
        System.out.println(food);  
        food = Coffee.BLACK_COFFEE;  
        System.out.println(food);  
    } 
}

运行结果:

FRUIT CAKE GELATO
BLACK_COFFEE DECAF_COFFEE LATTE CAPPUCCINO
CAKE
BLACK_COFFEE

关于枚举接口的使用

java.util.EnumSet和java.util.EnumMap是两个枚举集合。EnumSet保证集合中的元素不重复；EnumMap中的 key是enum类型，而value则可以是任意类型。

①EnumSet类的用法

EnumSet继承AbstractSet，AbstractSet实现了set接口。

public abstract class EnumSet> extends AbstractSet
    implements Cloneable, java.io.Serializable

 API中的方法：

static > EnumSet	allOf(Class elementType)创建一个包含指定元素类型的所有元素的枚举 set。
EnumSet	clone()  返回 set 的副本。
static > EnumSet	complementOf(EnumSet s)创建一个其元素类型与指定枚举 set 相同的枚举 set，最初包含指定 set 中所不 包含的此类型的所有元素。
static > EnumSet	copyOf(Collection c)  创建一个从指定 collection 初始化的枚举 set。
static > EnumSet	copyOf(EnumSet s)  创建一个其元素类型与指定枚举 set 相同的枚举 set，最初包含相同的元素（如果有的话）。
static > EnumSet	noneOf(Class elementType)创建一个具有指定元素类型的空枚举 set。
static > EnumSet	of(E e)创建一个最初包含指定元素的枚举 set。
static > EnumSet	of(E first, E... rest) 创建一个最初包含指定元素的枚举 set。
static > EnumSet	of(E e1, E e2)  创建一个最初包含指定元素的枚举 set。
static > EnumSet	of(E e1, E e2, E e3)创建一个最初包含指定元素的枚举 set。
static > EnumSet	of(E e1, E e2, E e3, E e4)创建一个最初包含指定元素的枚举 set。
static > EnumSet	of(E e1, E e2, E e3, E e4, E e5) 创建一个最初包含指定元素的枚举 set。
static > EnumSet	range(E from, E to)创建一个最初包含由两个指定端点所定义范围内的所有元素的枚举 set。

示例：

enum SeasonEnum{
	SPRING, SUMMER,OUTUMN,WINTER;
}

public class Test{
        public static void main(String[] args) {
	// 创建一个EnumSet集合，集合元素就是Season枚举类的全部枚举值
	EnumSet es = EnumSet.allOf(SeasonEnum.class);
	System.out.println(es);//输出[SPRING, SUMMER, OUTUMN, WINTER]
	// 创建一个EnumSet空集合，指定其集合元素是Season类的枚举值。
	EnumSet es2 = EnumSet.noneOf(SeasonEnum.class);
	System.out.println(es2);
	// 手动添加两个元素  
        es2.add(SeasonEnum.WINTER);  
        es2.add(SeasonEnum.SPRING);  
        System.out.println(es2); // 输出[SPRING,WINTER]
        // 以指定枚举值创建EnumSet集合  
        EnumSet es3 = EnumSet.of(SeasonEnum.SUMMER , SeasonEnum.WINTER);  
        System.out.println(es3); // 输出[SUMMER,WINTER] 
        EnumSet es4 = EnumSet.range(SeasonEnum.SUMMER , SeasonEnum.WINTER);  
        System.out.println(es4); // 输出[SUMMER,FALL,WINTER]  
        // 新创建的EnumSet集合的元素和es4集合的元素有相同类型，  
        // es5的集合元素 + es4集合元素 = EnumSet枚举类的全部枚举值  
        EnumSet es5 = EnumSet.complementOf(es4);  
        System.out.println(es5); // 输出[SPRING]
	}
}

②EnumMap类的用法

EnumMap继承AbstractMap，AbstractMap实现了Map接口。EnumMap是不同步的。

public class EnumMap, V> extends AbstractMap
    implements java.io.Serializable, Cloneable

API中的方法 ：

void	clear() 从此映射中移除所有映射关系。
EnumMap	clone() 返回此枚举映射的浅表副本。
boolean	containsKey(Object key) 如果此映射包含指定键的映射关系，则返回 true。
boolean	containsValue(Object value)  如果此映射将一个或多个键映射到指定值，则返回 true。
Set>	entrySet() 返回此映射中所包含映射关系的 Set 视图。
boolean	equals(Object o)  比较指定对象与此映射的相等性。
V	get(Object key)返回指定键所映射的值，如果此映射不包含此键的映射关系，则返回 null。
Set	keySet()   返回此映射中所包含键的 Set 视图。
V	put(K key, V value) 将指定值与此映射中指定键关联。
void	putAll(Map m)将指定映射中所有映射关系复制到此映射中。
V	remove(Object key)  从此映射中移除该键的映射关系（如果存在）。
int	size()   返回此映射中的键-值映射关系数。
Collection	values()      返回此映射中所包含值的 Collection 视图。

示例：

public class Test {
	public enum Color{//默认继承  extends Enum类，所以枚举也是个类，既然是类就有构造函数，变量，方法等
	    RED, BLUE, BLACK, YELLOW, GREEN;//下标为0,1,2,3,4
	    @Override
	    public String toString() {
		return super.toString()+"..."+super.ordinal();//ordinal()方法获取下标
            }
	}
 
	public static void main(String[] args) {
	    EnumMap map = new EnumMap(Color.class);
            System.out.println(Color.GREEN);
	    map.put(Color.YELLOW, "黄色");
	    map.put(Color.BLUE, null);
	    //map.put(null, "无"); //会报NullPonitException的错误
	    map.put(Color.RED, "红色");
	    map.put(Color.GREEN, "绿色");
            map.get(Color.BLACK);
	    for (Entry entry : map.entrySet()) {
		System.out.println(entry.getKey() + ":" + entry.getValue());
	    }
	    map.clear();
	    System.out.println(map);
	}
}

 输出结果：

GREEN...4
RED...0:红色
BLUE...1:null
YELLOW...3:黄色
GREEN...4:绿色
{}

3、静态导入

静态导入是JDK1.5中对import语句的增强,语法格式:import static 包名….类名.方法名;或者导入类中所有静态成员，此时方法名用*代替。

静态导入注意事项：

• 方法或变量必须是静态的
• 如果有多个同名的静态方法，这个时候要使用，必须加前缀。

示例：

import static java.lang.System.out; 
import static java.lang.Integer.*; 

public class Test {
     
        public static void main(String[] args) { 
            out.println(MAX_VALUE);         //2147483647
            out.println(toHexString(42));   //2a
        } 
}

静态导入节省了大量重复代码的击键次数，但同时也牺牲了代码的可阅读性。

4、可变参

当在Java中调用一个方法时，必须严格的按照方法定义的变量进行参数传递，但是在开发中有可能会出现这样一种情况：不确定要传递的参数个数。从JDK1.5开始，为了解决参数任意多个的问题，专门在方法定义上提供了可变参数的概念，本质上还是基于数组的实现。

语法如下：

[public | protected | private][static][final][abstract] 返回值类型 方法名称(参数类型...变量){
    方法体;    
    [return [返回值];]
}

 注意事项：

• 可变参数只能作为函数的最后一个参数，但其前面可以有也可以没有任何其他参数

• 由于可变参数必须是最后一个参数，所以一个函数最多只能有一个可变参数

• Java的可变参数，会被编译器转型为一个数组

• 变长参数在编译为字节码后，在方法签名中就是以数组形态出现的。这两个方法的签名是一致的，不能作为方法的重载。如果同时出现，是不能编译通过的。可变参数可以兼容数组，反之则不成立。

• 可变参的参数类型可以为泛型

可变参在方法重载中注意：

①方法重载优先匹配固定参数

public class Varargs {
    public static void test(String... args) {
        System.out.println("version 1");
    }
    public static void test(String arg1, String arg2) {
        System.out.println("version 2");
    }
    public static void main(String[] args) {
        test("a","b");    //version 2 优先匹配固定参数的重载方法
        test();           //version 1
    }
}

②匹配多个可变参数

调用一个被重载的方法时，如果此调用既能够和两个可变长参数的重载方法匹配，则编译出错:

public class Varargs {
    public static void test(String... args) {
        System.out.println("version 1");
    }
    public static void test(String arg1, String... arg2) {
        System.out.println("version 2");
    }
    public static void main(String[] args) {
        test("a","b");    //Compile error
    }
}

可变参在方法重写中注意：

①避免带有变长参数的方法重载

即便编译器可以按照优先匹配固定参数的方式确定具体的调用方法，但在阅读代码的依然容易掉入陷阱。要慎重考虑变长参数的方法重载。别让 null 值和空值威胁到变长方法。

public class Client {  
     public void methodA(String str,Integer... is){       
     }  
     public void methodA(String str,String... strs){          
     }  
     public static void main(String[] args) {  
           Client client = new Client();  
           client.methodA("China", 0);  
           client.methodA("China", "People");  
           client.methodA("China");       //compile error
           client.methodA("China",null);  //compile error
           //可修改为
           String[] strs = null;  
	   client.methodA("China",strs);
     }  
}

 ②覆写变长方法也要循规蹈矩

// 基类
class Base {
    void print(String... args) {
        System.out.println("Base......test");
    }
}
// 子类，覆写父类方法
class Sub extends Base {
    @Override
    void print(String[] args) {
        System.out.println("Sub......test");
    }
}
public class VarArgsTest2 {
    public static void main(String[] args) {
        // 向上转型
        Base base = new Sub();
        base.print("hello");
        // 不转型
        Sub sub = new Sub();
        sub.print("hello");    //compile error
    }
}

第一个能编译通过，这是为什么呢？事实上，base 对象把子类对象 sub 做了向上转型，形参列表是由父类决定的，当然能通过。而看看子类直接调用的情况，这时编译器看到子类覆写了父类的 print 方法，因此肯定使用子类重新定义的 print 方法，尽管参数列表不匹配也不会跑到父类再去匹配，因为找到了就不再找了，因此有了类型不匹配的错误。

这是个特例，覆写的方法参数列表竟然可以与父类不相同，这违背了覆写的定义，并且会引发莫名其妙的错误。

这里，总结下覆写必须满足的条件：

• 覆写方法不能缩小访问权限

• 参数列表必须与被覆写方法相同（包括显示形式）

• 返回类型必须与被覆写方法的相同或是其子类

• 覆写方法不能抛出新的异常，或者超出父类范围的异常，但是可以抛出更少、更有限的异常，或者不抛出异常

使用 Object… 作为变长参数：int[] 无法转型为 Object[], 因而被当作一个单纯的数组对象 ; Integer[] 可以转型为 Object[], 可以作为一个对象数组。

public class SeasonTest {
	public static void foo(Object... args) {
	    System.out.println(args.length);
	}
	public static void main(String[] args) {  
	    foo(new String[]{"arg1", "arg2", "arg3"}); //3
	    foo(100, new String[]{"arg1", "arg1"});    //2
	    foo(new Integer[]{1, 2, 3});               //3
	    foo(100, new Integer[]{1, 2, 3});          //2
	    foo(1, 2, 3);                              //3
	    foo(new int[]{1, 2, 3});                   //1      
	} 
}

 反射方法调用时的注意事项

public class Test {
    public static void foo(String... varargs){
        System.out.println(args.length);
    }
    public static void main(String[] args){
        String[] varArgs = new String[]{"arg1", "arg2"};
        try{
            Method method = Test.class.getMethod("foo", String[].class);
            method.invoke(null, varArgs);
            method.invoke(null, (Object[])varArgs);
            method.invoke(null, (Object)varArgs);
            method.invoke(null, new Object[]{varArgs});
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}

 

上面的四个调用中，前两个都会在运行时抛出 java.lang.IllegalArgumentException: wrong number of arguments 异常，后两个则正常调用。

反射是运行时获取的，在运行时看来，可变长参数和数组是一致的，因而方法签名为：

//方法签名 ([Ljava/lang/String;)V // public void foo(String[] varargs)

再来看一下 Method 对象的方法声明：

Object invoke(Object obj, Object... args)

args 虽然是一个可变长度的参数，但是 args 的长度是受限于该方法对象代表的真实方法的参数列表长度的，而从运行时签名来看，([Ljava/lang/String;)V 实际上只有一个形参，即 String[] varargs，因而 invoke(Object obj, Object… args) 中可变参数 args 的实参长度只能为1

//Object invoke(Object obj, Object... args) 
//String[] varArgs = new String[]{"arg1", "arg2"}; 
method.invoke(null, varArgs);               //varArgs长度为2，错误 
method.invoke(null, (Object[])varArgs);     //将String[]转换为Object[],长度为2的，错误 
method.invoke(null, (Object)varArgs);       //将整个String[] 转为Object，长度为1，符合 
method.invoke(null, new Object[]{varArgs}); //Object[]长度为1，正确。上一个和这个是等价的

反射机制：

反射不是jdk1.5的特性，从jdk1.0就有了

Java反射就是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；并且能改变它的属性。而这也是Java被视为动态（或准动态，为啥要说是准动态，因为一般而言的动态语言定义是程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言。从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C#不是动态语言。）语言的一个关键性质。

反射的常用类和函数:Java反射机制的实现要借助于4个类：Class，Constructor，Field，Method；其中class代表的是类对象，Constructor－类的构造器对象，Field－类的属性对象，Method－类的方法对象，通过这四个对象我们可以粗略的看到一个类的各个组成部分。其中最核心的就是Class类，它是实现反射的基础。

Class类：反射的基石
概述：Java程序中的各个Java类属于同一类事物，可以用一个类来描述这类事物，就是Class。Class类代表Java类，它的各个实例对象又分别对应各个类在内存中的字节码，一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，不同的类的字节码是不同的，所以它们在内存中的内容是不同的，这一个个的空间可分别用一个个的对象来表示。学习反射，首先就要明白Class这个类。每个java类都是Class的一个实例对象。

得到字节码的三种方式：

1. 类名.class，例如，System.class
2. 对象.getClass()，例如，new Date().getClass()
3. Class.forName("类名")，例如，Class.forName("java.util.Date");

注意：Class.forName()返回字节码的方式有两种，第一种是这份字节码曾经被加载过，已经存在于虚拟机中，直接返回。还有一种是java虚拟机中还没有这份字节码，则用类加载器去加载，把加载进来的字节码缓存在虚拟机中以后要得到这份字节码就不用再加载了。

Class类常用方法：

static Class	forName(String className)    返回与带有给定字符串名的类或接口相关联的 Class 对象。
static Class	forName(String name, boolean initialize, ClassLoader loader)           使用给定的类加载器，返回与带有给定字符串名的类或接口相关联的 Class 对象。
ClassLoader	getClassLoader()返回该类的类加载器。
native Class	getComponentType() 返回一个数组的类代表组件类型。
Constructor	getConstructor(Class... parameterTypes)           返回一个 Constructor 对象，它反映此 Class 对象所表示的类的指定公共构造方法。
Constructor[]	getConstructors()           返回一个包含某些 Constructor 对象的数组，这些对象反映此 Class 对象所表示的类的所有公共构造方法。
Constructor	getDeclaredConstructor(Class... parameterTypes) 获得类的指定构造方法,包括private 声明的和继承类，parameterTypes 参数指定构造方法的参数类型。
Constructor[]	getDeclaredConstructors()    获得类的所有构造方法，包括private 声明的和继承类
Field	getDeclaredField(String name)   获得类的指定属性。包括private 声明的和继承类
Field[]	getDeclaredFields() 获得类的所有属性。包括private 声明的和继承类
Method	getDeclaredMethod(String name, Class... parameterTypes)           返回一个 Method 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法。
Method[]	getDeclaredMethods() 返回 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。
Class	getDeclaringClass()    如果此 Class 对象所表示的类或接口是另一个类的成员，则返回的 Class 对象表示该对象的声明类。
Field	getField(String name)           返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段。
Field[]	getFields()   返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段。
Type	getGenericSuperclass()           返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的直接超类的 Type。
Method	getMethod(String name, Class... parameterTypes)           返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。
Method[]	getMethods() 返回一个包含某些 Method 对象的数组，这些对象反映此 Class 对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口那些的类或接口）的公共 member 方法。
int	getModifiers()返回此类或接口以整数编码的 Java 语言修饰符。
String	getName()           以 String 的形式返回此 Class 对象所表示的实体（类、接口、数组类、基本类型或 void）名称。
Package	getPackage()  获取此类的包。
URL	getResource(String name)    查找带有给定名称的资源。
InputStream	getResourceAsStream(String name)      查找具有给定名称的资源。
Class	getSuperclass()     返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的超类的 Class。
TypeVariable>[]	getTypeParameters()     按声明顺序返回 TypeVariable 对象的一个数组，这些对象表示用此 GenericDeclaration 对象所表示的常规声明来声明的类型变量。
boolean	isArray()     判定此 Class 对象是否表示一个数组类。
boolean	isAssignableFrom(Class cls)   判定此 Class 对象所表示的类或接口与指定的 Class 参数所表示的类或接口是否相同，或是否是其超类或超接口。
boolean	isEnum()      当且仅当该类声明为源代码中的枚举时返回 true。
boolean	isInstance(Object obj)      判定指定的 Object 是否与此 Class 所表示的对象赋值兼容。
boolean	isInterface()      判定指定的 Class 对象是否表示一个接口类型。
boolean	isLocalClass()      当且仅当底层类是本地类时返回 true。
boolean	isMemberClass()      当且仅当底层类是成员类时返回 true。
boolean	isPrimitive()     判定指定的 Class 对象是否表示一个基本类型。
T	newInstance()      创建此 Class 对象所表示的类的一个新实例。
String	toString()      将对象转换为字符串。

示例：

package se02.day07.reflect;

public class Person {
	private String name;
	int age;
	public String address;
	public Person() {
	}
	private Person(String name) {
		this.name = name;
	}
	Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public Person(String name, int age, String address) {
		this.name = name;
		this.age = age;
		this.address = address;
	}
	public void show() {
		System.out.println("show");
	}
	public void method(String s){
		System.out.println("method"+s);
	}
	public String getString(String s,int i){
		return s+"----"+i;
	}
	private void function() {
		System.out.println("function");
	}
	@Override
	public String toString() {
		return "Person [address=" + address + ", age=" + age + ", name=" + name
				+ "]";
	}
	
}

package se02.day07.reflect;

public class ReflectDemo01 {
	public static void main(String[] args) {
		//方式1
		Person p = new Person();
		Class c = p.getClass();
		System.out.println(c);
		
		//方式2
		Class c2 = Person.class;
		System.out.println(c2);
		
		//方式3
		try {
			Class c3 = Class.forName("se02.day07.reflect.Person");
			System.out.println(c3);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}
}

 输出结果：

 class se02.day07.reflect.Person
class se02.day07.reflect.Person
class se02.day07.reflect.Person

Field类：提供类的成员变量信息，就是类的属性。

方法摘要：

boolean	equals(Object obj)    将此 Field 与指定对象比较。
Object	get(Object obj)       返回指定对象上此 Field 表示的字段的值。
String	getName()    返回此 Field 对象表示的字段的名称。
short	getShort(Object obj)           获取 short 类型或另一个通过扩展转换可以转换为 short 类型的基本类型的静态或实例字段的值。
Class	getType()      返回一个 Class 对象，它标识了此 Field 对象所表示字段的声明类型。
void	set(Object obj, Object value)       将指定对象变量上此 Field 对象表示的字段设置为指定的新值。
void	setBoolean(Object obj, boolean z)     将字段的值设置为指定对象上的一个 boolean 值。
void	setByte(Object obj, byte b)      将字段的值设置为指定对象上的一个 byte 值。
void	setChar(Object obj, char c)      将字段的值设置为指定对象上的一个 char 值。
void	setDouble(Object obj, double d)      将字段的值设置为指定对象上的一个 double 值。
void	setFloat(Object obj, float f)      将字段的值设置为指定对象上的一个 float 值。
void	setInt(Object obj, int i)       将字段的值设置为指定对象上的一个 int 值。
void	setLong(Object obj, long l)      将字段的值设置为指定对象上的一个 long 值。
void	setShort(Object obj, short s)      将字段的值设置为指定对象上的一个 short 值。
String	toString()     返回一个描述此 Field 的字符串。
boolean	isAccessible()    获取此对象的 accessible 标志的值。从AccessibleObject类中继承的方法
void	setAccessible(boolean flag)    将此对象的 accessible 标志设置为指示的布尔值。从AccessibleObject类中继承的方法

 注意：setAccessible(ture)：//如果是私有字段，要先将该私有字段进行取消权限检查的能力。也称暴力访问。

示例：

package se02.day07.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

//通过反射获取成员变量并使用
public class ReflectDemo04 {
	public static void main(String[] args) throws Exception {
		Class c = Class.forName("se02.day07.reflect.Person");
		//Filed[] getFileds():获取所有公共的成员变量
		//获取所有的成员变量
		Field[] fields = c.getDeclaredFields();
		for (Field field : fields) {
			System.out.println(field);
		}
		
		//通过无参构造创建一个对象
		Constructor con = c.getConstructor();
		Object obj = con.newInstance();
		//获取单个成员变量(公共)
		//获取address
		Field addressField = c.getField("address");
		addressField.set(obj, "上海");
		System.out.println(obj);
		
		//获取name,并赋值（私有）
		Field nameField = c.getDeclaredField("name");
		nameField.setAccessible(true);
		nameField.set(obj, "老王");
		System.out.println(obj);
		
		//获取age,并赋值（默认default）
		Field ageField = c.getDeclaredField("age");
		ageField.set(obj, 55);
		System.out.println(obj);
	}
}

输出结果：

private java.lang.String se02.day07.reflect.Person.name
int se02.day07.reflect.Person.age
public java.lang.String se02.day07.reflect.Person.address
Person [address=上海, age=0, name=null]
Person [address=上海, age=0, name=老王]
Person [address=上海, age=55, name=老王]

Method类

概念：Method类代表某个类中成员方法。调用某个对象身上的方法，要先得到方法，再针对某个对象调用。

方法摘要：

boolean	equals(Object obj)      将此 Method 与指定对象进行比较。
Class	getDeclaringClass()    返回表示声明由此 Method 对象表示的方法的类或接口的 Class 对象。
Object	getDefaultValue()   返回由此 Method 实例表示的注释成员的默认值。
Type[]	getGenericParameterTypes()           按照声明顺序返回 Type 对象的数组，这些对象描述了此 Method 对象所表示的方法的形参类型的。
Type	getGenericReturnType()   返回表示由此 Method 对象所表示方法的正式返回类型的 Type 对象。
String	getName()     以 String 形式返回此 Method 对象表示的方法名称。
Class[]	getParameterTypes()           按照声明顺序返回 Class 对象的数组，这些对象描述了此 Method 对象所表示的方法的形参类型。
Class	getReturnType()  返回一个 Class 对象，该对象描述了此 Method 对象所表示的方法的正式返回类型。
TypeVariable[]	getTypeParameters()           返回 TypeVariable 对象的数组，这些对象描述了由 GenericDeclaration 对象表示的一般声明按声明顺序来声明的类型变量。
Object	invoke(Object obj, Object... args)  对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。
boolean	isVarArgs()    如果将此方法声明为带有可变数量的参数，则返回 true；否则，返回 false。
String	toGenericString()    返回描述此 Method 的字符串，包括类型参数。
String	toString()      返回描述此 Method 的字符串。

注意：

①invoke方法：如果底层是静态的，那么可以忽略指定的obj参数，填充为null。即：如果传递给Method对象的invoke()方法的第一个参数为null，说明Method对象对应的是一个静态方法

② 如果底层方法所需的“形式参数”为0，则所提供的args数组长度可以为0或null。

示例：

package se02.day07.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

//通过反射获取成员方法并使用成员方法
public class ReflectDemo03 {
	public static void main(String[] args) throws Exception {
		Class c = Class.forName("se02.day07.reflect.Person");
		/*
		 * Method[] getMethods():获取本类和父类里面所有公共的成员方法
		 */
		Method[] methods = c.getMethods();
		for (Method method : methods) {
			System.out.println(method);
		}
		System.out.println("==================================");
		//获取自己类中里面所有的成员方法
		Method[] methods02 = c.getDeclaredMethods();
		for (Method method : methods02) {
			System.out.println(method);
		}
		
		//创建一个对象
		Constructor con = c.getConstructor();
		Object obj = con.newInstance();
		
		/*
		 * 获取单个成员方法
		 * Method getMethod(String name,Class ... parameterTypes)
		 * 参数1：方法名  参数2：方法的参数类型
		 */
		//获取show
		Method m1 = c.getMethod("show");
		//调用show方法
		m1.invoke(obj);
		System.out.println("==============================");
		
		//获取method(),并调用（公共有参）
		Method m2 = c.getMethod("method", String.class);
		m2.invoke(obj, "hello");
		//获取function(),并调用（私有无参）
		Method m3 = c.getDeclaredMethod("function");
		m3.setAccessible(true);
		m3.invoke(obj);
	}
}

 输出结果：

public java.lang.String se02.day07.reflect.Person.toString()
public java.lang.String se02.day07.reflect.Person.getString(java.lang.String,int)
public void se02.day07.reflect.Person.method(java.lang.String)
public void se02.day07.reflect.Person.show()
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()
==================================
public java.lang.String se02.day07.reflect.Person.toString()
private void se02.day07.reflect.Person.function()
public java.lang.String se02.day07.reflect.Person.getString(java.lang.String,int)
public void se02.day07.reflect.Person.method(java.lang.String)
public void se02.day07.reflect.Person.show()
show
==============================
methodhello
function

数组的反射：

数组的反射主要通过java.lang.reflect.Array类完成

Java反射机制通过Array类来处理数组，结合java.lang.Class类，可以在运行时获取数组的相关信息。要和集合包中的java.util.Arrays区分开，Arrays类是一个数组工具类（排序、遍历数组，将数组转换为集合等）。

实例化数组

//如果在编译时知道数组的类型（如int类型)，使用new关键字实例化
int[] array = new int[3];
//也可以使用反射：
int[] array = Array.newInstance(int.class,3);

 对数组用Class.forName()不是很直观。例如，你可以像这样访问基本类型数组的Class对象：

Class intArray = Class.forName("[I");

JVM中用字母I代表int。在左边加上[（左中括号）表示int数组的类。这对所有其他的基本类型同样有效。

对于对象，你需要用一个稍微不同的符号：  

Class stringArrayClass = Class.forName("[Ljava.lang.String;");

 注意类名左边的[L和右边的分号（；）。这表示一个你指定类型的对象的数组。

访问数组 
创建数组后，可以通过Array.set()和Array.get()来设置和获取数组中的元素： 

float[] array = (float[]) Array.newInstance(float.class, 3);  
Array.set(array, 0, 16.0f);  
Array.set(array, 1, 12.4f);  
Array.set(array, 2, 16.4f);  
  
System.out.format("array[0]=%f\n", Array.get(array, 0));  
System.out.format("array[1]=%f\n", Array.get(array, 1));  
System.out.format("array[2]=%f\n", Array.get(array, 2));

 输出： 
array[0]=16.000000 
array[1]=12.400000 
array[2]=16.400000 

判断传入的对象是不是数组 

boolean bArray = obj.getClass().isArray();  

获取数组的长度 

int length = java.lang.reflect.Array.getLength(obj); 

 判断数组元素的类型 

try {
	Class intArray = Class.forName("[Ljava.lang.String;");
	System.out.println(intArray.getComponentType());	//class java.lang.String
} catch (ClassNotFoundException e) {
	e.printStackTrace();
}

5、内省(Introspector)

内省是Java语言对JavaBean类属性、事件的一种缺省处理方法。

JavaBean是一种特殊的类，主要用于传递数据信息，这种类中的方法主要用于访问私有的字段，且方法名符合某种命名规则。如果在两个模块之间传递信息，可以将信息封装进JavaBean中，这种对象称为“值对象”(Value Object)，或“VO”。方法比较少。这些信息储存在类的私有变量中，通过set()、get()获得。

例如Student类中有属性name,那我们可以通过getName,setName来得到其值或者设置新的值。通过getName/setName来访问name属性，这就是默认的规则。Java中提供了一套API用来访问某个属性的getter/setter方法，通过这些API可以使你不需要了解这个规则（但你最好还是要搞清楚），这些API存放于包java.beans中。

JDK内省类库：

①PropertyDescriptor类：表示JavaBean类通过存储器导出一个属性

构造器：

PropertyDescriptor(String propertyName, Class beanClass)           通过调用 getFoo 和 setFoo 存取方法，为符合标准 Java 约定的属性构造一个 PropertyDescriptor。

PropertyDescriptor(String propertyName, Class beanClass, String readMethodName, String writeMethodName)           此构造方法带有一个简单属性的名称和用于读写属性的方法名称。

PropertyDescriptor(String propertyName, Method readMethod, Method writeMethod)           此构造方法带有某一简单属性的名称，以及用来读取和写入属性的 Method 对象。

方法摘要：

boolean	equals(Object obj)    将此 PropertyDescriptor 与指定对象进行比较。
Class	getPropertyType()   获得属性的 Class 对象。
Method	getReadMethod()    获得应该用于读取属性值的方法。
Method	getWriteMethod()    获得应该用于写入属性值的方法。
int	hashCode()  返回对象的哈希码。
void	setReadMethod(Method readMethod)   设置应该用于读取属性值的方法。
void	setWriteMethod(Method writeMethod) 设置应该用于写入属性值的方法。

示例：

Student类：

public class Student {
	private String name;
	private int age;
	public Student() {}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [age=" + age + ", name=" + name + "]";
	}
}

测试类：

package se02.day07.introspector;

import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class BeanInfoUtil {
	public static void setProperty(Student info, String name){
		PropertyDescriptor propDesc;
		Method methodSetName;
		try {
			propDesc = new PropertyDescriptor(name,Student.class);
			methodSetName = propDesc.getWriteMethod();
			methodSetName.invoke(info,"张三");
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println("set studentName:"+info.getName());
	}
	public static void getProperty(Student info,String name){
		try {
			PropertyDescriptor proDescriptor = new PropertyDescriptor(name,Student.class);
			Method methodGetName = proDescriptor.getReadMethod();
			Object obj = methodGetName.invoke(info);
			System.out.println("get studentName:"+obj);
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}
	public static void main(String[] args) {
		Student student = new Student();
		setProperty(student,"name");
		getProperty(student,"name");
	}
}

输出结果为：

set studentName:张三
get studentName:张三

②Introspector类

将JavaBean中的属性封装起来进行操作。在程序把一个类当做JavaBean来看，就是调用Introspector.getBeanInfo()方法，得到的BeanInfo对象封装了把这个类当做JavaBean看的结果信息，即属性的信息。

方法摘要：

static String	decapitalize(String name)           获得一个字符串并将它转换成普通 Java 变量名称大写形式的实用工具方法。
static void	flushCaches()           刷新所有 Introspector 的内部缓存。
static void	flushFromCaches(Class clz)           刷新给定类的 Introspector 的内部缓存信息。
static BeanInfo	getBeanInfo(Class beanClass)           在 Java Bean 上进行内省，了解其所有属性、公开的方法和事件。
static BeanInfo	getBeanInfo(Class beanClass, Class stopClass)           在给定的“断”点之下，在 Java Bean 上进行内省，了解其所有属性和公开的方法。
static BeanInfo	getBeanInfo(Class beanClass, int flags)           在 Java Bean 上进行内省，了解其所有属性、公开的方法和事件，并将结果用一些控制标记表示。
static String[]	getBeanInfoSearchPath()           获得将用来查找 BeanInfo 类的包名称的列表。
static void	setBeanInfoSearchPath(String[] path)           更改将用来查找 BeanInfo 类的包名称的列表。

BeanInfo类

PropertyDescriptor[]

getPropertyDescriptors()           获得 JavaBean的所有属性描述器

实例:

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;

public class BeanInfoUtil {
	public static void setPropertyByIntrospector(Student info, String name){
		try {
			BeanInfo beanInfo = Introspector.getBeanInfo(Student.class);
			PropertyDescriptor[] proDescriptors = beanInfo.getPropertyDescriptors();
			if(proDescriptors != null && proDescriptors.length>0){
				for(PropertyDescriptor propDesc:proDescriptors){
					if(propDesc.getName().equals(name)){
						Method methodSetName = propDesc.getWriteMethod();
						methodSetName.invoke(info, "李四");
						break;
					}
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println("set studentName:"+info.getName());
	}
	public static void getPropertyByIntrospector(Student info,String name){
		try {
			BeanInfo beanInfo = Introspector.getBeanInfo(Student.class);
			PropertyDescriptor[] proDescriptors = beanInfo.getPropertyDescriptors();
			if(proDescriptors!=null && proDescriptors.length>0){
				for(PropertyDescriptor propDesc:proDescriptors){
					if(propDesc.getName().equals(name)){
						Method methodGetName = propDesc.getReadMethod();
						Object obj = methodGetName.invoke(info);
						System.out.println("get studentName:"+obj);
						break;
					}
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	public static void main(String[] args) {
		Student student = new Student();
		setPropertyByIntrospector(student,"name");
		getPropertyByIntrospector(student,"name");
	}
}

输出结果：

set studentName:李四
get studentName:李四

6、泛型(Generic)

泛型，即“参数化类型”，一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。参数化类型就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式(可以称之为类型形参)，然后在使用或调用时传入具体的类型(类型实参)。

泛型的本质是为了参数化类型(在不创建新的类型情况下，通过泛型指定的不同类型来控制形参具体限制的类型)。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称之为泛型类、泛型接口、泛型方法。

泛型的好处：

1. 将运行期间遇到的问题提前到编译期间
2. 避免了向下转型
3. 优化了程序设计，解决了黄色警告

实例1：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class GenericDemo01 {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("hello");
		list.add("world");
		list.add("java");
		list.add(100);
		
		Iterator iter = list.iterator();
		while(iter.hasNext()){
			String s = iter.next();
			System.out.println(s);
		}
	}
}

毫无疑问，程序的运行结果会以崩溃结束：

java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
	at se01.day05.GenericDemo01.main(GenericDemo01.java:18)

ArrayList可以存放任意类型，例子中添加了一个String类型，添加了一个Integer类型，再使用时都以String的方式使用，因此程序崩溃了。为了解决类似这样的问题（在编译阶段就可以解决），泛型应运而生。

我们将第一行声明初始化list的代码更改一下，编译器会在编译阶段就能够帮我们发现类似这样的问题。

List list = new ArrayList();
...
//list.add(100); 在编译阶段，编译器就会报错

 实例2：

//泛型类
class ObjectDemo{
	private E e;
	public void setE(E e){
		this.e = e;
	}
	public E getE(){
		return e;
	}
}

//不使用泛型
class ObjectDemo02{
	private Object obj;

	public Object getObj() {
		return obj;
	}

	public void setObj(Object obj) {
		this.obj = obj;
	}
}
public class GenericDemo02 {
	public static void main(String[] args) {
		ObjectDemo od = new ObjectDemo();
		od.setE("张伟");
		System.out.println(od.getE());
		
		ObjectDemo od2 = new ObjectDemo();
		od2.setE(12);
		int i = od2.getE();
		System.out.println(i);
		
		ObjectDemo02 obj = new ObjectDemo02();
		obj.setObj("最低配");
//		Integer inter =  (Integer) obj.getObj();//.ClassCastException
//		System.out.println(inter);
		
	}
}

由上可知，在不使用时我们会用到Object作为数据类型，在使用时再根据具体的情况向下转型还可能出现java.lang.ClassCastException异常，使用泛型后就避免了这种情况。

泛型的使用：

①泛型类：定义在类上面

格式：public class 类名<泛型类型1,...>

例如：

//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
public class Generic{     //一个类上可以定义多种泛型声明
    //key这个成员变量的类型为T,T的类型由外部指定  
    private T key;

    public Generic(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定
        this.key = key;
    }

    public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定
        return key;
    }
    public R fun(T p){  //R是返回值类型，T为方法参数类型
        teturn null;    
    }
}

测试：

public class GenericTest{
    public static void main(String[] args){
       //泛型的类型参数只能是类类型（包括自定义类），不能是简单类型
       //传入的实参类型需与泛型的类型参数类型相同，即为Integer.
       Generic genericInteger = new Generic(123456);
       //传入的实参类型需与泛型的类型参数类型相同，即为String.
       Generic genericString = new Generic("key_vlaue");
       System.out.println("泛型测试","key is " + genericInteger.getKey());
       System.out.println("泛型测试","key is " + genericString.getKey());
    }
}

输出结果：

泛型测试: key is 123456
泛型测试: key is key_vlaue

 泛型类的所有实例都具有相同的运行时类，而不管它们的实际类型参数如何。

实例：

List l1 = new ArrayList();
List l2 = new ArrayList();
System.out.println(l1.getClass()== l2.getClass());    //true

注意：

• 定义的泛型类，要么传入所有的泛型类型实参，要么不传入任何泛型类型实参。即:Generic...或Generic...不能是Generic...
• 泛型的类型参数只能是类类型，不能是简单类型。
• 不能对确切的泛型类型使用instanceof操作。如下操作是非法的，编译时会报错。if(ex_num instanceof Generic){}

②泛型接口：定义在接口上面

格式：public interface 接口名<泛型类型1,...>

任何情况下如果要使用接口，就必须定义相应的子类，而对于实现了泛型接口的子类而言，有以下两种实现方式：

• 实现方式一：在子类继续设置泛型标记
• 在子类不是设置泛型，而为接口明确定义一个泛型类型

示例：

//泛型接口
interface Inter{
	void show(T t);
}

//实现类
//1)知道实现什么泛型
class InterImpl implements Inter{
	@Override
	public void show(String s) {
		System.out.println(s);
	}
}
//2)不知道实现什么泛型
class InterImpl02 implements Inter{
	@Override
	public void show(T t) {
		System.out.println(t);
	}
}
public class GenericDemo03 {
	public static void main(String[] args) {
		//1)
		InterImpl i = new InterImpl();
		i.show("hello");           // hello
		
		//2)
		InterImpl02 i2 = new InterImpl02();
		i2.show("world");          //world
		InterImpl02 i3 = new InterImpl02();
		i3.show(13);               //13
	}    
}

注意：如果不声明泛型，如：class InterImpl02 implements Inter，编译会报错“Unknown class”

③泛型方法：定义在方法上

格式：修饰符 <泛型类型> 返回值类型 方法名(参数列表){}

注意：

• 泛型方法即在方法上设置泛型类型，参数中可以出现泛型类或类中未定义的泛型标识
• 在方法上定义泛型时，这个方法不一定要在泛型类中定义
• 泛型方法中可以出现任意多个泛型标识符
• 静态的泛型方法需要额外的泛型声明，即使使用了泛型类声明过的泛型类型
• 静态方法若有返回值其类型不能为泛型

示例：

//泛型方法
class Generic{//这个类是个泛型类，在上面已经介绍过
	private T key;
	
	//这只是类中一个普通的成员方法，只不过他的返回值是在声明泛型类已经声明过的泛型。
	public T getKey(){
        return key;
        }
	/* 因为在类的声明中并未声明泛型K，所以在使用K做形参和返回值类型时，编译器会无法识别。
	 * K cannot be resolved to a type
	 * public K setKey(K key){	
        this.key = key;
	}*/
	//在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型
	public  void show(T t){
		System.out.println(t);
	}
	public  T fun(E e){
		System.out.println(e);
		return key;
	}
	//泛型的数量也可以为任意多个 
	public  R showKeyName(R r,V v){
		return null;
	} 
	/*
     * 如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
     * 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
     * 如：public static void method(T t){...},此时编译器会提示错误信息：
     * Cannot make a static reference to the non-static type T
     */
	public static  void method(E t){}
}
public class GenericTest {
	public static void main(String[] args) {
		Generic od = new Generic();
		od.show("hello");    //hello
		Generic od2 = new Generic();
		od2.show(132);       //132
	}
}

通配符：

利于泛型技术虽然解决了向下转型所带来的安全隐患问题，但同时又会产生一个新的问题：即便是同一个类，由于设置泛型类型不同，其对象表示的含义也不同，因此不能直接进行引用操作。为了解决这个问题，Java提供通配符“?”解决参数传递问题。

• ?：表示任意类型
• ？ extends 类：设置泛型上限，可以在声明和方法参数上使用；如? extends Nummber：意味着可以设置Number或者Number的子类(Integer、Double...)
• ? extends 类：设置泛型下限，方法参数上使用；如 ? extends String：意味着只能设置String或它的父类Object

实例：

import java.util.ArrayList;
import java.util.Collection;

//通配符
class Animal{}
class Cat extends Animal{}
class Dog extends Animal{}
public class GenericDemo05 {
	public static void main(String[] args) {
		//？ 任意类型
		Collection c1 = new ArrayList();
		Collection c2 = new ArrayList();
		Collection c3 = new ArrayList();
		
		//? extends E (向下限定)
		Collection c4 = new ArrayList();
		Collection c5 = new ArrayList();
		Collection c6 = new ArrayList();
//		Collection c4 = new ArrayList