How can I reset all object values with only one method call?

Question

Basically, I want to create Counter objects, all they have to do is hold number values. And in my resetCounters method, I would like to reset each object's values. This is probably very easy, but I'm a newb.

public class Counter
{
    Random number = new Random();

    Counter()
    {
        Random number = new Random();
    }

    public Random getNumber()
    {
        return number;
    }

    public void setNumber(Random number)
    {
        this.number = number;
    }

    public static void main(String[] args) 
    {
        Counter counter1 = new Counter();
        Counter counter2 = new Counter();
        Counter counter3 = new Counter();
        Counter counter4 = new Counter();
        Counter counter5 = new Counter();

    }

    public static void resetCounters()
    {

    }
    }

Answer 1

First option: Memorize each instance of Counter.

Collect each instance of Counter in some static collection. To reset all, simply iterate over all items in the collection. But strong references are too strong for this -- make sure it's a collection of weak references.

Remarks:

1. Using weak references will avoid the issue that the Counter objects exist indefinitely only because of their reference from within the static collection. Objects that are referred to only by weak references are eventually collected by the garbage collector.
2. The collection of every instance can be achieved by declaring the Counter constructor private and allowing only construction through a static member function which will also do the registration. (Or use some other incarnation of the Factory pattern.) I believe a factory is the way to go here, since each construction of an object has to carry out also a side effect. But perhaps it will make do to have the Counter constructor register this with the static collection.

Second option: Generation counter

Keep a static generation counter of type long, and also a copy of this counter in each instance. When resetting all counters, just increase the static generation counter. The getNumber() method will then check the static generation counter against its own copy and reset the counter if the static generation counter has changed.

(I don't really know the "official" name for this trick. How to zero out array in O(1)?)

Answer 2

Since we have no idea what the context is, we can't narrow down the specific thing you should do is, but the options that occur to me immediately are...

1: If the counters have distinct meanings beyond "counter1, counter2, counter3," then they could be static class variables (with more useful names).

   public class Counter {
       static Counter counter1 = new Counter();
       ...
       public void resetCounters() {
         counter1.clear();
         counter2.clear();
          ...
        }
      }

2: If you just want several distinct counters, and they have no particular meaning by themselves, and you know that there will only ever be five of them, then you should use an array:

public class Counter {
  public static void main(String[] args) {
    Counter[] counters = {new Counter(), new Counter(), new Counter(), new Counter(), new Counter()};
    ...
  }
  static void resetCounters(Counter[] counters) {
    for (Counter c : counters) {
      c.reset();
    }
  }
}

Or, if you're planning to have an arbitrary number of them, you might try one of the fancier factory patterns. It really depends on what the context is, what you're actually trying to do, and what the point of the exercise is.

Answer 3

Since you're working with a large number of objects, you would be well served placing them in some sort of collection, like an ArrayList.

List<Counter> counters = new ArrayList<Counter>();

Insert all of your counters into there using the .add() method. Then, you can author your resetCounters() method in this manner:

public static void resetCounters(List<Counter> counters) {
    for(Counter c: counters) {
        // perform some action to reset the counters, as described by you
    }
}

Answer 4

The easiest and elegant way of achieving what you want is keeping a reference to all created objects somewhere, in a factory for example and resetting them when needed.

public class CounterFactory{
      private List<Counter> counters = new ArrayList<Counter>();

      public Counter createCounter(){
          Counter c = new Counter();
          counters.add(c);
          return c;
      }
      public void resetCounters(){
          for(Counter c : counters) c.setNumber(new Random());
      }
}

And in the main method, use it this way:

public static void main(String[] args) 
{
    CounterFactory f = new CounterFactory();
    Counter counter1 = f.createCounter();
    Counter counter2 = f.createCounter();
    Counter counter3 = f.createCounter();
    Counter counter4 = f.createCounter();
    Counter counter5 = f.createCounter();

    // Reset all counters
    f.resetCounters();
}

Answer 5

1. First of all there is not need to Initialize a Random nos as an instance variable,just have a Object Reference Varaible, as you are already initializing it in the Constructor.

eg:

Random number;

2. Create an ArrayList and store all the Counter objects.

ArrayList<Counter> arr = new ArrayList<Counter>();

3. Add each counter object in to the ArrayList.

4. Make reset function Non-static..there is no need for it to be static.

5. Iterate and reset...

for (Counter c : arr){

      c.reset();
    }

6. In reset() do the following..

public void reset(){

         this.number = 0;

     }