设计模式 - 不同的对象，返回相同的对象

Question

我正在开发一个Android Java项目，我有预感，我将能够使用一个更好的模式，以适应两个地方的情况。

我有一个类从输入的模型/对象构建ContentValues（基本上是键/值对象），并返回一个ContentValue对象，它具有不同的键/值，具体取决于我输入的对象。

目前，我想为每个对象生成ContentValues的方法。 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; 

}

我的直觉告诉我，有可能是这样做的更好的方法。

第二种情况几乎相反。我输入相同的对象，构建不同的对象并返回它们。 如：

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; 
    } 

所以我的问题是：是否有任何设计模式，我可以使用，使相同的功能更加一般化的方式，所以我可以使用，而不是创建为每个新对象的新方法同样的方法我想用吗？

Answer 1

您可以使用界面和泛型，例如像这样：

编辑：在底部的旧东西！

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")+""); 

......现在，您可以概括您的S和T更多，更多接口......无尽的故事。

----旧的东西----

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(); 
    } 

} 

现在，你只需要调用一个方法，建立和你的对象。

您还做这样的与你的第一个问题......

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(); 
    } 

} 

在这里你只需要调用你的对象值（），并获取正确的ContentValues。