Java 何时创建帮助器方法和单独的文件

背景：我有一个大型（几百行）类，它管理基于一些基本类型数据结构的概念

long[] slist;  //list of unique patterns (related to polyominoes)
int[][][] sref;//patterns at each place [location][depth][<list of indices in slist>]

问题是，如果一个文件中有太多不相关的helper方法，可读性就不会提高

答案让我一路走到那里。我可以在同一个包中，在它们自己的类中声明结构，并访问基本成员字段或与调用相关的方法。但我仍然想知道这里被接受的智慧，因为这个组织不容易让人想到

---

您是否会将

update（）

和

build（）

函数放在它们自己的文件中？如果是这样，他们的共同任务应该宣布在哪里？

我强烈推荐阅读马丁·福勒的著作（）；它应该在每个程序员的库中，并将帮助您处理类似的情况。我会在邮件中提到它

如果一个类有太多的代码，那么通常是时候拆分这个类了。这可能需要创建具有类的成员变量（委托功能），也可能意味着动态创建对象（）。共享共性的事物是应用继承或继承的好例子

简短回答 是的，您甚至可以在自己的文件中包含这些函数。然而，我会改为让他们上课。可能是

Updater

和

Builder

对象。您可以从

BuilderCommon

和

updateercommon

类继承。这些新对象将耦合到旧对象，但这没关系。您可以考虑将这些新的类设置在自己的包中。分层组织将有助于提高通用代码的可读性和重用性。 尝试利用继承之类的概念和泛型之类的抽象技术来完成这项工作。如果您可以找到

doA

、

doB

等之间的共性，请从它们中生成

UpdateHelper

类，并将它们放入列表中。然后简单地迭代列表

这只是众多方法之一：

public class Updater
{
    public Updater(List<IUpdateHelper> helpers)
    {
        helpers = new ArrayList<UpdateHelper>();
        this.helpers.add(helpers);
    }
    public void update()
    {
        for (IUpdateHelper helper : helpers)
        {
            helper.performHelp();
        }
    }

    protected List<IUpdateHelper> helpers;
}

public class UpdaterCommon extends Updater
{
    public UpdaterCommon()
    {
        helpers.add(new UpdateHelperA());
        ... // Etc.
    }
}

/*
 * This uses inheritance for common helpers, but it could just as well use
 * delegation. Also, this assumes that order of invocation for each helper 
 * doesn't matter.
 */
public class UpdaterOne extends UpdaterCommon {...}

interface IUpdateHelper
{
    public void performHelp();
}
public class UpdateHelperA implements IUpdateHelper {...}

公共类更新程序
{
公共更新程序（列表帮助程序）
{
helpers=newarraylist（）；
this.helpers.add（helpers）；
}
公共无效更新（）
{
用于（IUpdateHelper帮助程序：帮助程序）
{
helper.performHelp（）；
}
}
受保护名单助手；
}
公共类UpdaterCommon扩展更新程序
{
公共更新命令（）
{
add（newupdatehelpera（））；
…//等等。
}
}
/*
*这对普通助手使用继承，但也可以使用
*代表团。此外，这假定每个助手的调用顺序相同
*没关系。
*/
公共类UpdaterOne扩展了UpdaterCommon{…}
接口IUpdateHelper
{
公共无效性能帮助（）；
}
公共类UpdateHelper实现IUpdateHelper{…}

确定并添加一个接口

结束

---

根据我的经验，通常只需要定期应用其中的一些概念，就可以显著提高代码质量。如果一个包、类、方法、条件等变得难以控制，将其分解成一个更小的单元。继续将基本功能下推到非常小的方法中，以便您可以从较高的层次查看代码。

编写同一段代码有许多不同的方法。 我喜欢把我的代码写成一种我可以用真实的语言来解释的方式

例如，假设我在创造一个人。 如果我把所有的身体部位都放在一节课上，读起来会有点混乱

我可以将头部、四肢和躯干分为不同的类别，然后将它们全部分为我的人类类别，但即便如此，这些身体部位都相当复杂。你可能想再细分一点

我可以为眼睛、鼻子、嘴巴和耳朵做一个类，然后在你的头类中引用它们

手指，手指关节，指甲。。。所有这些都可以进入手工课

这都是关于你的心态。一旦您构建了所有类，您就可以根据自己的喜好引用它们

为了继续这个例子，至少对我来说，我会在Arm类中引用Hand类，因为每个Arm都包含一只手（希望…）

如果我叫人帮忙的话，会是这样的：

Arm leftArm = new Arm();
Arm rightArm = new Arm();

leftArm.hand.makeFist();
rightArm.hand.raiseMiddleFinger();

尽管这样写会很乏味（如果你想引用手，你必须穿过手臂才能找到它），这就是为什么我喜欢使用静态值和返回方法。这都是关于你如何看待编程的。我喜欢将编程与现实世界进行比较

至于helper方法，我喜欢将它们视为操作。 如果你想做一些事情，比如“turnOnTv”或“tossBall”，那么你应该把这个方法放在受尊重的类中

例如，假设您想让某人掷一个球。 您可能希望在拥有用户信息的类中使用“public void tossBall（）”方法，因此当您调用它时，它看起来有点像

Person personNumberOne = new Person();

personNumberOne.tossBall()

---

这只是我个人的看法。并不是说这是正确的方法，但老实说，真的没有正确的方法，看看事情可以通过多种方式来完成。在任何地方寻找效率总是很好的，但是你也不想使用你不懂的代码

一种设计模式在这里可能会有所帮助，这就是抽象工厂模式，你可以创建一个抽象类/接口，在其中定义你的助手方法（作为抽象），并在原始的update（）和build（）中使用这个接口方法

并为抽象工厂（类/接口）创建一个子类，在这个子类中完成所有工作

您可以将参数传递给抽象方法，这些方法将在您将创建的子类中实现它们时使用，以便保持事物之间的连接，但也保持松散耦合

例如：

class Client {
    private AbstractFactory factory = null;

    public Client(AbstractFactory factory){
        this.factory = factory;
    }

    void update(){
        String a = factory.getA();
        MyObject b = factory.getB(a);
        b.doSomeStuff();
        int c = factory.getC(b);
    }

    void build(){
        AnotherObject d = factory.getD();
        d.doMoreStuff();
    }
}

public interface AbstractFactory{
    String getA();
    MyObject getB(String a);
    int getC(MyObject b);
    AnotherObject getD();
}


public class Helper implements AbstractFactory{
    // implement your methods here
}

public class MyObject{ /*some helper methods here as well */}
public class AnotherObject{ /*another helper methods here as well */}

这将提供松耦合和eas

class Client {
    private AbstractFactory factory = null;

    public Client(AbstractFactory factory){
        this.factory = factory;
    }

    void update(){
        String a = factory.getA();
        MyObject b = factory.getB(a);
        b.doSomeStuff();
        int c = factory.getC(b);
    }

    void build(){
        AnotherObject d = factory.getD();
        d.doMoreStuff();
    }
}

public interface AbstractFactory{
    String getA();
    MyObject getB(String a);
    int getC(MyObject b);
    AnotherObject getD();
}


public class Helper implements AbstractFactory{
    // implement your methods here
}

public class MyObject{ /*some helper methods here as well */}
public class AnotherObject{ /*another helper methods here as well */}