¿Cómo inicializar un objeto con una lista de diferentes tipos?

Question

Oye, estoy inicializando un ListRepository con dos tipos diferentes de listas de inicialización. La mejor manera sería algo como esto.

public ListRepository(String id, List<PrimaryKey> initilizationList) 
{ 
    // Load objects from data source via primary key. 
} 

public ListRepository(String id, List<DomainObject> initilizationList) 
{ 
    // Store objects directly 
} 

Desafortunadamente, esto no es posible debido al borrado del tipo de tiempo de ejecución. No me gusta un enfoque de constructor con List<?> como argumento, esto lleva a una fea comprobación instanceof de la primera entrada, para determinar el tipo de lista y manejarla.

¿Cómo resuelves ese problema con una API intuitiva y limpia?

Answer 1

El constructor está haciendo mucho más que inicializar el objeto. Lo mejor es mantener a los constructores simples.

Utilizaría un método estático para realizar cada consulta.

public static ListRepository<PrimaryKey> loadFromPrimaryKey(String id, List<PrimaryKey> initilizationList) { 
    // Load objects from data source via primary key. 
} 

public static ListRepository<PrimaryKey> loadFromDomainObject(String id, List<DomainObject> initilizationList) { 
    // Store objects directly 
} 

Usted tendría un constructor que solo toma los datos resultantes. Esto aclararía mucho más sobre lo que construirán los métodos.

Answer 2

uso de la fábrica método

class ListRepository {  
    public static ListRepository createPrimaryKeysRepository(String id, List<PrimaryKey> initilizationList){} 
    public static ListRepository createDomainObjectsRepository(String id, List<DomainObject> initilizationList){} 
} 

Answer 3

uno puede cerrar las listas en un objeto que contiene la lista:

public ListRepository(String id, PrimaryKeyList initilizationList) 
{ 
    // Load objects from data source via primary key. 
} 

public ListRepository(String id, DomainObjectList initilizationList) 
{ 
    // Store objects directly 
} 

o puede utilizar un solo método, y pasar un argumento adicional, siendo un valor lógico o una enumeración:

public ListRepository(String id, List<?> initilizationList initilizationList, boolean isPrimaryKey) 
{ 
    // Load objects from data source 
} 

Answer 4

Utilice los métodos de fábrica; p.ej.

private ListRepository(String id) { 
    this.id = id; 
} 

public static ListRepository createFromPrimaryKeys(String id, List<PrimaryKey> init) { 
    ListRepository res = new ListRepository(id); 
    // Load objects from data source via primary key. 
    return res; 
} 

public static ListRepository createFromObjects(String id, List<DomainObject> init) { 
    ListRepository res = new ListRepository(id); 
    // Store objects directly 
    return res; 
} 

Answer 5

¿Qué tal

  
public ListRepository(String id, PrimaryKey...keys) { 
    // Load objects from data source via primary key. 
} 

public ListRepository(String id, DomainObject...stuff) 
{ 
    // Store objects directly 
} 

O bien, utilizar ListRepositoryInitializers especializados

Answer 6

public ListRepository(String id, List<PrimaryKey> listByKey , List<DomainObject> listByObject) 
{ 
    if(listByKey == null) 
    // Load objects from data source via primary key. 
    else 
    // Store Objects Directly 
} 

En lugar de escribir el método o constructor sobrecarga, se puede lograr el mismo según el método que acepta ambos parámetros y tomar cualquiera de ellos.

Espero que esto resuelva su problema.

Answer 7

Esto podría ser un poco feo, pero ¿qué pasa con:

public ListRepository(String id, PrimaryKey[] initilizationList) { 
    [...] 
} 

public ListRepository(String id, DomainObject[] initilizationList) { 
    [...] 
} 

Udo.