Q:

Best Practice for Checking Dependent Variables Before or inside Method

I was wondering what the best practices would be for when you have a variable that needs to be checked before a certain helper method could run. Should the check be done in the caller or callee? I see benefits to both. A bit less expensive to do it in the caller method (before calling the helper method) but that puts the checks on the developers shoulders and something may get lost if the code switches hands (which it will do). Thus, that's the benefit of having it in the callee. A very crude example of what I mean is below
public class TestClass implements TestInterface {

    private String dependentVariable = null;

    public TestClass(arg1) {
    }

    @Override
    public void init(String flag) {
        this.dependentVariable = flag;
        caller();
    }

    public void caller() {
        //do it here?
        if(this.dependentVariable != null)
            callee();
    }

    public void callee() {
        //or do the check here?
        // do stuff involving the dependentVariable...
    }

}

A:

You should handle this in init() itself. If your class behaviour is dependent on this variable you should not let your class get initialized with null in the first place.
@Override
public void init(String flag) {
    if (flag == null)
        throw IllegalArgumentException("Flag cannot be null");
    this.dependentVariable = flag;
    caller();
}

If the absence of the flag is okay and should just preempt the execution of callee(), it should be handled within callee() itself.
public void callee() {
    if (flag == null) return;
    // do stuff involving the dependentVariable...
}

This is because, as the code base grows, you would not be able to check if flag is being null checked everywhere prior to calling callee(). This falls in line with the DRY principle too. 

