Könnt ihr mir bei dieser Java-Aufgabe helfen?

1 Antwort

Methoden, die ohne Probleme in die Basisklasse verschoben werden können, sind zum Beispiel:

  • setzeLaenge(int laenge)
  • simuliereZeitabschnitt()
  • liefereSieger()
  • rennenDurchfuehren()

Diese Methoden sind unabhängig von der konkreten Implementierung der Rennbahn und könnten daher in der abstrakten Basisklasse definiert werden.

Es gibt allerdings auch Methoden, bei denen es Probleme geben könnte, wenn sie in der Basisklasse definiert werden. Zum Beispiel:

  • setzeAufSpur(Rennauto auto)
  • entferne(Rennauto auto)
  • istRennbahnBesetzt()

Diese Methoden hängen sehr stark von der konkreten Implementierung der Rennbahn ab und könnten daher Schwierigkeiten bereiten, wenn sie in der Basisklasse definiert werden. Zum Beispiel könnte die Implementierung einer Rennbahn mit nur einer Spur anders sein als die Implementierung einer Rennbahn mit mehreren Spuren. Es könnte daher schwierig sein, eine allgemeine Methode für die Verwaltung von Autos auf der Rennbahn zu definieren, die für alle Implementierungen geeignet ist.

Es ist daher wichtig, bei der Entwicklung von abstrakten Klassen genau abzuwägen, welche Methoden unabhängig von der konkreten Implementierung sind und welche nicht. In diesem Fall könnten die Methoden setzeAufSpur und entferne in der abstrakten Klasse nur als leere Methoden definiert werden, die in den konkreten Implementierungen überschrieben werden müssen. Die Methode istRennbahnBesetzt könnte hingegen in der Basisklasse gar nicht definiert werden und muss in den konkreten Implementierungen vollständig implementiert werden.

Woher ich das weiß:Recherche
Mathematik2000 
Fragesteller
 19.12.2022, 13:41

Welche Methoden von der Klasse Rennuto Können in BasisRennbahn dabei sein?

0
RealMakrochain  19.12.2022, 13:47
@Mathematik2000

Basierend auf der gegebenen Implementierung der Klasse "Rennauto" und des Interfaces "Rennbahn" könnten in der Klasse "BasisRennbahn" folgende Methoden enthalten sein:

  1. setzeLaenge(int laenge) - Setzt die Länge der Rennbahn.
  2. setzeAufSpur(Rennauto auto) - Setzt ein Rennauto auf eine Spur, falls möglich.
  3. simuliereZeitabschnitt() - Simuliert einen Zeitabschnitt.
  4. liefereSieger() - Liefert den Sieger.
  5. rennenDurchfuehren() - Führt das Rennen durch.
  6. entferne(Rennauto auto) - Entfernt ein Rennauto von der Rennbahn.
  7. istLeer() - Prüft, ob wenigstens ein Auto auf der Rennbahn steht.

Bitte beachten Sie, dass diese Liste möglicher Methoden nur eine allgemeine Empfehlung ist und möglicherweise nicht vollständig oder genau ist. Es ist wichtig, die konkrete Implementierung der Klasse "BasisRennbahn" zu überprüfen, um sicherzustellen, welche Methoden tatsächlich enthalten sind.

0
Mathematik2000 
Fragesteller
 19.12.2022, 13:50
@RealMakrochain

Wie können wir verstehen, ob die Methoden von der konkreten Implementierung der Rennbahn abhängen oder nicht? ich kann nicht unterscheiden?

0
Mathematik2000 
Fragesteller
 19.12.2022, 13:45

Wie sieht bei diese Klasse aus?



public class DynamicArrayRennbahn implements Rennbahn
{
    Rennauto[] rennbahn;
    int streckelaenge;
    int autosAufSpur=0;


    /**
     * Initialisierung neues Array
     */
    public DynamicArrayRennbahn()
    {
        rennbahn = new Rennauto[3];
    }


    /**
     * Setzt die Laenge der Rennbahn. Typische Werte werden zwischen 100 und 1000 liegen.
     */
    @Override
    public void setzeLaenge(int laenge)
    {
        streckelaenge = laenge;
    }


