The gordian knot here is that whenever you see Object as part of a
*type* you'd like to interpret it as a top type (the root of the
hierarchy). OTOH, when you see Object as part of an *expression* you'd
like to interpret it as something else (e.g. RefObject). And there are
also things in between - e.g. Object.class, where it's not uber clear
whether you want one or the other, but let's not get too distracted by
these for the moment.
From a type-system perspective, the basic property called
_preservation_ mandate (Gavin, correct me if I'm wrong :-)) that, given
an expression of *static type* E, the type associated with the value V
obtained by executing the expression must be a subtype of E, which we
can write:
typeof(V) <: E
(of course this is only true for type systems which feature subtyping,
otherwise typeof(V) == E).
So, in our case, the theorem demands something like this:
typeof(new Object()) <: Object
But it seems like we have already ruled this out - since, if typeof(new
Object()) is 'RefObject', you don't want RefObject <: Object.
So, from a type-system perspective, we're on unsound territory, at least
assuming we only use classes w/ single inheritance.
Interfaces (or, more generally, multiple inheritance) add a bit of
flexibility because (as Brian said) we could say:
typeof(new Object()) = XYZ, where XYZ <: RefObject && XYZ <: Object
So this would satisfy the type theory; whether it can be made into
something that looks compelling for a Java user, that's another story.
Note that the dual nature of *type* vs. *expression* mentioned at the
beginning will bite you as soon as you start doing things like this:
void m(RefObject ro) { ... }
m(new Object()) // ok, as per above
m((Object)new Object()) // not ok?
m(Object.class.newInstance()) // WAT!?
Maurizio
On 08/04/2019 20:58, Brian Goetz wrote:
No matter which way we go, we end up with an odd anomaly: “new Object()” should
yield an instance of RefObject, but we don’t want Object <: RefObject for
obvious reasons. Its possible that “new Object()” could result in an instance of
a_species_ of Object that implement RefObject… but our theory of species doesn’t
quite go there and it seems a little silly to add new requirements just for this.
