使用其他方法或继承将变量传递给方法

Question

Hello I'm a little rusty on my Java, so please bear with me. I have been tasked with reducing the amount of duplicated code in a research project for my Professor, so I don't think I'm able to post any of the code on here. But basically I have about 20 cases of generally the same method ( test method ) in different classes, and I've been trying two different ways to solve this problem but I have run into issues with each.

The first way I've found to reduce the duplication is to remove the initial variables contained in all of the test methods and place them in a separate method ( prepare method ) inside of a superclass and have it called into the test method . Isn't the problem with this solution that all of the variables declared in the prepare method will remain local and be erased as soon as the method is called inside of another method?

The second idea I had was to just make all of the variables fields of the superclass and have them be inherited by the subclasses. This solution almost worked except for the fact that one of the variables IFile importedFile = importFile(file); which is necessary for creating many of these variables has to have whatever it is contained in throw an Exception, which I do not believe you can do with a class.

I was hoping someone could point me in the right direction with one of these solutions or possibly suggest another solution I have been unable to find.

Something I forgot to mention is that besides the initial variables, each test method slightly varies in how their test method is written. Edit: If not for this I would have just pulled up the method into a superclass and been done with it.

Edit: Here's the test method and the parts of the superclass I am using,

// method inside of the subclass    
public void test() throws Exception {
           // variables removed and placed in AbstractTest
            for (int i = 0; i < expectedExitNodeCount; i++) {
                if (markerFields.peekFirst().equalsIgnoreCase("EXPOSED_EXIT")) {
                    expectedExitNodes.add(new CTrueExitNode());
                } else {
                    fromLine = Integer.parseInt(markerFields.removeFirst().trim());
                    fromCol = Integer.parseInt(markerFields.removeFirst().trim());
                    toLine = Integer.parseInt(markerFields.removeFirst().trim());
                    toCol = Integer.parseInt(markerFields.removeFirst().trim());
                    length = length(ast, fromLine, fromCol, toLine, toCol);
                    assertTrue(length > 0);
                    ICFlowNode expectedExit = findNode(ast, ICFlowNode.class, fromLine, fromCol, length);
                    assertNotNull(expectedExit);
                    expectedExitNodes.add(expectedExit);
                }
            }
                // additional code omitted from method
            }

// Superclass the variables have been placed in.
public abstract class AbstractTestCase extends WorkTest {
    protected File file;
    protected String markerText;

    public AbstractTestCase(String name, VPG< ? , ? , ? > vpg) {
        super(name, vpg);
    }

    protected void prepare() throws Exception {
       // Variables used in the test method  
          IFile importedFile = importFile(file);

        project.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());
        CVPG.getInstance().ensureVPGIsUpToDate();

        CTranslationUnit ast = CVPG.getInstance().acquireTransientAST(
            ResourceUtil.getFilenameForIFile(importedFile));

        LinkedList<String> markerFields = MarkerUtil.parseMarker(markerText);

        int fromLine = Integer.parseInt(markerFields.removeFirst().trim());
        int fromCol = Integer.parseInt(markerFields.removeFirst().trim());
        int toLine = Integer.parseInt(markerFields.removeFirst().trim());
        int toCol = Integer.parseInt(markerFields.removeFirst().trim());
        int length = length(ast, fromLine, fromCol, toLine, toCol);
        assertTrue(length > 0);
        IASTNode node = findNode(ast, IASTNode.class, fromLine, fromCol, length);
        assertNotNull(node);

        Integer expectedExitNodeCount = Integer.parseInt(markerFields.removeFirst().trim());
        Set<ICFlowNode> expectedExitNodes = new HashSet<ICFlowNode>();
    }

    protected void test() throws Exception {
       //Considered making test a inherited method
    }
}

Answer 1

Why the field approach isn't so cool: you are introducing sequential coupling. Whoever comes next won't readily know that method test will fail without calling method prepare. Also if a class extend another or the structure changes you might end up calling prepare twice and having hard to trace errors

Pattern 1) move all variables into a state object

Group variables into a new object - not the superclass

Create a builder object so the class that you can easily initialize what variable you need into this object

Change test method to accept this object and work from its data

public class TestParameters {
    public boolean flag1;
    public int someNumber;
}

public class Tester {

    public static void test(TestParameters p) {
       for (int i=0; int i<p.someNumber;i++) {
          if (p.flag1) doA();
          else doB();
       }
    }
}

public class Builder {
   TestParameters p = new TestParameters();

   new Builder() {
   }

   public Builder setFlag(boolean f) {
       p.flag1 = f;
   }

   public Builder setNumber(int n) {
       p.someNumber = n;
   }
   public TestParameters build() {
       return p;
   }
}

public class SomeClass {

   public void doSomething() {
       TestParameters p = new Builder().setFlag(true).setNumber(10).build();
       Tester.test(p);
   }
}

Pattern 2) inversion of control

Create a class for your test method, make the variable parts field of this new class. Set up variables during this class constructor - add static getInstanceForXxxx methods and hardcode the magic values you need for each of these static getters - into each getInstanceForXxxx you create a new instance passing in whatever initializarion value client needs

public class Tester {
    public boolean flag1;
    public int someNumber;

    private Tester() {};

    //feel free to be more descriptive if each initialization apply for more than one class 
    public static Tester testForClassSomeClass() {
        Tester t = new Tester();
        t.flag1=false;
        t.int=2;
        return t;
    }

    public void test() {
       for (int i=0; int i<someNumber;i++) {
          if (flag1) doA();
          else doB();
       }
    }

}


public class SomeClass {

   public void doSomething() {
       Tester t = Tester.testForClassSomeClass();
       t.test();
   }
}

Pattern 3) encapsulate behaviour in strategy

Create a base class. Each point of the duplicate code which is different, refactor in a private method. Create a class and override each method with the specialized code you need. Instanciate the right class for each client and call the public test method

public abstract class Tester {


    private Tester() {};

   public boolean getFlag();
   public int getNumber();
   public int someLogic();

    public void test() {...}

}
public class SomeClassTester {


    private Tester() {};


   public int getNumber() {
      return false;
   }
   public int someLogic() {
      doA();
   }

    public static void test() {
       for (int i=0; int i<getNumber();i++) {
          doA();
       }
    }

}


public class SomeClass {

   public void doSomething() {
       Tester t = new SomeClassTester();
       t.test();
   }
}

I like this last because it gets rid for a flag (flag1) and encapsulate properly behaviours (specific SomeClass test only has doA() call)

Answer 2

Defining the variables as fields is a good way, I think. But you should initialize them a little bit later. Just use a constructor to init the variables, and there you can catch Exceptions!