Java – When to Use Inheritance or Composition/Aggregation?

On the other hand, this member variable isn't really representing any object state (as it's neither set nor available outside), but is really a hidden additional argument for the "inner" private method.

That reinforces my gut feeling upon reading your question: try to keep this data as local as possible, i.e. don't add it to the object state. This reduces the state space of your class, making your code simpler to understand, test and maintain. Not to mention that avoiding shared state makes your class more threadsafe too - this may or may not be a concern to you right now, but it may make a huge difference in the future.

Of course, if you need to pass around such flags excessively, it may become a nuisance. In this case, you may consider

• creating parameter objects to group related parameters together into a single object, and/or
• encapsulating this state and the associated logic into a separate family of strategies. The viability of this depends on the language: in Java, you need to define a distinct interface and a (possibly anonymous) implementation class per each strategy, whereas in C++ or C# you may use function pointers, delegates or lambdas, which simplifies the code considerably.

IMO, "making my method more "generic" and not reliable on the class" is not a good goal, since it promotes classes with low cohesion.

If your method is generic enough to serve for other classes, too, then take it out of the class and move it to a "function library" class. (But beware of the functional decomposition antipattern).