Status: Fendy和Glen Best的答案 同样 被我 接受
和尊重，但由于可以接受并给予赏金，因此我选择Fendy的答案。

Scenario:

如果我有 一些代码 有 被多次重复使用 在 许多类 （很少有轻微参数改变是显而易见的）和并发线程，哪种方法去？

必须重用的代码可以是任何理智的东西（在考虑了静态和非静态上下文以及方法制作技术的前提下）。它可以是一种算法，一种执行connect，operate，close的DB方法。什么都可以

1. 使类 变得 很像，MyMethods.class然后 将所有这些方法放入其中 。

1.a. 制作 方法 static和呼叫（在各个阶层和并发线程）直接作为MyMethods.someMethod();

1.b. 制作 方法 non-static和当时打电话给他们， instantiate 全班通过MyMethods mm = MyMethods(); mm.someMethod();

1. 使用https://en.wikipedia.org/wiki/Strategy_pattern中所述的 策略模式 （代码随附于此）。

2. 使用https://en.wikipedia.org/wiki/Dependency_injection#Java中所述的 依赖项注入

Problems:

1. 有人会说，使用这种方法将 无法进行* 单元测试 http://en.wikipedia.org/wiki/Unit_testing ， 在换出 后者时会 遇到麻烦 。如果你想测试你的类，并使用一个 模拟版本 中的 依赖 ***

1.a. 并发 调用或多个类是否会有问题？特别JDBC static methods是一个例子？

1.b. 我认为这将导致过多的 内存负载， 因为仅调用一个或两个方法 就 需要花费instanticated很多时间。

1. 多数民众赞成在我头上，请解释一下和/或任何优点/缺点

2. 我 也没有 想 用一个框架 在上下文中对这个问题..在我头上那顺便说一下，解释和或任何优势/劣势

3. 等待任何其他策略或建议（如果有）。

Request: 请仅在有经验的情况下回答，并深刻理解其含义，并能以您的回答全面帮助我和整个社区！

Code:

/** The classes that implement a concrete strategy should implement this.
* The Context class uses this to call the concrete strategy. */
interface Strategy {
    int execute(int a, int b); 
}

/** Implements the algorithm using the strategy interface */
class Add implements Strategy {
    public int execute(int a, int b) {
        System.out.println("Called Add's execute()");
        return a + b;  // Do an addition with a and b
    }
}

class Subtract implements Strategy {
    public int execute(int a, int b) {
        System.out.println("Called Subtract's execute()");
        return a - b;  // Do a subtraction with a and b
    }
}

class Multiply implements Strategy {
    public int execute(int a, int b) {
        System.out.println("Called Multiply's execute()");
        return a * b;   // Do a multiplication with a and b
    }    
}

// Configured with a ConcreteStrategy object and maintains
// a reference to a Strategy object 
class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public int executeStrategy(int a, int b) {
        return this.strategy.execute(a, b);
    }
}

/** Tests the pattern */
class StrategyExample {
    public static void main(String[] args) {
        Context context;

        // Three contexts following different strategies
        context = new Context(new Add());
        int resultA = context.executeStrategy(3,4);

        context = new Context(new Subtract());
        int resultB = context.executeStrategy(3,4);

        context = new Context(new Multiply());
        int resultC = context.executeStrategy(3,4);

        System.out.println("Result A : " + resultA );
        System.out.println("Result B : " + resultB );
        System.out.println("Result C : " + resultC );
    }
}