关于Object数组强转成Integer数组的问题：Ljava.lang.Object; cannot be cast to [Ljava.lang.Integer;

一、当把Object数组，强转的具体的Integer数组时，会报错。

代码如下：

   //数组强转报错演示  
　　Object[] numbers = {1,2,3};
     Integer[] ints = (Integer[])numbers;

 报错：

java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.Integer;

原因：

　　根本原因还是类型的继承关系问题，Integer[]并不是Object[]的子类。虽然，Integer继承自Object,但Integer[]的直接父类是Object。即所有数组类型的直接父类都是Object，可以通过反射来验证。数组类型是写在jvm里得，就像8种基本类型，我们无法在java的标准库中找到这个类。

//数组的直接父类演示
@Test
public void testArrayClass() {
    Integer[] i = {1,2,3};
    Object[] o = {1,2,3};            
    System.out.println(o.getClass().getSuperclass().getName());            
    System.out.println(i.getClass().getSuperclass().getName());
}     

输出结果：

java.lang.Object
java.lang.Object

解决方案，可以对数组每个成员分别转化：

 　 @Test
    public void testArrayChange() {
        Object[] numbers = {1,2,3};
        Integer[] ints = new Integer[numbers.length];
        for(int i = 0;i<numbers.length;i++) {
            ints[i] = (Integer)numbers[i];
        }
    }

二、另外：虽然强转会有类型转换异常，但是，java有一个语法特性：

　　当A被B继承时，A[]类型的引用可以指向B[]类型的实例.

　　　　即：A[] a = new B[3]成立。

    @Test
    public void testArrayClass() {
        Integer[] i = {1,2,3};
        Object[] o = i;
        System.out.println("引用成功！！");
    }    

 控制台：

引用成功！！

这种情况被允许，是java的一个语法特性，这种语法特性的存在是为了方法中参数传递的方便。

在给数据库语句传递参数时，将多个参数传递给sql语句中的每一个占位符，可以使用Object[]类型的参数来接收，然后，在方法中遍历数组元素，根据不同类型，转化成相应的类型数据。

    @Test
    public void testTraversalObject() {
        Integer[] a = {1,2,3};
        String[] b = {"a","b","c"};
        traversalArray(a);
        traversalArray(b);
    }
    
    public void traversalArray(Object[] o) {
        for(int i = 0;i<o.length;i++) {
            if(o[i] instanceof Integer) {
                System.out.println("PreparedStatement添加int参数");
            }
            if(o[i] instanceof String) {
                System.out.println("PreparedStatement添加String参数");
            }
            if(o[i] instanceof java.util.Date) {
                System.out.println("PreparedStatement添加String参数");
            }
            else {
                System.out.println("还有其他类型得意添加！");
            }
        }
    }

如果没有这个特性：

　　1、在方法中定义Object类型的参数，来接收数组参数，如果在代码内部进行类型转化，则有类型转化异常的风险，因为，Object是顶级父类，传递的参数可以不是个数组

Object obj = 1;
Object[] objs = (Object[]) obj;

　　2、使用具体的数据类型数组，String[],Integer[],则会使类型的限制太过固定失去灵活性，每种类型都要新增一个方法来代替。

 @Test
    public void testTraversalObject() {
        Integer[] a = {1,2,3};
        String[] b = {"a","b","c"};
        traversalIntegerArray(a);
        traversalStringArray(b);
    }
    
    public void traversalIntegerArray(Integer[] arr) {
        for(int i = 0;i<arr.length;i++) {
           //给PreparedStatement添加参数
　　　　　}
　　　}
　　　
　　public void traversalStringArray(String[] arr) {
        for(int i = 0;i<arr.length;i++) {
           //给PreparedStatement添加参数
　　　　　}
　　　} 
}