Is it good habit to use "Instanceof"

Question

Is good habit to use "Instanceof" for selection purpose. Below code will make it more clear.
public boolean entryAdd(Object obj) throws SQLException
     String sSQL="";
     if (obj instanceof cT )
         cTeacher oT = (cT)obj;
         sSQL = "INSERT INTO tblT VALUES(";
         sSQL = sSQL + String.valueOf(getNextID("TID","tblT"));
         sSQL = sSQL + ",'";
         sSQL = sSQL + oT.Name + "','";
         sSQL = sSQL + oT.Qualification + "','";
         sSQL = sSQL + oT.Description + "')";
     }else if(obj instanceof cS)
         cS oS = (cS)obj;
         sSQL = "INSERT INTO tblS VALUES(";
         sSQL = sSQL + String.valueOf(getNextID("SID","tblS"));
         sSQL = sSQL + ",'";
         sSQL = sSQL + oS.Name + "','";
         sSQL = sSQL + oS.Code + "','";
         sSQL = sSQL + oS.Description + "')";
     }elseif(.){...
     else
         return false;
     Statement oStmt = getStatement(EnumDBType.UPDATEABLE);
     oStmt.execute(sSQL);
     oStmt.close();
     return true;
    }Well, in C++ we have enum. Which can be given as arg. when function is called. So,it is easy for caller and for us to get only values we want in arg. But, in java, we don't have this kind of feature(excluding J1.5).
So, should I be using above method for identifying object and taking action. Or should I declare Interface with all the costants for all the classes which i expect and take int as an argument. and tell caller to send one of the constant declared in interface. And using switch statement I take action.one of the constant declared in interface.
So, I am looking for good programming method of doing above task.

Answer 1

But, don't
you think "UlrikaJ" way is more straight forward.
Please give your suggestion.Ulrika's method, simple having every SQLStorable is certainly a very good way in simple cases.
The only complaint I would have is that SQL is a different domain of knowledge than whatever it is that the storable class is supposed to be doing. Suppose it changed. Suppose you decided to use a different persistence mechanism. Would you add XMLStorable and RMIStorable and whatever else to every class in you system?
Double-dispatch addresses this problem, but at the cost of having one class with comprehensive knowledge of every other class in the system.
A more general solution would be to have each class be able to describe itself (either by implementing a Storable interface, with method that could tell a SQLStorer, an XMLStorer, or whatever, how to store it, or by using Annotation to save the same information).
Plus, although this is somewhat of topic, as a visitor from the Generics forum, I want to point out that using StringBuffers and string concatenation is distinctly old-hat. Going forward, you could writ:public String apply (CT ot) {
    return String.format("INSERT INTO tblT VALUES(%d, %s, %s, %s)",
                         getNextID("TID","tblT"),
                         ot.name,
                         ot.qualification,
                         ot.description);
}which is quite a bit cooler.