Tipo generico da Enum e il modello di generatore

Question

Sto provando a creare un modello di generatore che utilizza i generici per fornire il controllo dei tipi su alcuni metodi. Attualmente ho il seguente lavoro:

ParameterBuilder.start(String.class).setName("foo").setDefaultValue("Hello").build(); 
ParameterBuilder.start(Integer.class).setName(bar).setDefaultValue(42).build(); 
ParameterBuilder.start(Boolean.class).setName(bar).setDefaultValue(false).build(); 

Utilizzando il codice:

public class ParameterBuilder<T> { 
    private String name; 
    private T defaultValue; 

    public static <T2> ParameterBuilder<T2> start(Class<T2> type) { 
    return new ParameterBuilder<T2>(); 
    } 
    // Other methods excluded for example 
} 

Così il tipo di input per il metodo setDefaultValue è definito da ciò che è passato nel metodo start, proprio come voglio.

Ma ora voglio estendere ciò che viene passato in start() per contenere un po 'più di informazioni. In sostanza, voglio passare un "tipo" per i parametri che sto creando. A volte questi parametri saranno cose come "e-mail", "url", ecc Il valore predefinito sarà ancora di tipo noto (String in questi casi), quindi mi piacerebbe avere qualcosa di simile:

ParameterBuilder.start(EMAIL).setName("email").setDefaultValue("foo@bar.com").build(); 
ParameterBuilder.start(URL).setName("website").setDefaultValue("http://www.somewhere.com").build(); 

Dove al momento EMAIL & URL sono enumerazioni, contenenti tra le altre cose - la classe del valore predefinito. Ma se percorro questa strada, come posso istanziare il generatore di parametri?

public static <T2> ParameterBuilder<T2> start(ParameterType paramType) { 
    Class<T2> type = paramType.getTypeClass(); 
    // How do I instantiate my ParameterBuilder with the right type? 
} 

Se non può essere fatto utilizzando le enumerazioni (che posso vedere è il caso), Qualcuno ha un suggerimento per una soluzione diversa?

Answer 1

Penso che sia necessario un enum per tipo di classe (non vedo come si possa avere un enum che copre diversi tipi e fa funzionare la cosa). In tal caso, un'interfaccia generica comune potrebbe fare ciò che vuoi. È quindi possibile creare una sorta di fabbrica per fornire le costanti enum se ciò aiuta.

Questo compila:

static interface ParameterType<T> {} 

static enum ParameterTypeEnum implements ParameterType<String> { EMAIL; } 

public static void main(String[] args) { 
    ParameterBuilder 
      .start(ParameterTypeEnum.EMAIL) 
      .setName("email") 
      .setDefaultValue("foo@bar.com") 
      .build(); 
} 

public static class ParameterBuilder<T> { 

    private String name; 
    private T defaultValue; 

    public static <T2> ParameterBuilder<T2> start(ParameterType<T2> paramType) { 
     return new ParameterBuilder<T2>(); 
    } 

    ParameterBuilder<T> setName(String name) { 
     this.name = name; 
     return this; 
    } 

    ParameterBuilder<T> setDefaultValue(T defaultValue) { 
     this.defaultValue = defaultValue; 
     return this; 
    } 

    void build() {} 
} 

Answer 2

Non sono sicuro del contesto in quello che si desidera utilizzare, ma penso che la seguente potrebbe essere un'opzione.

È possibile seguire il principio Aperto/Chiuso e creare un'interfaccia Parameter e disporre di un'implementazione per tipo. Il vantaggio di questo è che non è necessario aggiungere un nuovo valore enum per ogni nuovo parametro desiderato. In seguito, è possibile passare la classe a ParameterBuilder anziché l'enum e lo ParameterBuilder e Parameter funzionerebbero insieme per creare ciò di cui si ha bisogno.

Quindi ParameterBuilder.start() potrebbe restituire un'istanza dello specifico Parameter e il parametro potrebbe avere metodi diversi a seconda del tipo di parametro.

Non credo che questa risposta sia davvero buona, ma si spera possa darvi un suggerimento su come costruire una potenziale soluzione per il vostro contesto.

Answer 3

Si potrebbe creare un hierachie oggetto di queste e-mail e l'URL tipi

public class DefaultType { 
    protected String name; 
    protected String defaultValue; 
    //some constructor 
} 

public class EmailType extends DefaultType { 
    ... 
} 

public class URLType extends DefaultType { 
    ... 
} 

poi il costruttore parametro potrebbe essere simile a questa:

public static ParameterBuilder start(DefaultType type) { 
    ParameterBuilder builder = new ParameterBuilder(type); 
    builder.setType(type); 
    return builder; 
} 

allora si potrebbe chiamare in questo modo:

ParameterBuilder.start(new EmailType("name","value");... 

questo aiuto o non vuoi andare in questa direzione?