Implementando várias interfaces genéricas em java

Preciso de uma interface que me garanta a disponibilidade de um determinado método, incluindo assinatura específica. Até agora, é o que tenho:

public interface Mappable<M> {
    M mapTo(M mappableEntity);
}

O problema surge quando uma classe deve ser mapeada para várias outras entidades. O caso ideal seria este (não java):

public class Something implements Mappable<A>, Mappable<B> {
    public A mapTo(A someObject) {...}
    public B mapTo(B someOtherObject) {...}
}

Qual seria a melhor maneira de conseguir esse remanescente o mais "genérico" possível?

Obviamente, isso não é algo que você pode fazer devido ao apagamento de tipo . No tempo de execução, você tem dois métodos public Object mapTo(Object), que obviamente não podem coexistir.

Infelizmente, o que você está tentando fazer é simplesmente além do sistema de tipos do Java.

Supondo que seu tipo genérico seja sempre um tipo de primeira classe, e não ele próprio genérico, você poderá obter um comportamento externo semelhante ao ter o método mapTo(Object, Class), o que permitiria que você faça uma inspeção em tempo de execução da classe especificada e decida qual comportamento usar. Obviamente, isso é bastante deselegante - e exigirá a transmissão manual do valor de retorno - mas acho que é o melhor que você pode fazer. Se os seus tipos genéricos forem genéricos, seus parâmetros genéricos também serão apagados e suas Classes serão iguais, portanto esse método não funcionará.

No entanto, eu apontaria para a resposta de @ Joachim também, este pode ser um caso em que você pode dividir o comportamento em componentes separados e evitar toda a questão.

Como você viu, não é possível implementar a mesma interface duas vezes com parâmetros de tipo diferentes (por causa do apagamento: no tempo de execução, são as mesmas interfaces).

Além disso, essa abordagem viola o princípio da responsabilidade única: sua classe deve se concentrar em ser um Something(o que quer que isso signifique) e não deve fazer o mapeamento para Aou B além dessa tarefa.

Parece que você realmente deveria ter um Mapper<Something,A>e um Mapper<Something,B>. Dessa forma, cada classe tem uma única responsabilidade claramente definida e você não encontra o problema de implementar a mesma interface duas vezes.

Dado que não é permitido implementar múltiplas interfaces, você pode considerar o uso de encapsulamento. (exemplo usando java8 +)

// Mappable.java
public interface Mappable<M> {
    M mapTo(M mappableEntity);
}

// TwoMappables.java
public interface TwoMappables {
    default Mappable<A> mapableA() {
         return new MappableA();
    }

    default Mappable<B> mapableB() {
         return new MappableB();
    }

    class MappableA implements Mappable<A> {}
    class MappableB implements Mappable<B> {}
}

// Something.java
public class Something implements TwoMappables {
    // ... business logic ...
    mapableA().mapTo(A);
    mapableB().mapTo(B);
}

Por favor, verifique aqui para mais informações e mais exemplos: Como criar uma classe Java que implemente uma interface com dois tipos genéricos? .

public interface IMappable<S, T> {
    T MapFrom(S source);
}

// T - target
// S - source

Se você deseja mapear User para UserDTO e mapear User para UserViewModel, precisará de duas implementações separadas. Não acumule toda essa lógica em uma única classe - não faz sentido fazer isso.

Atualize para manter Joachim feliz

public interface ITypeConverter<TSource, TDestination>
{
    TDestination Convert(TSource source);
}

Mas agora estamos no domínio Automapper ( http://automapper.codeplex.com/wikipage?title=Custom%20Type%20Converters )