A better solution IMO is duck-typing+constraints. This is the approach C++ is moving towards.
Why should sizeof() be limited to just integral types (a.k.a. types which extend DataType)? If it has a sizeof method (better yet, have a sizeof operator like in C++), I should be able to call it. The compiler can check if it really does, and if so use it. If not, throw a compiler error. There is also on-going work in C++ development to create a "constraints" or "concepts-lite" which encapsulates this idea better. The details allow the developer to explicitly spell out what it means for a class to encapsulate a certain idea, for example the mergable idea, or copyable. A linked list node could be mergable, and two vectors/array lists could be mergable. Hashsets should be mergable, etc.
Of course, this is all C++, not Java. I don't think this is something that's coming to Java anytime soon because of the way Java generics work. There's not one "best" language, and our goal as programmers is to pick a suitable language to solve the problem at hand.
There's also the issue of backwards compatibility, and exact details which need to be worked out. With C++ any idea proposal needs to have at least 2 things:
1. What type of problems the idea is intended to solve
2. How the solution would work (a.k.a. a prototype implementation with standardese draft documents of the feature)
Java's language has really been stagnant for quite a while because the maintainers of the language can't agree on what direction to take Java, plus there's a general lack of people who want to work on the latter part. A few features of Java 7's initial design were post-poned to Java 8 or indefinitely because of the lack of people working on implementing/specifying the features.