Альтернативы статическим методам для интерфейсов для осуществления непротиворечивости

Похоже, вам нужно отделить фабрику от созданного объекта.

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

Вы можете регистрировать классы TextTransformer по своему усмотрению:

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

Если вы хотите, чтобы FooTextTransformer был одноэлементным, вы можете использовать такой контейнер, как Spring, для обеспечения этого. Google инициировал проект по удалению всех вручную принудительных синглтонов из своей кодовой базы, но если вы хотите сделать старомодный синглтон, вы можете использовать служебный класс:

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

В вашем клиентском коде:

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

Это всего лишь один подход с верхней части моей головы.

Если вы работаете в Java 5 или выше, вы можете использовать тип enum - все они, по определению, являются синглтонами. Таким образом, вы можете сделать что-то вроде:

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

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

}

Таким образом, проблема памяти исчезает, и вы можете иметь единичные экземпляры реализованного поведения.

Edit: Если у вас нет доступа к enum (1.4 или более ранняя версия) или, по какой-то другой причине, они вам не подходят, я бы рекомендовал Flyweight pattern реализацию.

Как сказал @aperkins, вы должны использовать перечисления.

Базовый класс перечисления Enum предоставляет метод valueOf, который преобразует строку в экземпляр.

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);

Обновление: Для перечислений это может сделать то, что вам нужно. Он использует отражение, поэтому вам нужно реализовать EnumHelper только в перечислениях, где вам нужно иметь дело с устаревшими значениями.

/** 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();
    }
}

Просто идея для рассмотрения: вы можете отделить логику преобразования от самих объектов, и тогда у вас будет фиксированный набор преобразователей, реализующий следующий интерфейс:

public interface Transformer<T>{ 

  public T fromText(String text); 

  public String toText(T obj); 
}

Фактические классы данных могут иметь метод getTransformer (), который возвращает им нужный трансформатор.

Совершенно другой подход (и уродливый взлом, если на то пошло) - позволить интерфейс имеет метод, который возвращает метод.

public interface MyInterface{
    Method getConvertMethod();
}

теперь ваш клиентский код умеет

yourInterface.getConvertMethod().invoke(objectToBeConverted);

Это чрезвычайно мощный, но очень плохой дизайн API.

Шон