I think its pretty straight forward with reflection

MyClass mobj = MyClass.class.cast(obj);

and if class name is different

Object newObj = Class.forName(classname).cast(obj);

Whats wrong with creating a constructor in the respected class? or using a parsing decorator/object?

I.E.

public final class MyCustomRecordFromDB implements CustomRecordInterface {
    private final DatabaseRecord innerDBRecord;
    public MyCustomRecordFromDB(DatabaseRecord dbRecord) {
        this.innerDBRecord = dbRecord;
    }

    public Something A()
    {
        return ... ;
    }

    public Something B()
    {
        return ... ;
    }
}

Where CustomRecordInterface is the interface that MyCustomRecord implements (i.e. MyCustomRecordFromDB should be able to be a substitute to MyCustomRecord) as you should always code to interfaces in OOP (in case you want to follow OOP).

it is really similar to adapter object pattern.

Note: I've assumed that your setA(...) and setB(...) are public methods that have getter such as A() and B() respectfully, you can omit that if this isn't the case.

If PerformanceInvokeService has an accessible default constructor, you can create a new instance using:

Object instance = c.newInstance();

You can then pass that to the method invocation:

Object ret = m.invoke(instance, new Object[] { "some string", new Date() });

If there is no accessible default constructor, then you'll have to find a constructor that you can use by using reflection.

Whats the output of System.out.println(pObject.getClass().getName());

If its the same Customer class, then you could cast the object like this

Customer cust = (Customer) pObject;

This seems like a perfectly good example of using Adapter Pattern

Basically, you would create one interface that would have one method:

public interface Adapter
{
   ClassC ConvertObject();
}

And then you would create two classes, implementing this interface, like this:

class AdapterClass : Adapter
{
   private ClassA adaptee;
   public AdapterClassA(ClassA pAdaptee)
   {
        adaptee = pAdaptee;
   }

   public ClassC ConvertObject()
   {
      //Code that converts ClassA to ClassC
   }
}

class AdapterClassB : Adapter
{
   private ClassB adaptee;
   public AdapterClassB(ClassB pAdaptee)
   {
        adaptee = pAdaptee;
   }

   public ClassC ConvertObject()
   {
      //Code that converts ClassB to ClassC
   }
}

This way, you are decoupling the logic of type conversion into different classes, leaving the same interface to the user class.

Now, one might raise an issue with unnecessarily creating an interface when nobody but ClassC will invoke the constructor of adapter classes. The interface is not there just because of who will invoke the constructor. For instance, it will be easier to write unit tests if you have something like this.

Next, you might want to decouple the classes completely, and move the invokation of the constructor to some factory class, where ClassC would just see the Adapter interface and then it would not depend on ClassA or ClassB in any way. Of course, this is flirting with the violation of KISS principle, but I would call it a judgment call.

Bottom line is: If you want to decouple ClassC from ClassA and ClassB, there must be something that binds adapter classes. It can be an abstract parent class, or a regular parent class or an interface. Considering that the parent entity carries no information, it is logical to use interface.

I am storing a class object into a string using toString() method. Now, I want to convert the string into that class object.

Your question is ambiguous. It could mean at least two different things, one of which is ... well ... a serious misconception on your part.

If you did this:

SomeClass object = ...
String s = object.toString();

then the answer is that there is no simple way to turn s back into an instance of SomeClass. You couldn't do it even if the toString() method gave you one of those funky "SomeClass@xxxxxxxx" strings. (That string does not encode the state of the object, or even a reference to the object. The xxxxxxxx part is the object's identity hashcode. It is not unique, and cannot be magically turned back into a reference to the object.)

The only way you could turn the output of toString back into an object would be to:

• code the SomeClass.toString() method so that included all relevant state for the object in the String it produced, and
• code a constructor or factory method that explicitly parsed a String in the format produced by the toString() method.

This is probably a bad approach. Certainly, it is a lot of work to do this for non-trivial classes.

If you did something like this:

SomeClass object = ...
Class c = object.getClass();
String cn = c.toString();

then you could get the same Class object back (i.e. the one that is in c) as follows:

Class c2 = Class.forName(cn);

This gives you the Class but there is no magic way to reconstruct the original instance using it. (Obviously, the name of the class does not contain the state of the object.)

If you are looking for a way to serialize / deserialize an arbitrary object without going to the effort of coding the unparse / parse methods yourself, then you shouldn't be using toString() method at all. Here are some alternatives that you can use:

• The Java Object Serialization APIs as described in the links in @Nishant's answer.
• JSON serialization as described in @fatnjazzy's answer.
• An XML serialization library like XStream.
• An ORM mapping.

Each of these approaches has advantages and disadvantages ... which I won't go into here.

First, you have to understand that casts and deciding which overloaded method to chose ... happens at compile time. In contrast to polymorphism, overloading is decided at compile time.

Therefore, given a fixed, known sets of "target" classes, the following cascading of instanceof, as ugly as it looks, would work out:

if (someObject instanceof A) {
  foo((A) someObject);
  return;
} 
if (someObject instanceof B) {
  foo((B) someObject);
  return;
} 

Please note: there is no "working around" here using reflection. Reflection kicks in at runtime, and as said, you need all the information at compile time.

If at all, you would have to step back, and see if there are ways of turning your overloading approach into polymorphism.

What you really want to do here is use composition and not inheritance. Keep all your objects as type Student, and then temporarily assign the behaviour of a TutorRole as it is required to each instance of Student.

With this design your Student class will contain a property (member variable) of type TutorRole that you can add or remove at runtime. Adding an isTutor() method will allow you to detemine whether a Student is a Tutor at runtime in a clear and concise manner.

The TutorRole class will encapsulate the behaviour (i.e. methods) of being a Tutor.

/*
 * The TutorRole can be set at runtime
 */
public class Student {

    private String facultyId;

    private TutorRole tutorRole = null;

    public boolean isTutor() {
        return !(tutorRole == null);
    }

    public void doTutorStuff() {
        if(isTutor()) {
            tutorRole.doTutorStuff();
        }
        else {
            throw new NotTutorException();
        }
    }

    public void setTutorRole(TutorRole tutorRole) {
        this.tutorRole = tutorRole;
    }
}

/*
 * Ideally this class should implement a generic interface, but I'll keep this simple
 */
public class TutorRole {

    public void doTutorStuff() {
        // implementation here
    }
}

/*
 * Now let's use our classes...
 */
Student st = new Student(); // not a tutor
st.setTutorRole(new TutorRole()); // now a tutor
if(st.isTutor()) {
    st.doTutorStuff();
}
st.setTutorRole(null); // not a tutor anymore

An alternative approach is to have a Tutor class contain a reference to a Student object, but it depends on how you are going to be interacting with the Student and Tutor objects on which way around you want to code this.