Home | Contact Us | FAQ | Search & Site Map | Link to Us
Sign In | Join | Other 45 Sites in Network
HomeAnnouncementsWhite Papers
Discussion GroupsFirst AidDatabasesJavaBeansGUIJava 3DVirtual MachineCORBASecurityToolsGeneral
Java DirectoryOpen Source ProjectsSample Book ChaptersUser GroupsWeb Resources
Related Topics
Databases.NETMore Topics ...

Java Forum / General / October 2007

Tip: Looking for answers? Try searching our database.

Create an Object from an Array Class

Thread view: 
Z - 30 Oct 2007 22:33 GMT
I am using reflection to getmethod(methodName, Class parameters) and
invoke(object, obj[] parameters) methods from some Objects.

My problem is:

Say: I want to invoke a method that takes String[] object as parameter
(I was able to getmethod correctly). When I try to create an object
(to pass as args to invoke):

Object someObject= (Object) String[].class.newInstance();

(Note that the object is not always an instance of String[]... it
could be an instance of  SomeOtherClass[])

I do get the following exception:

java.lang.InstantiationException: [Ljava.lang.String;

My question is:

Does the "[L" at the beginning and the ";" at the end have a meaning?
How can I solve this problem?

I am using IntelliJ 6.0.5.

Thanks in advance.
Joshua Cranmer - 30 Oct 2007 22:53 GMT
> I am using reflection to getmethod(methodName, Class parameters) and
> invoke(object, obj[] parameters) methods from some Objects.
[quoted text clipped - 9 lines]
> (Note that the object is not always an instance of String[]... it
> could be an instance of  SomeOtherClass[])

RTFM:
[ From Class.newInstance(): ]
Throws:
    [ ... ]
    InstantiationException - if this Class represents an abstract
class, an interface, an array class, a primitive type, or void; or if
the class has no nullary constructor; or if the instantiation fails for
some other reason.
    [ ... ]

Arrays cannot be created with a new instance, because they are a
special-case class.

> My question is:
>
> Does the "[L" at the beginning and the ";" at the end have a meaning?

Yes, this is the internal representation of the class (it means that
this is an array of java.lang.String's).

> How can I solve this problem?

What you are probable intending is something like this:

Method m = Class.forName("some.pkg.Type").getMethod("main",
    String[].class);
m.invoke(null, new String[0]);

> I am using IntelliJ 6.0.5.

Java version matters, not IDE version.

Signature

Beware of bugs in the above code; I have only proved it correct, not
tried it. -- Donald E. Knuth

Joshua Cranmer - 30 Oct 2007 22:56 GMT
> What you are probable intending is something like this:
>
> Method m = Class.forName("some.pkg.Type").getMethod("main",
>     String[].class);
> m.invoke(null, new String[0]);

If the type of array must be determined at runtime, the following idiom
can also be used:

// arrayType is a class representing the type we want.
Object array = Array.newInstance(arrayType, 0); // Empty array

Array has another overloaded version that handles multiple array dimensions.

Signature

Beware of bugs in the above code; I have only proved it correct, not
tried it. -- Donald E. Knuth

Z - 30 Oct 2007 23:53 GMT
Thanks for the clarifications. I hope that my phrasing of the question
shows where I am stuck.

What I am intending to do is:

//here is how my program is flowing

String className = namesOfAllClasses[j]; //I have it coming through a
loop

Class class1 = Class.forName(className);

Fields fields = class1.getDeclaredFields(); //assuming that all fields
are Class type (not primitive)

for (int i=0; i < fields.length; i++) {
   Class newClass = Class.forName(fields[i].getType().getName()); //
create a class of the field type
   Object newObject = newClass.newInstance(); //create an object of
the new field type
   Method m = newClass.getMethod(methodName, newClass); /*get method;
we can assume it's "set"+fields[i].getName()*/
   Object arguments[] = {"dummy"};
   m.invoke(newObject, arguments);
}

/*
When a field is someClass[], I am facing troubles since now the
   fields[i].getType().getName() = L[some.pkg.name.someClass;
In this case:
   Class newClass = Class.forName(fields[i].getType().getName()) is
returning with a result (no exceptions)

But using the newInstance is generating exceptions since it's a
special-case class as you explained.

You have used
m.invoke(null, new String[0]); //it gave me back a
nullPointerRxception even though it's a static method

My problem is that the second parameter in invoke does not have to be
a String type for the parameter object but is an object instance of
the L[some.pkg.name.someClass; (object array)

Example: This method looks like this in ClassName.java

   public void setsomeObjectProperty(some.pkg.name.someClass[]
someObjectProperty) {
       this.someObjectProperty= someObjectProperty;
   }

Any tips?
*/

Thanks again for your time

> > I am using reflection to getmethod(methodName, Class parameters) and
> > invoke(object, obj[] parameters) methods from some Objects.
[quoted text clipped - 45 lines]
> Beware of bugs in the above code; I have only proved it correct, not
> tried it. -- Donald E. Knuth
Daniel Pitts - 31 Oct 2007 02:04 GMT
>>> I am using reflection to getmethod(methodName, Class parameters) and
>>> invoke(object, obj[] parameters) methods from some Objects.
[quoted text clipped - 93 lines]
>
>  
First, please don't top-post. Reply after the bottom or interleaved.

Second, Don't look for set+name or get+name methods. Use the
introspection API. (java.beans.*).  There is more to JavaBeans than just
a naming convention.

Also, ask yourself if you REALLY need to use reflection/introspection at
all.  I wrote an article about it on my blog sometime last year
<http://virtualinfinity.net/wordpress/>

I'll post the exact link when I have a chance to look it up.

Signature

Daniel Pitts' Tech Blog: <http://virtualinfinity.net/wordpress/>

Lasse Reichstein Nielsen - 31 Oct 2007 01:01 GMT
> I am using reflection to getmethod(methodName, Class parameters) and
> invoke(object, obj[] parameters) methods from some Objects.
[quoted text clipped - 6 lines]
>
> Object someObject= (Object) String[].class.newInstance();

That fails, because the array class does not have a normal
constructor. Here you try to invoke a default constructor.

> (Note that the object is not always an instance of String[]... it
> could be an instance of  SomeOtherClass[])
>
> I do get the following exception:

> java.lang.InstantiationException: [Ljava.lang.String;

> My question is:
>
> Does the "[L" at the beginning and the ";" at the end have a meaning?

Yes. Java writes the name of and array of object type as "[L" followed
by the name of the class and ended by ";". I.e., the type
my.foo.Foo[]
has the name "[Lmy.foo.Foo;". Arrays of base types have other abbreviations,
e.g., "[I" for int[].

> How can I solve this problem?

Array.newInstance(String.class, 0); // equivalent to: new String[0]

/L
Signature

Lasse Reichstein Nielsen  -  lrn@hotpop.com
DHTML Death Colors: <URL:http://www.infimum.dk/HTML/rasterTriangleDOM.html>
 'Faith without judgement merely degrades the spirit divine.'



Free Magazines

Get these publications absolutely FREE for up to 12 months. There are no hidden fees and no obligation. Simply choose a title, complete the application form and submit it. Read more ...

Oracle MagazineNetwork ComputingComputer WorldBio-IT WorldeWeekInformation WeekInfosecurity
 
Sign In
Join
My Latest Posts
My Monitored Threads
My Blog
My Photo Gallery
My Profile
My Homepage

Start New Thread
Enable EMail Alerts
Rate this Thread



©2008 Advenet LLC   Privacy Policy - Terms of Use
This website includes both content owned or controlled by Advenet as well as content owned or controlled by third parties.