Question

在网上阅读时，我发现了以下内容：

public interface UnaryFunction<T>
{
    T apply(T arg);
}

.......


private static UnaryFuntion<Object> ID_FUNC = new UnaryFunction<Object>
                                          {
                                             Object apply(Object arg)
                                             {
                                                  return arg;
                                             }
                                          };

public static <T> UnaryFunction<T> idFunction()
{
    return (UnaryFunction<T>) ID_FUNC;
}

在main：

public static void main(String[] args)
{
    String[] strings = {"Peter", "Paul", "Mary"};
    UnaryFunction<String> names = idFunction();
    for(String s : strings)
    {
        System.out.println(names.apply(s));
    }

    Number[] numbers = {1, 2.0, 3L};
    UnaryFunction<Number> nums = idFunction();
    for(Number n : numbers)
    {
        System.out.println(nums.apply(n));
    }
}

我的问题是，为什么我们在这里需要通用interface？

只需以下即可：

public interface UnaryFunction
{
    Object apply(Object arg); //Object as return type and argument type, instead.
}

？这里有什么需要使用泛型？

而且，什么是通用的单件工厂？有什么好处？

感谢。

Answer 1

通用单件工厂是示例中的idFunction。如果没有它，你可以在两个丑陋的替代品之间做出选择，无论你在哪里使用它都要求使用，如下所示：

public class ExampleWithoutGenericSingletonFactory {

    static UnaryFunction<Object> ID_FUNC = new UnaryFunction<Object>() {
        public Object apply(Object arg) {
            return arg;
        }
    };

    public static void main(String[] args) {
        BigDecimal b = new BigDecimal("1234.1241234");
        BigDecimal b1 = (BigDecimal)(ID_FUNC.apply(b)); // have to cast here >_<
        System.out.println("engineeringstring val of b1 = " 
        + b1.toEngineeringString());
    }
}

或为您要支持的每种类型单独实施：

public static UnaryFunction<String> ID_FUNC_STRING = new UnaryFunction<String>() {
    public String apply(String arg) {
        return arg;
    }
};

public static UnaryFunction<Number> ID_FUNC_NUM = new UnaryFunction<Number>() {
    public Number apply(Number arg) {
        return arg;
    }
};

public static UnaryFunction<BigDecimal> ID_FUNC_DECIMAL = new UnaryFunction<BigDecimal>() {
    public Number apply(BigDecimal arg) {
        return arg;
    }
};

为您提供一些丑陋的详细剪切代码，每个类型都有不同的名称。但是既然你知道它是一个纯函数并且类型被擦除，你只能有一个实现（ID_FUNC）并且让单件工厂idFunction返回它。

如果你有一个函数实现，你希望能够指定不同的类型，实现是无状态的，你可以使用它。

这个例子可能更好，因为它只调用函数调用返回的对象上的toString，没有工厂的好处。如果示例显示在返回的对象上使用特定于类型的方法，那么好处可能会更明显。

当你这样做时会出现未经检查的施法警告，但是可以安全地禁止它（这是约书亚布洛赫所建议的）。

通用Singleton工厂

1 个答案: