Digitaluhr, Hilfe !

Bitte aktiviere JavaScript!
Ja, das ist auch ein interessanter Ansatz, aber bei der Implementation ist noch ein Fehler: die Abfrage std==0 kann so nicht gehen, denn in der ersten Stunde ist std immer 0, d.h. z wird immer wieder auf 0 gesetzt. Also ein if (std == 0 && z > 36000) würde das Problem lösen können.
 
Ich hatte mich vor ein paar Jahren auch mal an so einem Beispiel ausgetobt, es OOP zu machen. Ich habe Counter verkettet, um deren Überläufe zu übertragen.
Java:
public class Counter {
    private AtomicInteger count = new AtomicInteger(0);

    public int increment() {
        return count.incrementAndGet();
    }

    public int decrement() {
        return count.decrementAndGet();
    }

    public int set(int count) {
        return this.count.getAndSet(count);
    }

    public int getCount() {
        return count.get();
    }

    @Override
    public String toString() {
        return "" + getCount();
    }
}

public class ModCounter extends Counter {

    private int mod;

    public ModCounter(int mod) {
        this.mod = mod;
    }

    @Override
    public int increment() {
        set( super.increment() % mod);
        return 0;
    }

    @Override
    public int decrement() {
        return set( ( getCount() + mod - 1 ) % mod);
    }
}

public class LinkedModCounter extends ModCounter {
    private LinkedModCounter next;

    public LinkedModCounter(final int mod, final LinkedModCounter next) {
        super(mod);
        this.next = next;
    }

    @Override
    public int increment() {
        super.increment();
        if (0 == getCount() && null != next) {
            next.increment();
        }
        return 0;
    }
}

public class Clock {

    private final LinkedModCounter hours = new LinkedModCounter(24, null);
    private final LinkedModCounter minutes = new LinkedModCounter(60, hours);
    private final LinkedModCounter seconds = new LinkedModCounter(60, minutes);

    public int getSeconds() {
        return seconds.getCount();
    }

    public int getMinutes() {
        return minutes.getCount();
    }

    public int getHours() {
        return hours.getCount();
    }

    public void tick() {
        seconds.increment();
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("Clock{");
        sb.append("seconds=")
          .append(seconds);
        sb.append(", minutes=")
          .append(minutes);
        sb.append(", hours=")
          .append(hours);
        sb.append('}');
        return sb.toString();
    }
}

public class Main {

    private final Clock clock = new Clock();

    public static void main(String[] args) {
        new Main().run();
    }

    public void run() {
        new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    Thread.sleep(TimeUnit.SECONDS.toMillis(1));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                clock.tick();
                System.out.println(clock);
            }
        }).start();
    }
}
 
Ja genau, so in der Art meinte ich das.

Ich selbst habe einen direkten Vergleich statt Modulo, da diese Operation ja unnötig ist (Es wird ja immer nur um 1 erhöht). Dafür habe ich da noch ein format-String mit dazu genommen und die toString() Methode überschrieben.

Daher sah meine OO Lösung für dieses Uhr Thema wie folgt aus:

UhrElement
Java:
package uhr;

public class UhrElement {
    int value = 0;
    int maxValue;
    UhrElement next;
    String format;

    public UhrElement(int startValue, int maxValue, String format, UhrElement next) {
        this.maxValue = maxValue;
        this.next = next;
        this.format = format == null ? "%d" : format;
        this.value = startValue;
    }

    public void increase() {
        value++;
        if (value == maxValue) {
            value=0;
            if (next != null) next.increase();
        }
    }

    @Override
    public String toString() {
        return String.format(format, value);
    }
}
Uhr:
Java:
package uhr;

public class Uhr {
    public static final int START_VALUE = 0;
    public static final int MAX_STUNDEN = 24;
    public static final int MAX_MINUTEN = 60;
    public static final int MAX_SEKUNDEN = 60;
    public static final int MAX_ZEHNTEL_SEKUNDEN = 10;
    public static final String FORMAT_SINGLE = "%d";
    public static final String FORMAT_DOUBLE_LEADING_ZERO = "%02d";
    public static final String FORMAT_DOUBLE = "%2d";

    private UhrElement stunden = new UhrElement(START_VALUE, MAX_STUNDEN, FORMAT_DOUBLE, null);
    private UhrElement minuten = new UhrElement(START_VALUE, MAX_MINUTEN, FORMAT_DOUBLE_LEADING_ZERO, stunden);
    private UhrElement sekunden = new UhrElement(START_VALUE, MAX_SEKUNDEN, FORMAT_DOUBLE_LEADING_ZERO, minuten);
    private UhrElement zehntelSekunden = new UhrElement(START_VALUE, MAX_ZEHNTEL_SEKUNDEN, FORMAT_SINGLE, sekunden);

    @Override
    public String toString() { return String.format("%s:%s:%s,%s", stunden, minuten, sekunden, zehntelSekunden); }

    public void run() {
        try {
            while (true) {
                System.out.println(this);
                Thread.sleep(100);
                zehntelSekunden.increase();
            }
        } catch (InterruptedException e) {
            System.out.println("Thread.sleep interrupted!");
            e.printStackTrace();
        }
    }

    public static void main (String[] args) {
        Uhr uhr = new Uhr();
        uhr.run();
    }
}
 
b) Abhängigkeit von Java 9
Das kann man fixen:
Java:
import java.util.function.Supplier;
public class Uhr {
  private int std;
  private int min;
  private int sek;
  private int zs;
  public void tick() {
    advance(() -> ++zs,  10, () -> zs  = 0, () -> 
    advance(() -> ++sek, 60, () -> sek = 0, () -> 
    advance(() -> ++min, 60, () -> min = 0, () -> 
    advance(() -> ++std, 24, () -> std = 0, null))));
  }
  private void advance(Supplier<Integer> incr, int cmp, Runnable rst, Runnable next) {
    if (incr.get() == cmp) {
      rst.run();
      if (next != null)
        next.run();
    }
  }
  @Override
  public String toString() {
    return String.format("%d:%02d:%02d,%d", std, min, sek, zs);
  }
  public static void main(String[] args) throws InterruptedException {
    Uhr uhr = new Uhr();
    while (true) {
      System.out.println(uhr);
      Thread.sleep(100);
      uhr.tick();
    }
  }
}
Jetzt ist das Problem: Abhängig von Java 8. :)
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben