Alternativas a los métodos estáticos en las interfaces para hacer cumplir la coherencia

Solo una idea a considerar: Puede separar la lógica de transformación de los propios objetos, y luego tiene un conjunto fijo de transformadores, implementando la siguiente interfaz:

public interface Transformer<T>{ 

  public T fromText(String text); 

  public String toText(T obj); 
}

Sus clases de datos reales pueden tener un método getTransformer() que devuelve el transformador correcto para ellas.

Un enfoque totalmente diferente (y un truco feo, para el caso) es dejar que la interfaz tenga un método que devuelva un método.

public interface MyInterface{
    Method getConvertMethod();
}

Ahora su código de cliente puede hacer

yourInterface.getConvertMethod().invoke(objectToBeConverted);

Esto es extremadamente poderoso, pero muy mal diseño de API

Sean

Si se está ejecutando en Java 5 o superior, puede usar el tipo enum - todos ellos son, por definición, singletons. Así que podrías algo como:

public enum MyEnumType {
    Type1,
    Type2,
    //....
    TypeN;

    //you can do whatever you want down here
    //including implementing interfaces that the enum conforms to.

}

De esta manera el problema de memoria desaparece, y puede tener instancias individuales de comportamiento implementadas.

Edit: Si no tienes acceso a enums (1.4 o anteriores) o, por alguna otra razón, no funcionan para ti, recomendaría una implementación Flyweight pattern.

Solo una idea diferente. No aplicable para todos los casos, pero tal vez ayudar a alguien más.

Puedes usar un abstract class, como puente entre tu interface y tu concrete classes. Clases abstractas permite métodos estáticos, así como definiciones de métodos de contrato. Como ejemplo, puede consultar la API de colección, donde Sun implementó varias clases abstractas, en lugar de codificar por fuerza bruta desde cero todas las clases concretas.

En algunos casos, solo puede reemplazar las interfaces por clases abstractas.

Parece que necesita separar la fábrica del objeto creado.

public interface TextTransformer<T> {
    public T fromText(String text);
    public String toText(T source);
}

Puedes registrar las clases TextTransformer como quieras:

public class FooTextTransformer implements TextTransformer<Foo> {
    public Foo fromText(String text) { return ...; }
    public String toText(Foo source) { return ...; }
}

Si desea que FooTextTransformer sea un singleton, puede usar un contenedor como Spring para hacer cumplir eso. Google ha iniciado un proyecto para eliminar todos los singletons forzados manualmente de su base de código, pero si desea hacer un singleton anticuado, podría usar una clase de utilidad:

public class TextTransformers {
    public static final FooTextTransformer FOO = new FooTextTransformer();
    ...
    public static final BarTextTransformer BAR = new BarTextTransformer();
}

En su cliente código:

Foo foo = TextTransformers.FOO.fromText(...);
...
foo.setSomething(...);
...
String text = TextTransformers.FOO.toText(foo);

Este es solo un enfoque de la parte superior de mi cabeza.

Como dijo @aperkins, deberías usar enumeraciones.

La clase base enum, Enum, proporciona un método valueOf que convertirá una cadena en una instancia.

enum MyEnum { A, B, C; }
// Here's your toText
String strVal = MyEnum.A.getName();
// and here's your fromText
MyEnum value = MyEnum.valueOf(MyEnum.class, strVal);

Actualización: Para los que son enumeraciones, esto podría hacer lo que necesita. Utiliza reflexión, por lo que solo necesita implementar EnumHelper en enumeraciones donde tiene que lidiar con valores heredados.

/** Enums can implement this to provide a method for resolving a string
  * to a proper enum name.
  */
public interface EnumHelp
{
    // Resolve s to a proper enum name that can be processed by Enum.valueOf
    String resolve(String s);
}

/** EnumParser provides methods for resolving symbolic names to enum instances.
  * If the enum in question implements EnumHelp, then the resolve method is
  * called to resolve the token to a proper enum name before calling valueOf.
  */
public class EnumParser
{
    public static <T extends Enum<T>> T fromText(Class<T> cl, String s) {
        if (EnumHelp.class.isAssignableFrom(cl)) {
            try {
                Method resolve = cl.getMethod("resolve", String.class);
                s = (String) resolve.invoke(null, s);
            }
            catch (NoSuchMethodException ex) {}
            catch (SecurityException ex) {}
            catch(IllegalAccessException ex) {}
            catch(IllegalArgumentException ex) {}
            catch(InvocationTargetException ex) {}
        }
        return T.valueOf(cl, s);
    }

    public <T extends Enum<T>> String toText(T value)
    {
        return value.name();
    }
}