Ampel bauen

Aufgabe: Mit Hilfe der Klassen aus dem „Zeichner“-Projekt zu Beginn des Schuljahres soll eine Ampel dargestellt werden, die die Schaltung einer normalen Ampel zeigt (Rot - RotGelb - Grün - Gelb - Rot).

Anschließend sollen zwei Ampeln immer abwechselnd geschaltet werden.

Verwendet werden soll eine Klasse für die eigentliche Ampel mit der Steuerung, eine Klasse für die Lampe(n) - wie bei der Digitaluhr benötigt ihr nur eine Lampenklasse, aber (hier) drei Instanzvariablen der Klasse Lampe für die drei Lampen der Ampel.

Da die Aufgabe auch dazu dienen soll, die Objektkommunikation zu üben, sollten die Lampen der Ampel als separate Klasse geschrieben werden (eine Klasse, drei Objekte), und die Ampel als zweite Klasse, die auf die Lampen zugreift.

Schließlich muss auch die Ampel-Klasse mindestens zwei Objekte erzeugen, damit eine Ampel an eine zweite Signale senden kann.

Die grafische Darstellung soll dann mit Hilfe der Klassen Kreis, Rechteck und Leinwand des „Zeichner“-Projekts erfolgen.

Euer Klassendiagramm sollte so ähnlich aussehen:

Vergleicht eure Klassen mit den eingeblendeten UML-Klassendiagrammen und ergänzt eure Klassen entsprechend.

Überlegt euch anschließend, wie ihr eine zweite Ampel zeichnen lasst, die automatisch geschaltet wird, nachdem die erste geschaltet wurde - im Anschluss soll die erste Ampel wieder das Schaltsignal erhalten.

Erstelle eine Klasse Lampe, aus der die drei Objekte rote Lampe, gelbe Lampe und grüne Lampe erzeugt werden sollen.

Grundlage für das Zeichnen sind die Klassen Leinwand, Kreis und Quadrat aus dem Projekt Zeichnung.

Die Klasse Lampe erzeugt eine „Leuchte“ (aus der Klasse Kreis) in einem „Kasten“ (aus der Klasse Quadrat).

Beide Zeichenobjekte müssen dann an die jeweils richtige Stelle positioniert werden. Da die Lampe in drei verschiedenen Farben leuchten kann, muss auch die Farbe als Attribut an den Konstruktor übergeben werden.

public class Lampe
{
    private Kreis leuchte;
    private Quadrat kasten;
    private String leuchtfarbe;
    private int xpos, ypos;
 
    public Lampe(String farbe, int x, int y)
    {
        leuchte = new Kreis();
        kasten = new Quadrat();
        leuchtfarbe = farbe;
        xpos = x; 
        ypos = y;
 
        //es wäre gut, hier den Kreis und das Quadrat unsichtbar so zu bewegen, dass diese links oben in der Ecke der Leinwand positioniert sind
        //dazu müssen die festen Startkoordinaten der Objekte im Konstruktor der Klassen Kreis und Quadrat nachgesehen werden
        //Beispiele für Bewegung:
 
        leuchte.horizontalBewegen(-startX);
        kasten.vertikalBewegen(-startY);
    }
 
    public void anschalten()
    {
        //die Lampe leuchtet in der jeweiligen Farbe 
 
    }
 
    public void ausschalten()
    {
        // die Lampe wird schwarz (oder grau) gezeichnet
    }
 
    public void anbringen(int x, int y)
    {
        // die Lampe+Kasten wird an der richtigen Stelle gezeichnet und sichtbar gemacht
 
    }
 
    public void abbauen()
    {
        // die Lampe+Kasten wird unsichtbar gemacht
    }
}    

Ermittle die zu verwendenden Methoden der Klassen Kreis und Quadrat, indem du entweder die Quelltexte liest oder in BlueJ ein Kreis- bzw. Quadrat-Objekt erzeugst, durch Inspizieren der Objekte erscheint dann eine Liste aller verfügbarer Methoden.

Die Klasse Ampel erzeugt eine Ampel, die die Ampelphasen rot - rot gelb - grün - gelb - rot anzeigt. Um die Wartezeiten einzubauen, kann die Methode warten(int ms) der Klasse Leinwand kopiert werden.

public class Ampel
{
    private Lampe rot, gelb, gruen;
 
    public Ampel()
    {
        //Lampen initialisieren
    }
 
    public void ampelRot()
    {
        //nur die rote Lampe ist an entsprechende Methode für grün und gelb und rot gelb)
    }
 
    public void ampelSchaltenRG()
    {
        //schaltet von rot über rot gelb nach grün
        //für Perfektionisten: gleicht die Phasenzeit an die Realität an
    }
 
    public void ampelSchaltenGR()
    {
        //schaltet von grün über gelb nach rot
    }
 
    public void ampelAus()
    {
        //schaltet alle Ampeln aus
    }
 
    private void warten(int ms)
    {
        try
        {
            Thread.sleep(ms);
        }
        catch (Exception e)
        {
        }
     }   
}

Mindestens zwei Ampeln werden nacheinander so geschaltet, dass die erste einen vollen Zyklus (rot bis rot) durchläuft und dann der zweiten mitteilt, dass diese nun durchschalten soll.

Dazu muss jede Ampel wissen, dass sie ein „benachbartes“ Ampelobjekt kennt und welches Objekt im Arbeitsspeicher das ist.