Question

The reflection classes and methods as well as class loaders etc. need the so called “binary” names of classes to work with.

The question is, how does one get the binary name if one only has the fully qualified name, i.e. the name that one would use in source code.

For example:

package frege;
public static class RT {
    ....
    public static class X { .... }
}

The fully qualified name of the class would be frege.RT.X. Yet, to get the class object, one needs to write:

Class.forName("frege.RT$X")

and not

Class.forName("frege.RT.X")    // fails with ClassNotFoundException

because X happens to be an inner class of frege.RT.

A possible, but clumsy, solution would be to replace . with $ from backwards, one by one, until Class.forName() doesn’t throw ClassNotFoundException anymore or there are no more . to replace.

Is there any better/well known/standard solution? I looked in the API docs for Class, CLassLoader and java.lang.reflect but did not find anything usable.

Answer 1

It now sounds like you want to get the fully qualified name (FQN) from the canonical name. As that is different from working from a simple name I’ll add a second answer.

The Sun javac command will not compile a classes if a canonical name conflict would result. However by compiling separately you can still get two different classes with the same canonical name.

An example:

File src1\com\stack\Test.java

package com.stack;

public class Test {
    public static class Example {
        public static class Cow {
            public static class Hoof {
            }
        }
    }

    public static void main(String[] args) throws Exception {
        Class<?> cl1 = Class.forName("com.stack.Test$Example$Cow$Hoof");
        Class<?> cl2 = Class.forName("com.stack.Test.Example.Cow.Hoof");
        System.out.println(cl1.getName());
        System.out.println(cl1.getSimpleName());
        System.out.println(cl1.getCanonicalName());
        System.out.println();
        System.out.println(cl2.getName());
        System.out.println(cl2.getSimpleName());
        System.out.println(cl2.getCanonicalName());
    }
}

File src2\com\stack\Test\Example\Cow\Hoof.java

package com.stack.Test.Example.Cow;

public class Hoof { }

Then to compile and execute:

set CLASSPATH=
mkdir bin1 bin2
javac -d bin1 -sourcepath src1 src1\com\stack\Test.java
javac -d bin2 -sourcepath src2 src2\com\stack\Test\Example\Cow\Hoof.java

set CLASSPATH=bin1;bin2
java com.stack.Test

Producing the output:

com.stack.Test$Example$Cow$Hoof
Hoof
com.stack.Test.Example.Cow.Hoof

com.stack.Test.Example.Cow.Hoof
Hoof
com.stack.Test.Example.Cow.Hoof

Thus two classes have the same canonical name but different FQNs. Even if two classes have the same FQN and same canonical name, they can still be different if they are loaded via different class loaders.

To resolve your issue I see several ways forward you could take.

First you can specify that you match the class with the least amount of nesting and hence the least number of ‘$’s in the FQN. UPDATE It turns out Sun javac does the exact opposite of this and matches the class with the most nesting.

Second you can test all possible FQNs and throw an exception if there is more than one.

Third, accept that the only unique mapping is with the FQN then only within a specified class loader and re-work you application appropriately. I find it convenient to use the thread context class loader as a default class loader.