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

Question

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

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

目前，我要为其生成 ContentValues 的每个对象都有一个方法。 例如：

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

}

在这里，您只需在对象上调用 values()，它就会检索正确的 ContentValues。