背景：我有一个管理基于一些原始类型的数据结构，一个概念一个大的（几百行）班
long[] slist; //list of unique patterns (related to polyominoes)
int[][][] sref;//patterns at each place [location][depth][<list of indices in slist>]
问：用于填充和更新这些数据，这两种方法都将是相当长，用5〜20个任务，一些共享，别人一把独特。 我可能要为每个子任务的辅助方法。
update(...){
//do A
//do B
//do C
//...
}
build(){
//do D
//do B
//do E
//...
}
问题是，如果有一个文件太多不相关的辅助方法，可读性不提高。
在回答这个问题，让我最那里的方式。 我可以声明结构在同一个包，在自己的班级，并访问原始成员字段或调用相关的方法。 但我还是想知道这里的接受智慧，因为这个组织并不容易浮现在脑海中。
难道你会走得很远，把update()和build()函数在他们自己的文件？ 如果是的话，应该在哪里他们共同的任务声明？
我强烈建议你阅读重构 （ 亚马逊链接由Martin Fowler）; 它应该是每个程序员的图书馆，并会帮助您这样的情况。 我将把它在后。
如果一个类有太多的代码，那么它通常是时候分手的类。 这可能需要创建具有类（委托功能）成员变量，或者它可以指在飞行创建一个对象（ 替换方法与方法对象 ）。 共享共性的东西都是好的情况下施加继承或州/策略模式 。
简答
是的，你会去那么远，在他们自己的文件的功能。 但是，我反而使他们的类。 或许， Updater和Builder对象。 您可以从继承BuilderCommon和UpdaterCommon类。 这些新对象将被连接到旧的对象，不过没关系。 你可以考虑把类的这些新的套在自己的包。 分层组织将有助于可读性和共同的代码重用。 尝试利用的概念，如继承和抽象技术，如仿制药为你做的工作。 如果你能找到共性之间的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 {...}
绝对与对象替换这些阵列和添加的接口。
闭幕
在我的经验，通常只需要定期其中的几个概念的应用，使代码质量显著差异。 如果一个包，类，方法，条件等，获取要守规矩，打破它伸到一个较小的单元。 继续推动基本事实的功能分解成非常小的方法，这样就可以查看代码从一个较高的水平。
有许多不同的方式来写相同的代码。 我喜欢我的代码写入的方式，我可以解释它的实质。
例如，可以说我是一个创造者。 如果我把所有的身体部位在一个类中，这将是一个有点混乱阅读。
我可以把头部，四肢与躯干成单独的类，然后把他们都变成我的人的班，但即使是这样，这些每一个身体部位是相当复杂的。 你可能会想打破它多一点。
我可以做一个类的眼睛，鼻子，嘴和耳朵，然后在你的脑袋类中引用它们。
手指，手指关节，指甲......所有这一切可以进入手工类。
这是关于你的思维定式。 一旦你把所有的课的，你可以参考，但是它们符合喜好。
要继续这个例子中，至少对我来说，我将引用手类在ARM类，因为每个臂包含一个手（希望...）
如果我要呼吁的手，它会是这个样子：
Arm leftArm = new Arm();
Arm rightArm = new Arm();
leftArm.hand.makeFist();
rightArm.hand.raiseMiddleFinger();
虽然这将是相当繁琐写出来一样，（如果你想指的是手，你将不得不通过手臂得到它），这就是为什么我喜欢使用静态值，并返回的方法。 这是所有关于你怎么看节目。 我喜欢编程比较现实世界。
至于辅助方法，我喜欢看到他们的行动。 如果有什么你想做的事，比如“turnOnTv”或“tossBall”，那么你会想要把这种方法在推崇类。
例如，假设你希望别人折腾一球。 你会想“公共无效tossBall（）”中的类方法你有你的用户信息，所以，当你调用它，它可以看起来有点像
Person personNumberOne = new Person();
personNumberOne.tossBall()
这只是我个人的意见。 不是说这是做正确的方式，但说实话，真的是没有正确的方式看到的东西怎么可以做很多方面。 它总是好的，以寻找效率的地方就可以了，但你不要想工作的代码你不理解或者
中的设计模式，可以帮助这里是抽象工厂模式，在那里你创建一个抽象类/接口，定义在它的辅助方法（抽象），并在原来的更新（使用此接口）和建立（）方法
并创建一个子类的抽象工厂（类/接口），并在这个子类做你的工作
你可以传递参数，而在您将创建子类实现它们将被用于你的抽象方法，所以让事情变得相互连接，但松散耦合以及
例如 ：
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 */}
这将提供松耦合和代码之间更容易分离，这样，当你想修改任何事情，你不会去你的客户端类，而是会去实现类这部分，让你的原始客户端类不变
和OO原则要求......在你的代码中的至少dependencied，更多的灵活性，它会获得，当你永远在你的代码找到“新”字，少弹性将是，请注意，在例如客户端类，有几乎没有“新”的关键字，这意味着它是非常灵活的，易于维护
