避免代码重复 - 最佳方法

Question

我有两个方法具有相同的参数列表和类型几乎相同的主体，但他们每个都调用另一个函数来获取元素列表。更确切地说：

    public void method1 (int a, int b) { 
      //body (the same in both of methods) 
      List<SomeObject> list = service.getListA(int c, int d); 
      //rest of the body (the same in both of methods) 
     } 

     public void method2 (int a, int b) { 
      //body (the same in both of methods) 
      List<SomeObject> list = service.getListB(int c, int d, int e); 
      //rest of the body (the same in both of methods) 
     } 

这种情况下避免代码重复的最佳方法是什么？我想到了Strategy模式，但是参数列表中存在差异的问题。

UPDATE：

    public void method1 (int a, int b) { 
      //body (the same in both of methods) 
      int c = some_value; 
      List<SomeObject> list = service.getListA(a, b, c); 
      //rest of the body (the same in both of methods) 
     } 

     public void method2 (int a, int b) { 
      //body (the same in both of methods) 
      int c = some_value; 
      int d = another_value; 
      List<SomeObject> list = service.getListB(a, b, c, d); 
      //rest of the body (the same in both of methods) 
     } 

所以有些变量是局部的，有些是通过参数传递。

Answer 1

将它们分解为其他方法。避免在你的情况下重复的代码

public void method1 (int a, int b) { 
     MyClass myClass = method3(a, b); 
     List<SomeObject> list = service.getListA(myClass.getC(), myClass.getD()); 
     method4(list); 
} 

public void method2 (int a, int b) { 
     MyClass myClass = method3(a, b); 
     List<SomeObject> list = service.getListB(myClass.getC(), myClass.getD(), myClass.getE()); 
     method4(list); 
} 

public MyClass { 
    private final int c; 
    private final int d; 
    private final int e; 
    ... 
} 

public MyClass method3(int a, int b) { 
    // body 
    return new MyClass(c, d, e) 
} 

public void method4(List<SomeObject> list) { 
    // rest of body 
} 

Answer 2

的一种方法是引入用来决定要检索的方法列表将要使用一个额外的参数：

​​

，而不是使用int method作为附加参数，我将使用新的enum类型，并在switch语句中定义default个案。

Answer 3

将service.getListA或service.getListB的调用封装到ListSource类/接口中，在具体类中实现每个版本并将具体实例作为第三个参数传递。这基本上是jlordo提出的答案的面向对象版本。

interface ListSource { 
    List<SomeObject> getList(int c, int d, int e); 
} 

class ListSourceA implements ListSource { 
    // constructor etc. 
    @Override 
    public getList(int c, int d, int e) { 
     return service.getListB(c, d); 
    } 
} 

class ListSourceB implements ListSource { 
    // constructor etc. 
    @Override 
    public getList(int c, int d, int e) { 
     return service.getListA(c, d, e); 
    } 
} 

public void method (int a, int b, ListSource source) { 
    //body (the same in both of methods) 
    List<SomeObject> list = source.getList(int c, int d, int e); 
    //rest of the body (the same in both of methods) 
} 

Answer 4

public void method (int a, int b, List<SomeObject> theList) { 
    //body (the same in both of methods) 
    List<SomeObject> list = theList; 
    //rest of the body (the same in both of methods) 
} 

这对我来说将删除所有代码重复，表示方法从未我们要使用不同的方法签名获得的列表进行操作，每次进行修改。

我相信你能推进这一如果类型SomeObject不使用泛型，即已知的（和我不是一个Java程序员，所以你将不得不read the docs）

public void method (int a, int b, List<T> theList) { 
    //body (the same in both of methods) 
    List<T> list = theList; 
    //rest of the body (the same in both of methods) 
} 

Answer 5

你也可以使用一个枚举：

public void method(int a, int b, Service service) { 
    // body 
    List<SomeObject> list = service.getList(myClass); 
    // rest 
} 

public enum Service { 
    METHOD_1 { 
     @Override 
     public List<SomeObject> getList(MyClass myClass) {} 
    }, 
    METHOD_2 { 
     @Override 
     public List<SomeObject> getList(MyClass myClass) {} 
    }; 

    public abstract List<SomeObject> getList(MyClass myClass); 
} 

public MyClass { 
    private final int c; 
    private final int d; 
    private final int e; 
    ... 
} 

基本上与@proskor相同，只是形式不同。

Answer 6

如果身体部分依赖于彼此，所以你不能象@ dicarlo2的回答是：

private interface GetObjects { 
    List<SomeObject> get(); 
} 

public void method1(int a, int b) { 
    impl(a, b, new GetObjects() { public List<SomeObject> get() { 
     return service.getListA(c, d); 
    }}); 
} 

public void method2(int a, int b) { 
    impl(a, b, new GetObjects() { public List<SomeObject> get() { 
     return service.getListB(c, d, e); 
    }}); 
} 

private void impl(int a, int b, GetObjects getObjects) { 
    //body (the same in both of methods) 
    List<SomeObject> list = getObjects.get(); 
    //rest of the body (the same in both of methods) 
} 

，如果你关心new您可以使用枚举代替GetObjects，但不要”不介意让订单混在一起，错过了外部this，不想打开它（尽管它可以实现公共接口）。

可能会出现Java SE 8中更好的语法。 IIRC，沿线：

public void method1(int a, int b) { 
    impl(a, b, { -> service.getListA(c, d) }); 
}