Is a String array subclass of an Object array?

Question

I think I'm missing something basic here. Any explanation or pointers to previously asked questions will be very helpful.

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
    }

}

So, it seems like a List<String> is not a subclass of a List<Object> but a String[] is a subclass of Object[].

Is this a valid assumption? If so, why? If not, why?

Thanks

Bozho · Accepted Answer · 2012-01-11 19:39:26Z

11

Java arrays are covariant, i.e. they allow Object[] foo = new String[2];. But this doesn't mean they are subclasses. String[] is a subclass of Object (although instanceof returns true, String[].class.getSuperclass() returns Object)

edited Jan 11, 2012 at 19:39

answered Jan 11, 2012 at 19:32

Bozho

599k147 gold badges1.1k silver badges1.2k bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

Kal Over a year ago

From @maerics comment below -- the new String[0] instanceof Object[] returns true. So, String[] is a type of Object and a type of Object[] and a type of CharSequence[] etc. Correct?

Bozho Over a year ago

@Kal that appears to be a special case to cover the covariance. See my update

Miserable Variable Over a year ago

String[] >1 Object seems to be a bug, I cannot get getSuperClass to return an Array for any other type either. But java.sun.com/docs/books/jls/third_edition/html/… seems to say that is what it should be

Itay Maman · Accepted Answer · 2012-01-11 19:41:39Z

6

Yes, your assumption is valid. As said by @Bozho arrays are covariant, whereas generic collections (such as generic List) are not covariant.

Covariance in arrays is risky:

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

The third line fires a runtime exception. If it weren't firing this exception then you could get a String variable, s, that references a value that is not a String (nor a subtype thereof): a Date.

answered Jan 11, 2012 at 19:41

Itay Maman

30.8k12 gold badges93 silver badges124 bronze badges

1 Comment

Kal Over a year ago

Thanks .. I have never seen the ArrayStoreException before.

maerics · Accepted Answer · 2012-01-11 19:34:40Z

4

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

answered Jan 11, 2012 at 19:34

maerics

157k47 gold badges277 silver badges299 bronze badges

Comments

pholser · Accepted Answer · 2012-01-11 19:35:35Z

3

You are correct. Array types are covariant in Java by design, but a Foo<Sub> is-not-a Foo<Super>.

answered Jan 11, 2012 at 19:35

pholser

4,9471 gold badge29 silver badges39 bronze badges

Comments

Miserable Variable · Accepted Answer · 2012-01-11 20:48:31Z

2

String[] is a subclass of Object[]

Correct, see 4.10.3 Subtyping among Array Types:

If S and T are both reference types, then S[] >1 T[] iff S >1 T.

Since String >1 Object so String[] >1 Object[]

That is, String[] is a direct subtype of Object[]

Object >1 Object[]

Therefor Object > String[]; String[] is a (indirect?) subtype of Object

No such relationship exists for generics, so List<String> > List<Object> is not true.

Now, consider the following simple example:

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

It does not compile, because x is invoking allF with a List<C> which is not a List<I>. To be able to use List<C> the signature has to change slightly:

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

Now it compiles. Informally, li is a List of some type that extends/implements I. So List<C> is assignable to List<? extends I>. What you can do with such a list is limited. Essentially, you can read/access it but cannot write/modify it.

answered Jan 11, 2012 at 20:48

Miserable Variable

28.8k15 gold badges79 silver badges138 bronze badges

2 Comments

Stephen C Over a year ago

Umm ... subtype and subclass mean different things.

Miserable Variable Over a year ago

@StephenC, for classes subtyping is same as subclassing, if I am reading 4.10.2. I guess the correct response would be "Arrays are not classes so they cannot have subclass relationship but String[] is a sybtype of Object[]". Is that what you are hinting?

Collectives™ on Stack Overflow

Is a String array subclass of an Object array?

5 Answers 5

3 Comments

1 Comment

Comments

Comments

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

3 Comments

1 Comment

Comments

Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related