¿Hay una subclase de matriz String de una matriz de objetos?

Question

Creo que me falta algo básico aquí. Cualquier explicación o sugerencia a preguntas previamente hechas será muy útil.

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 
    } 

} 

Por lo tanto, parece que una List<String> no es una subclase de un List<Object> sino un String[] es una subclase de Object[].

¿Es esto una suposición válida? Si es así, ¿por qué? Si no, ¿por qué?

Gracias

Answer 1

Java arrays are covariant, es decir, que permiten Object[] foo = new String[2];. Pero esto no significa que sean subclases. String[] es una subclase de Object (aunque instanceof devoluciones, String[].class.getSuperclass() vuelve Object cierto)

Answer 2

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

Answer 3

Estás en lo correcto. Los tipos de matriz son covariantes en Java por diseño, pero un Foo<Sub> no es un Foo<Super>.

Answer 4

Sí, su suposición es válida. Como dicen las matrices @Bozho son covariantes, mientras que las colecciones genéricas (como la Lista genérica) no son covariantes.

covarianza de matrices es arriesgado:

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 

La tercera línea dispara una excepción en tiempo de ejecución. Si no se activa esta excepción, puede obtener una variable String, s, que hace referencia a un valor que no es String (ni un subtipo del mismo): a Date.

Answer 5

String [] es una subclase de Object []

correcta, ver 4.10.3 Subtyping among Array Types:

Si S y T son ambos tipos de referencia, entonces S []> 1 T [ ] si y sólo si S> 1 T.

Desde String >1 Object así String[] >1 Object[]

Esto es, String[] es un subtipo directa de Object[]

Objeto> 1 Object []

para ello Object > String[]; String[] es un (indirecta?) subtipo de Object

No existe tal relación de los genéricos, por lo List<String> > List<Object> no es cierto.

Ahora, consideremos el siguiente ejemplo:

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); 
    } 
} 

No compila, porque x invoca allF con un List<C> que es no un List<I>. Para poder utilizar List<C> la firma tiene que cambiar un poco:

void allF(List<? extends I> li) { 

Ahora se compila. De manera informal, li es una List de algún tipo que se extiende/implementa I. Así List<C>es asignable aList<? extends I>. Lo que puedes hacer con tal lista es limitado. Básicamente, puede leer/acceder pero no puede write/modify.