 <p>They reduce reusability in much the same way that global variables do: when you method's computations depend on state which is external to the method, but not passed as parameters (i.e. class fields for example), your method is less reusable, because it's tightly coupled to the state of the object/class in which it resides (or worse, on a different class entirely).</p> <p><strong>Edit</strong>: Ok, here's an example to make it more clear. I've used <code>ThreadLocal</code> just for the sake of the question, but it applies to global variables in general. Assume I want to calculate the sum of the first N integers in parallel on several threads. We know that the best way to do it is to calculate local sums for each thread and them sum them up at the end. For some reason we decide that the <code>call</code> method of each <code>Task</code> will use a <code>ThreadLocal sum</code> variable which is defined in a different class as a global (static) variable:</p> <pre><code>class Foo { public static ThreadLocal&lt;Long&gt; localSum = new ThreadLocal&lt;Long&gt;() { public Long initialValue() { return new Long(0); } }; } class Task implements Callable&lt;Long&gt; { private int start = 0; private int end = 0; public Task(int start, int end) { this.start = start; this.end = end; } public Long call() { for(int i = start; i &lt; end; i++) { Foo.localSum.set(Foo.localSum.get() + i); } return Foo.localSum.get(); } } </code></pre> <p>The code works correctly and gives us the expected value of the global sum, but we notice that the class <code>Task</code> and its <code>call</code> method are now strictly coupled to the <code>Foo</code> class. If I want to reuse the <code>Task</code> class in another project, I must also move the <code>Foo</code> class otherwise the code will not compile.</p> <p>Although this is a simple example complicated on purpose, you can see the perils of "hidden" global variables. It also affects readability, since someone else reading the code will have to also search for the class <code>Foo</code> and see what the definition of <code>Foo.localSum</code> is. You should keep your classes as self-contained as possible.</p>