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

时间:2010-05-10 20:03:14

标签: java oop interface

在Java中,我希望能够定义标记接口,强制实现提供静态方法。例如,对于简单的文本序列化/反序列化,我希望能够定义一个看起来像这样的接口:

public interface TextTransformable<T>{

  public static T fromText(String text);

  public String toText();

由于Java中的接口不能包含静态方法(如许多其他帖子/帖子中所述:hereherehere此代码不起作用

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

注意:在我们的例子中,我们的主要用例是我们有许多“价值对象”类型 - 枚举或其他具有有限数量值的对象,通常没有超出其值的状态,我们解析/解析数秒钟的时间,所以实际上关心重用实例(如Float,Integer等)及其对内存消耗的影响/ gc

有什么想法吗?

EDIT1:为了消除一些困惑 - 我们有许多不同的对象适合这种模式 - 实际上我们正试图为具有2种语义的调用者提供优雅的东西:

  • 作为合同的接口 - 访问的统一性(例如TextTransformable作为能力)
  • 要求通过子类/实现实现(例如强制他们实现自己的转换

就我们对Flyweight,Factories的看法而言 - 它们都是我们考虑过的选项,我们真的想看看我们是否能找到更优雅的东西,而不是依赖于JavaDoc说“实现工厂和委托调用”它,或按惯例“

”在XXX位置公开

7 个答案:

答案 0 :(得分:7)

这非常适合Flyweight。这基本上就是你想用静力学来完成的。在如何为Flyweight对象提供服务以便您不创建数千个对象方面,这里有一些想法。

一个是工厂,你说你想到并拒绝,虽然你没有说明原因(所以任何其他想法可能会遇到同样的问题)所以我不会进入它。

另一种方法是让值类型具有可以为其转换器提供服务的方法。像这样:

 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) {
         ...
   }

找到合适的变换器的代码不一定是最漂亮的,但从调用者的角度来看,一切都很好。

编辑2:进一步思考,我看到你想要控制对象构造。你真的不能这样做。换句话说,在Java中,您无法强制实现者使用或不使用工厂来创建其对象。他们总是可以公开一个公共构造函数。我认为你的问题是你对执行建设的机制不满意。如果这种理解是正确的,那么可能会使用以下模式。

您创建一个只包含私有构造函数的对象,它包装您的值类型。该对象可以具有泛型类型参数,以了解它包装的值类型。此对象使用静态工厂方法进行实例化,该方法使用工厂接口创建“实际”值对象。使用该对象的所有框架代码仅将此对象作为参数。它不直接接受值类型,如果没有值类型的工厂,则无法实例化该对象。

这种方法的问题在于它是非常有限的。只有一种方法可以创建对象(工厂界面支持的对象),并且使用值对象的能力有限,因为处理这些文本元素的代码只能通过此对象进行有限的交互。

我猜他们说没有软件问题无法通过额外的间接层来解决,但这可能是一个太过分的桥梁。至少是值得深思的。

答案 1 :(得分:4)

只是一个要考虑的想法:您可以将转换逻辑与对象本身分开,然后您有一组固定的转换器,实现以下接口:

public interface Transformer<T>{ 

  public T fromText(String text); 

  public String toText(T obj); 
}

您的实际数据类可以有一个方法getTransformer(),它为它们返回正确的转换器。

答案 2 :(得分:2)

一种完全不同的方法(以及一个丑陋的黑客,就此而言)是让接口有一个返回方法的方法。

public interface MyInterface{
    Method getConvertMethod();
}

现在您的客户端代码可以执行

yourInterface.getConvertMethod().invoke(objectToBeConverted);

这非常强大,但API设计非常糟糕

肖恩

答案 3 :(得分:1)

如果您使用的是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或更早版本),或者由于其他原因,它们不适合您,我建议使用Flyweight pattern实施

答案 4 :(得分:1)

只是一个不同的想法。不适用于所有情况,但也许可以帮助其他人。

您可以使用abstract class作为interfaceconcrete classes之间的桥梁。抽象类允许静态方法以及契约方法定义。例如,您可以查看Collection API,其中Sun实现了几个抽象类,而不是从零所有具体类中进行强力编码。

在某些情况下,您可以通过抽象类替换接口。

答案 5 :(得分:0)

正如@westkins所说,你应该使用枚举。

枚举基类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();
    }
}

答案 6 :(得分:0)

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

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这样的容器来强制执行。谷歌启动了一个项目,从他们的代码库中删除所有手动强制执行的单例,但如果你想做一个老式的单例,你可以使用实用程序类:

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

这只是我头脑中的一种方法。