静态方法中的重复代码

Question

我有两个用 JAVA 实现的阅读器。见下文：

public final class ReaderA {
  public ReaderA() {}

  public static int read(final File file) {
    final byte[] data = Files.readAllbytes(file.toPath());
    return read(data);
  }

  public static int read(final byte[] data) {
    // do somethingA
  }

  ...// and some other methods
}


public final class ReaderB {
  public ReaderB() {}

  // this method is exactly the same as in ReaderA
  public static int read(final File file) {
    final byte[] data = Files.readAllbytes(file.toPath());
    return read(data);
  }

  // this is implemented different from the one in ReaderA
  public static int read(final byte[] data) {
    // do somethingB
  }

  ...// and the same other methods as in ReaderA
}

问题。避免重复代码的最佳方法是什么？

我尝试在新的抽象类Reader 中提取重复代码，并尝试将read(final byte[] data) 抽象化并在子类ReaderA 和ReaderB 中实现它。它不会起作用，因为方法是静态的。

Answer 1

除非您从 read(byte[]) 中删除 static 修饰符并创建实例，否则您将无法使用继承来帮助您。

static 方法的行为不像实例方法，并且不能被覆盖。相反，超类和子类都将具有需要使用类名限定的单独方法。拉起read(File) 意味着它总是调用超类的read(byte[])。您仍然必须将read(File) 复制到每个子类，以使其使用该类自己的read(byte[])。 Ward's answer 中的代码也显示了这一点。

作为参考，请阅读此问题及其答案：Are static methods inherited in Java?

为了说明：您拥有的两个read(File) 方法与您在代码sn-p 中所说的不“完全相同”。它们不都调用this.read(data)，而是分别调用ReaderA.read(data) 和ReaderB.read(data)。看看read(byte[]) 调用是如何对两个完全不同的、不可覆盖的方法进行的。

---

如果它在你的能力范围内，我建议以一种不那么静态的方式重写读者：

interface Reader
{
    default int read(File file)
    {
        final byte[] data = Files.readAllbytes(file.toPath());
        return read(data);
    }

    int read(byte[] data);
}

class ReaderA
    implements Reader
{
    int read(byte[] data)
    {
        // do somethingA
    }
}

class ReaderB
    implements Reader
{
    int read(byte[] data)
    {
        // do somethingB
    }
}

注意read(File) 现在对于所有实现类都是一样的。当然，您必须将调用方法的方式从 ReaderX.read() 更改为 new ReaderX().read()。

Answer 2

我认为您需要先问自己几个问题：

1. 我真的需要两个静态方法吗？
2. “方法”或类共有哪些代码？
3. 是否会创建一个抽象类来编写此类实现并让 ReaderA 和 ReaderB 扩展它，减少重复代码？
4. 是否应该有一个父类，然后创建从上面继承的类？

我认为您应该阅读 SOLID 原则，特别是 Open/Closed Principle 和 Dependency Inversion

Answer 3

如果您使用的是 Java SE 8，则可以将静态方法放在接口中。 Java接口静态方法类似于默认方法，只是我们不能在实现类中覆盖它们。这个特性可以帮助我们避免在实现类中实现不理想的结果。

Answer 4

有一些可能性：

1. 从其中一个类中删除方法并使用继承（您不能为静态方法调用 super.myMethod()，但除非您覆盖它，否则它会起作用）

我建议不要这样做：您可能会在子类中获得其他可用的方法，而您可能不想这样做。

1. 将其提取到两个类的公共超类

2. 从一个类调用另一个类的方法。如果它们都保持相同的功能，这将起作用

Answer 5

我不确定用静态方法保持这个实现是最好的，但如果是这样，你可以添加一个Function 参数。

public class Reader {

    public static int read(final File file, Function<byte[], Integer> reader) {
        final byte[] data = Files.readAllbytes(file.toPath());
        return reader.apply(data);
    }

}

然后像这样使用它：

public final class ReaderA {
    public static int read(final File file) {
        return Reader.read(file, ReaderA::read);
    }
    public static int read(final byte[] data) {
        // do somethingA
    }
}

自从在 Java 8 中引入functional interfaces 和method references 以来，几乎没有无法避免的重复代码部分。