3

我正在写一个小图书馆。

public class MyClass {

    public static String doSomethingWithString(final String s) {
        new MyClass().doSomething(s);
    }

    public String doSomething(final String s) {
        return null;
    }
}

或者我可以这样做。

public class MyClass {

    public static String doSomethingWithString(final String s) {
        return null;
    }

    public String doSomething(final String s) {
        return doSomethingWithString(s);
    }
}

哪种风格更受欢迎？他们是一样的吗？

更新

感谢您的评论和回答。

这里有两个类。

public class IdEncoder {

    private static String block(final long decoded) {
        final StringBuilder builder = new StringBuilder(Long.toString(decoded));
        builder.append(Integer.toString(
            ThreadLocalRandom.current().nextInt(9) + 1)); // 1-9
        builder.append(Integer.toString(
            ThreadLocalRandom.current().nextInt(9) + 1)); // 1-9
        builder.reverse();
        return Long.toString(
            Long.parseLong(builder.toString()), Character.MAX_RADIX);
    }

    public static String encodeLong(final long decoded) {
        return block(decoded >>> 0x20) + "-" + block(decoded & 0xFFFFFFFFL);
    }

    public String encode(final long decoded) {
        return encodeLong(decoded);
    }
}

还有另一种风格。

public class IdDecoder {

    public static long decodeLong(final String encoded) {
        return new IdDecoder().decode(encoded);
    }

    public long decode(final String encoded) {
        final int index = encoded.indexOf('-');
        if (index == -1) {
            throw new IllegalArgumentException("wrong encoded: " + encoded);
        }
        return (block(encoded.substring(0, index)) << 32)
               | (block(encoded.substring(index + 1)));
    }

    private long block(final String encoded) {
        final StringBuilder builder = new StringBuilder(
            Long.toString(Long.parseLong(encoded, Character.MAX_RADIX)));
        builder.reverse();
        builder.deleteCharAt(builder.length() - 1);
        builder.deleteCharAt(builder.length() - 1);
        return Long.parseLong(builder.toString());
    }
}
4

2 回答 2

3

如果您只是在这两个选项之间进行选择，请选择第二个。

原因是第一个要求您在堆上分配一个新的虚拟对象只是为了调用一个方法。如果确实没有其他区别，请不要浪费时间和空间，只需从类中调用静态方法即可。

第二个更类似于静态实用程序函数，这是一种很好的编码实践。

于 2013-05-31T01:37:04.163 回答
2

在编写库时，易用性大大胜过一般的最佳实践。如果用户实例化某些东西以访问它没有意义，那么您的方法应该是静态的。然而，通常将方法作为对象的一部分实际上更清晰、更强大，因为它允许用户（以及库编写者）在子类中覆盖它。

从某种意义上说，您实际上并不是在问编程问题，而是在问用户体验问题。问问自己，您的用户将如何从访问您的代码中获得最大收益，并以这种方式实现它。作为一个很好的基准，看看Guava API；它由许多静态实用程序类组成，但也包含许多旨在轻松扩展的类和接口。做你认为最好的事情。

于 2013-05-31T03:33:12.497 回答