Java 接口上用于强制一致性的静态方法的替代方法

在Java中，我希望能够定义标记接口，强制实现提供静态方法。例如，对于简单的文本序列化/反序列化，我希望能够定义如下所示的接口：

public interface TextTransformable<T>{

  public static T fromText(String text);

  public String toText();

 public class ValueType {
       public static final TextTransformable<ValueType> CONVERT = ....
 }

 ValueType value = ValueType.CONVERT.fromText(text);

 String text = ValueType.CONVERT.toText(value);

公共接口可转换文本{
公共静态T fromText（字符串文本）；
公共字符串toText（）；

由于Java中的接口不能包含静态方法（如许多其他帖子/线程中所述），因此此代码不起作用

然而，我所寻找的是一些合理的范例来表达相同的意图，即对称方法，其中一种是静态的，并且由编译器强制执行。现在我们能想到的最好的方法是某种静态工厂对象或泛型工厂，这两种方法都不是真正令人满意的

注意：在我们的例子中，我们的主要用例是我们有很多很多“值对象”类型-枚举，或者其他具有有限数量值的对象，通常没有超出其值的状态，并且我们每秒解析/反解析数千次，所以实际上我们关心重用实例（如Float、Integer等）以及它对内存消耗/g.c.的影响

有什么想法吗

EDIT1:为了澄清一些混淆-我们有许多不同的对象适合这种模式-实际上，我们正试图为调用方提供一些优雅的东西，具有两种语义：

• 作为合同的接口-访问的统一性（例如，可转换为功能的文本）
• 要求通过子类/实现实现（例如，强制他们实现自己的转换

---

就我们对Flyweight、Factory的想法而言，它们都是我们考虑过的选项，实际上，我们正在尝试寻找比依赖JavaDoc说“实现一个工厂并委托调用它，或者按照惯例在XXX位置公开它”更优雅的东西

如果您在Java 5或更高版本中运行，您可以使用枚举类型-根据定义，所有这些类型都是单例。因此，您可以使用如下内容：

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

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

}

这样，内存问题就消失了，您可以实现单个行为实例

---

---

编辑：如果您无权访问枚举（1.4或更早版本）或者，出于某些其他原因，它们不适合您，我建议您使用一种实现。

只是一个需要考虑的想法：您可以将转换逻辑与对象本身分离，然后使用一组固定的转换器，实现以下接口：

public interface Transformer<T>{ 

  public T fromText(String text); 

  public String toText(T obj); 
}

公共接口转换器{
公共T fromText（字符串文本）；
公共字符串toText（T obj）；
}

---

您的实际数据类可以有一个方法getTransformer（），该方法为它们返回正确的转换器。

正如@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();
    }
}

/**枚举可以实现这一点，以提供解析字符串的方法
*使用正确的枚举名。
*/
公共接口帮助
{
//将s解析为可由enum.valueOf处理的正确枚举名
字符串解析（字符串s）；
}
/**EnumParser提供将符号名解析为枚举实例的方法。
*如果所讨论的枚举实现了EnumHelp，则解析方法为
*调用以在调用valueOf之前将令牌解析为正确的枚举名称。
*/
公共类枚举分析器
{
公共静态T fromText（类别cl，字符串s）{
if（EnumHelp.class.isAssignableFrom（cl））{
试一试{
方法resolve=cl.getMethod（“resolve”，String.class）；
s=（字符串）resolve.invoke（null，s）；
}
catch（NoSuchMethodException ex）{}
catch（SecurityException ex）{}
捕获（非法访问例外）{}
捕获（IllegalArgumentException ex）{}
catch（InvocationTargetException ex）{}
}
返回T.valueOf（cl，s）；
}
公共字符串toText（T值）
{
返回值.name（）；
}
}

似乎需要将工厂与创建的对象分开

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

在客户端代码中：

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

---

这只是我脑子里想不到的一种方法。

这确实适用于。这基本上就是你试图用静力学来完成的。关于如何为Flyweight对象服务，这样你就不会创建成千上万的对象，这里有一些想法

一个是工厂，你说你考虑过并拒绝了它，尽管你没有说明原因（所以其他任何想法都可能会遇到同样的问题），所以我不会进入它

另一种方法是让值类型有一个可以为其转换器服务的方法。如下所示：

public interface TextTransformable<T>{

  public static T fromText(String text);

  public String toText();

 public class ValueType {
       public static final TextTransformable<ValueType> CONVERT = ....
 }

 ValueType value = ValueType.CONVERT.fromText(text);

 String text = ValueType.CONVERT.toText(value);

这并不意味着所有ValueType都通过相同的机制提供转换器，因此我认为您需要某种工厂

编辑：我想我不知道你觉得工厂有什么不雅的地方，但我认为你关注的是来访者，那么你对此有何感受：

  ValueType value = getTransformer(ValueType.class).fromText(text);

可以通过工厂的静态导入和具有如下签名的方法完成上述操作：

   public static <T> TextTransformable<T> getTransformer(Class<T> type) {
         ...
   }

公共静态文本可转换getTransformer（类类型）{
...
}

找到正确的转换器的代码并不一定是最漂亮的，但从调用方的角度来看，所有内容都很好地呈现出来

编辑2：进一步想一想，我看到的是你想要控制对象的构造。你不能真正做到这一点。换句话说，在Java中，你不能强迫实现者使用或不使用工厂来创建他们的对象。他们总是可以公开一个公共构造函数。我想你的问题是你不喜欢使用它

yourInterface.getConvertMethod().invoke(objectToBeConverted);