Aufgabe 2.1
===========

public class Counter {

  // FELDER
  long value;

  // KONSTRUKTOREN
  public Counter() {
    value = 1;
  }

  public Counter(long initialValue) {
    value = initialValue;
  }

  // METHODEN
  public long getValue() {
    return value;
  }

  public void incr() {
    value++;
  }

  public void copyValueFrom(Counter ctr) {
    value = ctr.getValue();
  }

  public Counter makeClone() {
    return new Counter(value);
  }

}


Den Unterschied zwischen

  c1 = c2;

einerseits und

  c1 = c2.makeClone();

bzw.

  c1.copyValueFrom(c2);

andererseits sieht man am einfachsten, wenn man nach der jeweiligen
Anweisung c1 verändert. Im ersten Fall verändert sich auch c2 (da
c1 und c2 jetzt auf das gleiche Objekt zeigen), im zweiten und dritten
Fall nicht:

  c1 = new Counter(10);
  c2 = new Counter(20);
  c1 = c2;  // c1 zeigt auf das gleiche Objekt wie c2.
  c1.incr();
  System.out.println(c2.getValue()); // liefert 21

  c1 = new Counter(10);
  c2 = new Counter(20);
  c1 = c2.makeClone(); // c1 zeigt auf neues Objekt.
  c1.incr();
  System.out.println(c2.getValue()); // liefert 20

  c1 = new Counter(10);
  c2 = new Counter(20);
  c1.copyValueFrom(c2); // c1 zeigt auf das gleiche Objekt wie vorher.
  c1.incr();
  System.out.println(c2.getValue()); // liefert 20

Einen Unterschied zwischen der zweiten und der dritten Anweisung
sieht man, wenn c1 vorher auf das gleiche Objekt zeigt wie eine dritte
Variable c3. Im zweiten Fall zeigt c1 nach der Anweisung auf ein
neues Objekt, während c3 unverändert bleibt. Im dritten Fall zeigen c1
und c3 weiterhin auf das gleiche Objekt; die Änderung des Wertes von
c1 betrifft also auch c3.

  c1 = new Counter(10);
  c2 = new Counter(20);
  c3 = c1;
  c1 = c2.makeClone(); // c1 zeigt auf neues Objekt, c3 bleibt unverändert.
  System.out.println(c3.getValue()); // liefert 10

  c1 = new Counter(10);
  c2 = new Counter(20);
  c3 = c1;
  c1.copyValueFrom(c2); // c1 und c3 zeigen weiter auf das gleiche Objekt.
  System.out.println(c3.getValue()); // liefert 20

Ein weiterer Unterschied zwischen der zweiten und der dritten Anweisung
besteht darin, daß die zweite Anweisung auch dann zulässig ist, wenn
c1 nicht initialisiert ist oder den Wert null besitzt, während die
dritte Anweisung nur ausgeführt werden kann, wenn c1 bereits auf ein
Counter-Objekt zeigt.



Aufgabe 2.2
===========

public class HierCounter {

  // FELDER
  long[] values;

  // KONSTRUKTOREN
  public HierCounter() {
    values = new long[] {0, 0, 0, 0, 0};
  }

  // METHODEN
  public long getValue(int i) {
    if (1 <= i && i <= 5) {
      return values[i-1];
    } else {
      return 0;
      // Hier sollte eigentlich eine Exception geworfen werden.
      // Exceptions waren aber zu diesem Zeitpunkt in der Vorlesung
      // noch nicht besprochen worden.
    }
  }

  public void incr(int i) {
    int j;
    if (1 <= i && i <= 5) {
      values[i-1]++;
      for (j = i+1 ; j <= 5 ; j++) {
        values[j-1] = 0;
      }
    } else {
      /* do nothing */
      // Hier sollte eigentlich eine Exception geworfen werden.
      // Exceptions waren aber zu diesem Zeitpunkt in der Vorlesung
      // noch nicht besprochen worden.
    }
  }

}