Question

我有一些耗时的代码，您可以将其作为从磁盘加载数据（但绝对不仅如此）。但是我在初始化时只需要这段代码，但是完成后，我可以直接快速地使用与它相关的一些方法。

现在我不知道我应该把这段代码放在哪里，这是我的想法：我把它放在某个类A的构造函数中，然后在类B中，它需要在A中调用一些方法，所以我在B＆＃39的构造函数中创建了一个新的A实例，这非常理想，因为每次我需要A方法时，我都可以直接访问它，而A的构造函数只调用一次。

但问题是，我有一些其他的C类，它们生成了很多B实例（新的B（）），然后每次C生成一个新的B实例，A＆＃39的构造函数都会被调用，这又是非常耗时的，我如何组织我的代码以避免这种情况？

请参阅代码以获得澄清。

class A{
    public A(){
        some time-consuming code; 
    }
    public void methodInA(){
        some method in A;
    }
}

class B{
    public B(){
        A a = new A();
        for (i=0; i<10000;i++)
            methodInB();
    }
    public void methodInB(){
        methodInA();
    }
}
//so far, everything is perfect, but I have another class C 

class C{
    public C(){
        some code;
    }
    public void methodInC(){
        for (i = 0; i<10000; i++)
            new B();
    }

}

Answer 1

方法1：使A类中的方法成为静态，并在静态块中进行初始化。

请参阅此SO answer。

class A {
    // if any variable then make them static
    static {
        // some time-consuming code;
    }

    public static void methodInA() {
        // some method in A;
    }
}

class B {
    public B() {
        for (int i = 0; i < 10000; i++)
            methodInB();
    }

    public void methodInB() {
        A.methodInA(); // directly call static method
    }
}

方法2：制作A类singleton。但@BalusC在SO answer中就是not recommended。

Answer 2

所以你已经发现了那个耗费时间代码的问题＆＃34;进入类A的构造函数。如果经常调用耗时的构造函数，那么如果你生成很多类a的对象，那么你将有一个总体耗时的程序。例如，方法

mehodInC(){ 
    //some code
}

C类会创建10.000个新的B对象，并且因为每个B对象在构造函数中自动创建一个A对象，所以最终会将耗时的代码片段调用10.000次。

现在这显然不是最理想的，我们怎么能解决这个问题呢？如果我是你，我会将该代码片段移动到一个方法中，因为它可以让您更好地控制何时调用它。（让我们为进一步的参数调用方法methTimeConsuming（））它还分离了您的程序的不同功能。这有助于最终代码的整体可读性。

这样一种只调用一次耗时的代码的方法，即使你创建了很多对象，也是：

A myObj = new A();
myObj.methTimeConsuming();
for(int x = 0; x < 9999; x++){ //9999 because you already called it once outside of for-loop
    myObj = newA();
}

很明显，这是一个非常基本的代码片段，但这个想法可以从那里扩展。

我应该把我的代码放在哪里？

2 个答案: