java - Design pattern - different object in, same object returned -

i'm working on android java project , have hunch able use better pattern situation accures in 2 places.

i have class wich builds contentvalues (basically key/value object) inputed model/object , returns contentvalue object have different key/values depending on object i'm inputing.

currently, there method each object want generate contentvalues for. e.g:

public contentvalues buildpage (page p){ contentvalues val = new contentvalues();  val.put(page_description, p.getdesciption());  val.put(page_displayable, bitmaphelper.converttoblob(p.getpic()));  val.put(page_module_id, p.getmoduleid());  val.put(page_title, p.gettitle());  return val;  

}

public contentvalues buildquestion(question q){ contentvalues val = new contentvalues();  val.put(question_correct, q.getcorrect()); val.put(question_question, q.getquestion());  val.put(question_quiz_id, q.getquizid());   return val;  

}

my intuition tells me there better way of doing it.

the second situation opposite. input same object, builds different objects , returns them. e.g:

   public quiz buildquizobj(cursor c){             //{quiz_id, quiz_module_id};              quiz q = new quiz();               if(cursorisok(c)){                 c.movetofirst();                  q.setid(c.getlong(0));                  q.setmoduleid(c.getlong(1));             }              return q;          }       public module buildmoduleobj(cursor c){         list<module> modules = buildmodulesobj(c);           module m = new module();          if(modules.size() > 0){             m = modules.get(0);         }          return m;      } 

so question is: there design pattern can use make same functionality in more generalized way can use same method instead of creating new methods each new object want use?

you can use interfaces , generics, e.g. :

edit: old stuff @ bottom!

public interface buildable {      public contentvalues values();  }  public interface builder<s, t extends buildable> {      public t build(s source);  }  public class module implements buildable {      @override     public contentvalues values() {         contentvalues c = new contentvalues();         c.put("name", getclass().getname());         return c;     }  }  public class modulefromcursorbuilder implements builder<cursor, module> {      @override     public module build(cursor source) {         return new module();     }  }  public class quizfromcursorbuilder implements builder<cursor, quiz> {      @override     public quiz build(cursor source) {         return new quiz();     }  }  cursor cursor = null; log.i("modulefromcursorbuilder",new modulefromcursorbuilder().build(cursor).values().get("name")+""); log.i("quizfromcursorbuilder",new quizfromcursorbuilder().build(cursor).values().get("name")+""); 

...now generalize s , t more, more interfaces... endless story.

---- old stuff ----

public interface buildable<t> {     public t build(cursor c); }  public class modulebuilder implements buildable<module>{      @override     public module build(cursor c) {         return new module();     }  }  public class quizbuilder implements buildable<quiz>{      @override     public quiz build(cursor c) {          return new quiz();     }  } 

now call 1 method, build, , object.

you first problem...

public interface valuable {      public contentvalues values();  }  public class question implements valuable {      @override     public contentvalues values() {         return new contentvalues();     }  }  public class page implements valuable {      @override     public contentvalues values() {         return new contentvalues();     }  } 

here call values() on object , retrieves correct contentvalues.