Java 用许多方法实现接口=巨大的类。模式来拯救？

我有很多方法的接口。（我无法将其拆分为不同的接口）

当我创建一个实现接口的类时，我在一个类文件中得到了很多方法

当所有这些方法的主体变大->类文件变大并且很难导航时，情况就变得更糟了

即使是像eclipse这样的ide，因为包含所有类的大纲窗口都会有一个垂直的滚动条，因为不是所有的方法都适合大纲

---

是否有一种模式可以防止这种情况发生？

否无法将实现拆分为多个类。 但是您可以从实现类委托给任何其他类。

---

这将减少实现中的代码，但方法的数量保持不变。

否无法将实现拆分为多个类。 但是您可以从实现类委托给任何其他类。

---

这将减少实现中的代码，但方法的数量保持不变。

我不太明白为什么不能将接口拆分为多个

我当然会尝试使用继承，比如：

第一界面：

public interface FatherInterface {
    String methodOne(String var);

    String methodTwo(String var);

    String methodThree(String var);
}

public interface SonInterface extends FatherInterface {
    String methodFour(String var);

    String methodFive(String var);
}

public interface SecondSonInterface extends SonInterface {
    String methodSix(String var);

    String methodSeven(String var);
}

第二界面：

public interface FatherInterface {
    String methodOne(String var);

    String methodTwo(String var);

    String methodThree(String var);
}

public interface SonInterface extends FatherInterface {
    String methodFour(String var);

    String methodFive(String var);
}

public interface SecondSonInterface extends SonInterface {
    String methodSix(String var);

    String methodSeven(String var);
}

第三界面：

public interface FatherInterface {
    String methodOne(String var);

    String methodTwo(String var);

    String methodThree(String var);
}

public interface SonInterface extends FatherInterface {
    String methodFour(String var);

    String methodFive(String var);
}

public interface SecondSonInterface extends SonInterface {
    String methodSix(String var);

    String methodSeven(String var);
}

等等。。。从前一个接口继承的每个接口

至于类文件变大，也可以使用继承

父亲阶级：

public class Father implements FatherInterface

子类：

public class Son extends Father implements SonInterface

等等

---

编辑

---

如果您不能拆分接口（如第三方提供的），我将按部分执行方法的实现。也就是说，每个类中只实现了其中的一些。如果需要，使用抽象类（或保留空白方法）。每个类都继承了上面的方法并实现了一些剩余的方法。

我不太明白为什么不能将接口拆分为多个

我当然会尝试使用继承，比如：

第一界面：

public interface FatherInterface {
    String methodOne(String var);

    String methodTwo(String var);

    String methodThree(String var);
}

public interface SonInterface extends FatherInterface {
    String methodFour(String var);

    String methodFive(String var);
}

public interface SecondSonInterface extends SonInterface {
    String methodSix(String var);

    String methodSeven(String var);
}

第二界面：

public interface FatherInterface {
    String methodOne(String var);

    String methodTwo(String var);

    String methodThree(String var);
}

public interface SonInterface extends FatherInterface {
    String methodFour(String var);

    String methodFive(String var);
}

public interface SecondSonInterface extends SonInterface {
    String methodSix(String var);

    String methodSeven(String var);
}

第三界面：

public interface FatherInterface {
    String methodOne(String var);

    String methodTwo(String var);

    String methodThree(String var);
}

public interface SonInterface extends FatherInterface {
    String methodFour(String var);

    String methodFive(String var);
}

public interface SecondSonInterface extends SonInterface {
    String methodSix(String var);

    String methodSeven(String var);
}

等等。。。从前一个接口继承的每个接口

至于类文件变大，也可以使用继承

父亲阶级：

public class Father implements FatherInterface

子类：

public class Son extends Father implements SonInterface

等等

---

编辑

---

如果您不能拆分接口（如第三方提供的），我将按部分执行方法的实现。也就是说，每个类中只实现了其中的一些。如果需要，使用抽象类（或保留空白方法）。每个类都继承了上面的方法，并实现了一些剩余的方法。

也许您可以通过从不同的类实现其中的一些方法，在大接口上使用策略模式。然后，当您希望使用这些方法中的任何一种时，只需从实现“大型”接口的类中调用它

---

关于策略模式的更多信息：

也许您可以在大接口上使用策略模式，从不同的类实现其中的一些方法。然后，当您希望使用这些方法中的任何一种时，只需从实现“大型”接口的类中调用它

---

<> P>关于策略模式：

在这种情况下，我会考虑你的类中的所有方法是否都是精心设计的。可能它们没有明确的目的，应该按几个分开。 您必须定义某些特定接口的明确用途

---

此外，如果您正在使用java 8，请考虑为某些方法提供一些默认实现。在这种情况下，我会考虑你们班里的所有方法是否都设计得很好。可能它们没有明确的目的，应该按几个分开。 您必须定义某些特定接口的明确用途

---

此外，如果您正在使用java 8，请考虑为某些方法提供一些默认实现。p> 我在接受答案后发布此回复，希望未来的参与者会发现它有用

---

如前所述：

---

不，没有办法将实现拆分为多个类。但是 您可以从实现类委托给任何其他类。 这将减少实现中的代码，但会减少 方法保持不变

---

有一次，我开发了一个相当大的应用程序，在这个应用程序中，我必须定义一个

生命周期

接口，该接口包含许多状态和函数，可能会造成麻烦，因此我提出了如下建议：

您可以创建一个类，将其抽象并实现大多数常用函数

public interface TheBigFunctional {
    public void functionalA();
    public void functionalB();
    public void functionalC();
    //....
    public void functionalZ();
}

public abstract class FunctionalBase implements TheBigFunctional {
    public void functionalA() {
        aInternal();
    }

    protected abstract void aInternal();

    // Rest of methods implementations.
    // You may choose to skip those if you want child classes to implement them.
}


public class FunctionalTypeFoo extends FunctionalBase {
    // Implementations.
}

public class FunctionalTypeBar extends FunctionalBase {
    // Implementations.
}

---

---

有很多（好的）方法可以解决这个问题，但我正在分享我所做的。

我在一个答案被接受后发布这个回复，希望未来的参与者会发现它有用

---

如前所述：

---

不，没有办法将实现拆分为多个类。但是 您可以从实现类委托给任何其他类。 这将减少实现中的代码，但会减少 方法保持不变

---

有一次，我开发了一个相当大的应用程序，在这个应用程序中，我必须定义一个

生命周期

接口，该接口包含许多状态和函数，可能会造成麻烦，因此我提出了如下建议：

您可以创建一个类，将其抽象并实现大多数常用函数

public interface TheBigFunctional {
    public void functionalA();
    public void functionalB();
    public void functionalC();
    //....
    public void functionalZ();
}

public abstract class FunctionalBase implements TheBigFunctional {
    public void functionalA() {
        aInternal();
    }

    protected abstract void aInternal();

    // Rest of methods implementations.
    // You may choose to skip those if you want child classes to implement them.
}


public class FunctionalTypeFoo extends FunctionalBase {
    // Implementations.
}

public class FunctionalTypeBar extends FunctionalBase {
    // Implementations.
}

---

有很多（好的）方法来解决这个问题，但我正在分享我所做的

有没有一种模式可以防止这种情况发生

在Java中：

• ：如果您可以将方法集分组到不同的接口中，以便清晰的层次关系有意义。这是公认答案的假设
• ：如果可以将方法集分组到不同的同级“域”或“类别”。请看一看来自的示例。看看

  Github

  是如何成为这个API的入口点的，同时通过连续的“分组”接口公开不同的功能集

有一种模式吗