"Good programming practice" question about writing classes

Question

I am taking a java class this year and my teacher has taught us to never use global variables in a class (but still private). I find it much easier to explain with a simple example. Say I have a class that looks like this:
public class Demo
        private int int1, int2;
     public Demo()
          int1 = 1;
          int2 = 2;
     public void demoMethodOne(int int1, int int2)
          //... code using the ints passed to the method
     public void demoMethodTwo()
          //... code directly accessing the private ints of the class
        public int getInt1() { return int1; }
        public int getInt2() { return int2; }
}My teacher says to ALWAYS use methods of the type demoMethodOne (to pass all of the variables it will use to it) and avoid using the type demoMethodTwo. But in my programming experience, I have found it very repetitive and pointless to use that method in some cases. For example if I call demoMethodOne like this:
demoMethodOne(demo.getInt1(), demo.getInt2());
That seems very repetitive but that is how I am told to do it. Should I program that way even if it seems very pointless or is it ok to use "public" variables like in demoMethodTwo. Thanks.

Answer 1

I think you may have misunderstood your teacher.
If your object method is doing something with the object's state, then it's perfectly appropriate to modify the object's fields, which embody the state.
And generally it's good to adopt a functional programming approach, in which there are few side effects. This principle is sort of independent of the previous one.
The danger is when you treat object fields as global variables (and not as the embodiment of the object's state). In this case the global variable doesn't really represent anything, it's just a place to store data temporarily to avoid designing your methods properly. So for example you'd have two methods, one sets a field and then calls another method, which reads the field; the field doesn't really mean anything to the object as a whole, it's just a lazy way to pass data between the two methods. This is asking for bugs. The correct thing would have been to pass the value as an argument to the second method.
Also, if you have a method that doesn't really express the behavior or effect the state of an object, but is called just for its return value (like some kind of utility method), then it's pointless and dangerous to make it effect the state of an object.