Metodo di template all'interno di una classe senza sottoclassi o ereditarietà

Question

Metodo di template all'interno di una classe senza sottoclassi o ereditarietà

#1 da (2 voti)
#2 da (1 voti)

3

Ho un algoritmo con parti per lo più invarianti che devono essere riutilizzati all'interno di una classe in modo da rimanere DRY .

Duplicazione del codice con struttura del metodo ripetuta

public void save(String key, int value) {
    try {
        if (isValidWrite()) {
            // Only variable part
            editor.putInt(key, value);
            if (!writeOnDisable){
                write(editor);                    
                Log.v(TAG, "Saved " + key + " | "+ value);
            }
        }
    } catch (Exception e) {
        Log.e(TAG, "save", e);
    }
}

public void save(String key, String value) {
    try {
        if (isValidWrite()) {
            // Only variable part
            editor.putString(key, value);
            if (!writeOnDisable){
                write(editor);
                Log.v(TAG, "Saved " + key + " | "+ value);
            }
        }
    } catch (Exception e) {
        Log.e(TAG, "save", e);
    }
}

Soluzione?

Il modello di metodo del modello non è applicabile, poiché richiede la sottoclassificazione.
Strategia: ho davvero bisogno di creare un'interfaccia e fornire diverse implementazioni per passare a un metodo generalizzato come delegato? Forse mi sto solo lamentando del supporto adeguato per i delegati in Java .. (in C # potrebbe usare solo un'azione generica < >)

java design-patterns inheritance delegates

posta Cel 21.02.2013 - 14:56

fonte

2 risposte

1

Questa è una soluzione alternativa, esponi due metodi, uno per ints e uno per Strings .

Un metodo privato riceve entrambi i tipi di valori e decide cosa salvare.

public void save(String key, int value) {
    save(key, new Integer(value), null); // pass null in String param
}


public void save(String key, String value ) {
    save(key, null, value); // pass null in Integer param
}

private void save(String key, Integer intVal, String strVal){
    String strToLog="";
    try {
        if (isValidWrite()) {
            if ( intVal != null) {
                editor.putInt(key, intVal);
                strToLog = intVal.toString();
            } else if ( strVal != null) {
                editor.putInt(key, strVal);
                strToLog = strVal;
            }               

            if (!writeOnDisable){
                write(editor);                    
                Log.v(TAG, "Saved " + key + " | "+ strToLog);
            }
        }
    } catch (Exception e) {
        Log.e(TAG, "save", e);
    }       
}

risposta data 21.02.2013 - 16:40

fonte

Leggi altre domande sui tag java design-patterns inheritance delegates

Che cosa può essere utilizzato al posto dei casi d'uso per raccogliere i requisiti? Peer programmazione e condivisione delle esperienze

score 2 · Accepted Answer

protected void applyParameters(Editor editor, Object [] parameters) {
    for(Object param : parameters) {
        if(param instanceof Integer) {  
            editor.putInt(key, param);
        } else if (param instanceof String) {
            editor.putString(key, param);
        } else {
            // case for unknown type?
        }
    }
}
public void save(String key, Object ... params) {
    try {
        if (isValidWrite()) {
            if(params != null) 
                applyParameters(editor, params);

            if (!writeOnDisable){
                write(editor);                    
                Log.v(TAG, "Saved " + key + " | "+ value);
            }
        }
    } catch (Exception e) {
        Log.e(TAG, "save", e);
    }
}

Prova questo. In sostanza, non è possibile generalizzare "putInt" e "putString", ma è possibile estrapolarli almeno nel loro metodo. Fornisci semplicemente un caso per i parametri che non riconosci come validi.