Java 字符串数组是对象数组的子类吗？

我想我缺少一些基本的东西。任何对之前提出的问题的解释或提示都将非常有用

import java.util.Arrays;
import java.util.List;

public class St {

    public static void bla(Object[] gaga) {
            gaga[0] = new Date(); // throws ArrayStoreException
        System.out.println(gaga[0]);
    }

    public static void bla(List<Object> gaga) {
        System.out.println(gaga.get(0));
    }

    public static void main(String[] args) {
            String[] nana = { "bla" };
        bla(nana); // Works fine

        List<String> bla1 = Arrays.asList(args);
        bla(bla1); // Wont compile

            System.out.println(new String[0] instanceof Object[]); // prints true
            System.out.println(nana.getClass().getSuperclass().getSimpleName()); // prints Object
    }

}

导入java.util.array；
导入java.util.List；
公共类街{
公共静态无效bla（对象[]gaga）{
gaga[0]=新日期（）；//引发ArrayStoreException
System.out.println（gaga[0]）；
}
公共静态无效bla（列表gaga）{
System.out.println（gaga.get（0））；
}
公共静态void main（字符串[]args）{
字符串[]nana={“bla”}；
布拉（娜娜）；//很好用
List bla1=Arrays.asList（args）；
bla（bla1）；//不会编译
System.out.println（对象[]的新字符串[0]instanceof；//打印为true
System.out.println（nana.getClass（）.getSuperclass（）.getSimpleName（））；//打印对象
}
}

因此，似乎

列表

不是

列表

的子类，而是

字符串[]

是

对象[]

的子类

这是一个有效的假设吗？若然，原因为何？若否，原因为何

---

感谢

，即他们允许

对象[]foo=新字符串[2]。但这并不意味着它们是子类
String[]
是
Object
的子类（尽管
instanceof
返回true，
String[].class.getSuperclass（）
返回
Object
）
您是正确的。在Java中，数组类型在设计上是协变的，但是a
Foo
不是-a
Foo
是的，您的假设是有效的。正如@Bozho所说，数组是协变的，而泛型集合（如泛型列表）不是协变的

阵列中的协方差存在风险：

String[] strings = new String[] { "a", "b" }
Object[] objects = strings;
objects[0] = new Date();  // <-- Runtime error here 
String s = strings[0];
s.substring(5, 3);        // ????!! s is not a String 

String[]strings=新字符串[]{“a”，“b”}
Object[]objects=字符串；
对象[0]=新日期（）；//
字符串[]是对象[]的子类

正确，请参阅：

如果S和T都是引用类型，则S[]>1T[]如果S>1T

由于
String>1对象
so
String[]>1对象[]

也就是说，
String[]
是
Object[]

对象>1对象[]

因此
对象>字符串[]
String[]
是
对象的（间接？子类型

(new String[0] instanceof Object[]) // => true

泛型不存在这种关系，因此
List>List
不是真的

现在，考虑下面的简单例子：
import java.util.*;

class G {
    interface I {
    void f();
    }
    class C implements I {
    public void f() {}
    }

    void allF(List<I> li) {
    for (I i : li) { i.f(); }
    }

    void x(List<C> lc) {
    allF(lc);
    }
}

现在它编译了。非正式地说，
li
是扩展/实现I的某种类型的
List
。因此
List
可分配给下面@maerics注释中的
ListFrom:
对象[]的新字符串[0]实例返回true。因此，String[]是一种Object类型，Object[]类型和CharSequence[]类型。正确吗？@Kal这似乎是一种覆盖协方差的特例。查看我的更新
String[]>1对象
似乎是一个bug，我也无法让
getSuperClass
为任何其他类型返回数组。但似乎说这就是它应该做的。。我以前从未见过ArrayStore例外。嗯。。。子类型和子类的意思不同。@StephenC，对于类来说，如果我在读的话，子类型和子类是一样的。我想正确的回答应该是“数组不是类，所以它们不能有子类关系，但是字符串[]是对象[]的sybtype”。这就是你暗示的吗？
void allF(List<? extends I> li) {