Alex Hunsley wrote:

They do so match!

Dzikus, you're entirely correct. Array types are subtypes of Object, and can
be upcast without fear. Downcasting works if the Object happens to be an array
at runtime for the downcast.

What you did, testing the claim, exemplifies wise use of Usenet.

There's a lot of reflection and C++ idiom in your posted code, so I didn't
delve into it much. To answer your original question, how to print an array
from a method that takes an Object parameter:

Another poster suggested simply using the parameter's toString() method, which
you can do implicitly or explicitly.

private PrintWriter out;
...
public void foo( Object obj )
{
    out.println( "Object: " );
    out.println( obj );
}

If you don't like the way the arrays' toString() methods work, you can crack
arrays into a loop. This requires a check for each primitive type and Object
if you're avoiding complicated reflection:

public void foo( Object obj )
{
    if ( obj instanceof Object [] )
    {
        Object [] oarr = (Object []) obj;
        for( Object o : oarr )
        {
            out.println( o );
        }
    }
    else if ( obj instanceof int [] )
    {
        int [] iarr = (int []) obj;
        for ( int i : iarr )
        {
            out.println( i );
        }
    }
    // ... byte, char, short, long, float, double
    else
    {
        out.println( obj );
    }
    out.flush();
}

As another poster pointed out, in a type that you design a reasonable
implementation of toString() is important.

Even better is when you know that you'll use only arrays of a type that you
design (or subtype thereof). Then you can simplify to a static method of, say,
parent class Foo that can print values of Foo [] as you like. If the array
lister method calls each element's own toString() then the whole listing will
be sensible.

- Lew

It's not trivial to do this, but it's more tedious than difficult
to handle an arbitrary input object if you allow a
recursive solution.

I believe you are correct that you will have to do explicit downcasts
to each of the primitive types.  You may also want to handle
arrays of objects specially (which will get you multi-dimensional
arrays of all types as well).

E.g.,

   void method(Object o) {

         if (o instanceof Object[]) {
                Object[] oa = (Object[]) o;
                for (Object ox: oa) method(ox);
         } else if (o instanceof int[]) {
                ... process int array ..
         } else if (o instanceof double[]) {
         ... handle all 7 primitive arrays explictly
         } else {
               ... Handle a non-array Object
         }
   }

This is one example where it would be nice to have double-dispatch but
that's not available in Java.  [Double dispatch would allow you to
select from among overloaded 'method's the one whose signature
matched the actual rather than the declared class of the argument.]

   Regards,
   Tom McGlynn

    In either of the ways I showed, or perhaps in some other
way I didn't think of: I'm only a user of Java, not a guru.
The documentation for java.lang.Class is likely to be helpful.

    One way or another, you will need to determine the actual
class of the array your Object reference refers to.  You said
you only cared about arrays of primitive types, which makes
things a little easier: There is a fixed number of primitive
types to check for, and writing the code for each of them (or
for the subset that interests you) may take you a few minutes
but doesn't require much ingenuity.

   I can't believe I missed that function.

   Oh well. Hooray for teamwork! =)

   - Oliver