    /**
     * Setzt ein Rennauto auf eine Spur, falls möglich
     * 
     * @param auto das Auto, das auf die Rennbahn gesetzt wird.  Dieses darf nicht null sein!
     * @return true, falls das Auto auf die Bahn gesetzt werden konnte. Falsch, wenn
     *         das Rennauto bereits auf der Fahrbahn ist oder keine Spur (je nach
     *         Implementierung unterschiedlich viele) mehr frei ist.
     */
    @Override
    public boolean setzeAufSpur(Rennauto auto)
    {        
        if (auto != null)
        {
            if (autosAufSpur==rennbahn.length)
            {
                rennbahn = Arrays.copyOf(rennbahn, rennbahn.length+1);
                rennbahn[rennbahn.length-1] = auto;  
                autosAufSpur++;
                return true;
            }
            
            for (int i=0; i<rennbahn.length; i++)
            {
                if (rennbahn[i] == auto && rennbahn != null)
                {
                    return false;
                }


                else if (rennbahn[i] == null)
                {
                    rennbahn[i] = auto;
                    autosAufSpur++;
                    break;
                }
            }          
        }
        else
        {
            throw new IllegalArgumentException("Auto darf nicht null sein!");
        }
        return true;
    }


    /**
     * Simuliert einen Zeitabschnitt, i.A. wird hier einfach nur
     * {@link Rennauto#fahre()} für alle am Rennen beteiligten Autos aufgerufen.
     */
    @Override
    public void simuliereZeitabschnitt()
    {
        for (int i=0; i<rennbahn.length; i++)
        {
            rennbahn[i].fahre();
        }
    }


    /**
     * Liefert den Sieger. Falls mehrere Autos im Ziel sind, gewinnt das Auto, das am weitesten gefahren ist.
     * Wenn Autos exakt gleich weit gefahren sind, gewinnt eines von beiden (welches ist nicht genauer spezifiziert).
     * 
     * @return Sieger oder null, falls es keinen Sieger gibt.
     */
    @Override
    public Rennauto liefereSieger()
    {
        Rennauto sieger = null;
        int maxStrecke=0;
        for (int i=0; i<rennbahn.length; i++)
        {
            if (rennbahn[i].getStrecke() > streckelaenge && rennbahn[i].getStrecke() >= maxStrecke)
            {
                maxStrecke = rennbahn[i].getStrecke();                
            }
        }


        for (int i=0; i<rennbahn.length; i++)
        {
            if (rennbahn[i].getStrecke() >= maxStrecke)
            {
                sieger = rennbahn[i];            
            }
        }
        return sieger;
    }


    /**
     * Führt das Rennen mittels {@link #simuliereZeitabschnitt()} und
     * {@link #liefereSieger()} durch. Die Methode gibt nichts zurück, der Sieger
     * kann über {@link #liefereSieger()} ermittelt werden.
     * 
     * @throws IllegalStateException, falls die Länge nicht gesetzt wurde oder keine
     *                                Autos auf der Rennbahn stehen.
     */
    @Override
    public void rennenDurchfuehren()
    {
        for (int i=0; i<rennbahn.length; i++)
        {
            if (streckelaenge == 0 || rennbahn[i] == null)
            {
                throw new IllegalStateException("Die Länge nicht gesetzt wurde oder keine Autos auf der Rennbahn stehen!");
            }
            else
            {
                do
                {       
                    liefereSieger();
                    simuliereZeitabschnitt();          
                }
                while (liefereSieger() == null);
            }            
        }
    }


    /**
     * Entfernt ein Rennauto von der Rennbahn und gibt die Spur wieder frei.
     * 
     * @param auto das zu entfernende Rennauto
     */
    @Override
    public void entferne(Rennauto auto)
    {
        for (int i=0; i<rennbahn.length; i++)
        {
            if (rennbahn[i]==auto)
            {
                rennbahn[i] = null;
            }
        }
    }


    /**
     * Prüft, ob wenigstens ein Auto auf der Rennbahn steht.
     * 
     * @return false, falls wenigstens ein Auto auf der Rennbahn steht, sonst true
     */
    @Override
    public boolean istLeer()
    {
        for (int i=0; i<rennbahn.length; i++)
        {
            if (rennbahn[i] != null)
            {
                return false;
            }
        }
        return true;
    }
}
0