Question

我正在写一个小型图书馆。

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

Answer 1

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

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

第二种更类似于静态效用函数，它是一种很好的编码实践。

Answer 2

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

从某种意义上说，你实际上并不是在问一个编程问题，而是一个UX问题。问问自己，您的用户如何最好地访问您的代码，并以这种方式实现它。作为一个很好的基准，请看Guava API;它由许多静态实用程序类组成，但同样多的类和接口也可以轻松扩展。做你认为最好的事情。

静态方法或实例方法中的实际代码

2 个答案: