Wie würdet ihr diese Java Aufgabe lösen?

Angabe:

(Ich habe selber einen Code geschrieben, aber da es hier in Zeichenlimit gibt, kann ich nicht alles einfügen)

1. Definiere eine Klasse 

2. Team

3. , die folgende Eigenschaften einer Sportmannschaft verwaltet. In Klammern stehen die Variablennamen, die du für die Attribute verwenden sollst.

Teamname (name)
Gespielte Spiele (games)
Siege (wins)
Unentschieden (draws)
Niederlagen (losses)
Tore erzielt (goals)
Gegentore (goalsAgainst)
Punkte (points)

Diese Daten sind notwendig, um eine vollständige Zeile einer Meisterschaftstabelle für ein Team auszugeben.

Erzeuge eine Programmklasse namens 

Sew2UeTeam

 und initialisiere in der 

main()

-Methode vier unterschiedliche Team-Objekte und lege die Teamnamen fest.

Schreibe danach die Methode

static void playGame(Team a, Team b, int toreA, int toreB)

Diese Methode dient dazu, EIN Bewerbsspiel von zwei Mannschaften zu erfassen und auszuwerten. Die beiden Mannschaften werden als Team-Objekte übergeben, zusätzlich werden die von jeder Mannschaft in diesem Spiel geschossenen Tore an die Methode übergeben.

Die jeweils erzielten Tore entscheiden über den Ausgang des Spieles (Sieg 1 – Unentschieden – Sieg 2). Eine Mannschaft bekommt für einen Sieg 3 Punkte, für ein Unentschieden 1 Punkt, und keinen Punkt für eine Niederlage.

Die Methode soll alle relevanten Daten in den beiden Teamobjekten aktualisieren (Anzahl Spiele, Anzahl Siege/Unentschieden/Niederlagen, Tore erzielt/erhalten, Punkte).

Lass danach jedes Team gegen jedes andere „spielen“, indem Du (vielleicht mit Zufallszahlen für die Tore) die Methode 

playGame(…)

 für alle möglichen Spielpaarungen aufrufst.

Als Abschluss gib für alle Teams die Daten als Tabellenzeile (unsortiert) aus.

Answer 1

[xxxcyberxxx]

Wie würdet ihr diese Java Aufgabe lösen?

Ich würde hingehen und die Punkte eben von oben nach unten abarbeiten. Ist doch genau beschrieben, was du tun sollst und wie die Klassen aussehen sollen

Die Grundlagen dazu wirst du ja schon gelernt haben, wenn du alles anwenden sollst. Wenn du dir unsicher bist, schau dir das einfach erneut an ...

Woher ich das weiß: Studium / Ausbildung – Abgeschlossenes Studium der Informatik (B.Sc.)

Comments

[leKAzz203]

public class Sew2UeTeam {
    public static void main(String[] args) {
        Team team1 = new Team();
        team1.name = "One";
        Team team2 = new Team();
        team2.name = "Two";
        Team team3 = new Team();
        team3.name = "Three";
        Team team4 = new Team();
        team4.name = "Four";

        playGame(team1, team2, team1.goales, team1.goolsAgainst);
        playGame(team3, team4, team3.goales, team3.goolsAgainst);
        System.out.printf("Die Mannschaft '%s' hat bei %s Spiel(e): %s Sieg(e), %s Unentschieden, %s Niederlage(n) und hat %s Tore erzielt, %s Gegentore gehabt und somit %s Punkte erreicht%n", team1.name, team1.games, team1.wins, team1.draws, team1.losses, team1.goales, team1.goolsAgainst, team1.points);
        System.out.printf("Die Mannschaft '%s' hat bei %s Spiel(e): %s Sieg(e), %s Unentschieden, %s Niederlage(n) und hat %s Tore erzielt, %s Gegentore gehabt und somit %s Punkte erreicht%n", team2.name, team2.games, team2.wins, team2.draws, team2.losses, team2.goales, team2.goolsAgainst, team2.points);
        System.out.printf("Die Mannschaft '%s' hat bei %s Spiel(e): %s Sieg(e), %s Unentschieden, %s Niederlage(n) und hat %s Tore erzielt, %s Gegentore gehabt und somit %s Punkte erreicht%n", team3.name, team3.games, team3.wins, team3.draws, team3.losses, team3.goales, team3.goolsAgainst, team3.points);
        System.out.printf("Die Mannschaft '%s' hat bei %s Spiel(e): %s Sieg(e), %s Unentschieden, %s Niederlage(n) und hat %s Tore erzielt, %s Gegentore gehabt und somit %s Punkte erreicht%n", team4.name, team4.games, team4.wins, team4.draws, team4.losses, team4.goales, team4.goolsAgainst, team4.points);

    }

    static void playGame(Team a, Team b, int toreA, int toreB) {
        a.games = 0;
        b.games = 0;
        int max2 = 1 + (int) (Math.random() * (5 - 1 + 1));
        while (a.games < max2) {
            int min = 0;
            int max = 15;
            a.goales = toreA;
            b.goales = toreB;
            a.goales = min + (int) (Math.random() * (max - min + 1));
            b.goales = min + (int) (Math.random() * (max - min + 1));
            b.goolsAgainst = a.goales;
            a.goolsAgainst = b.goales;
            if (a.goales > b.goales) {
                a.points += 3;
                a.wins++;
                b.losses++;
            }
            if (b.goales > a.goales) {
                b.points += 3;
                b.wins++;
                a.losses++;
            } else if (a.goales == b.goales) {
                a.points += 1;
                b.points += 1;
                a.draws++;
                b.draws++;
            }
            a.games++;
            b.games++;
        }
    }
}

[xxxcyberxxx]

@leKAzz203

Ich bin mir nicht sicher, ob es 100% richtig ist, da ich mir das selber beibringe

        Team team1 = new Team();
        team1.name = "One";
        Team team2 = new Team();
        team2.name = "Two";
        Team team3 = new Team();
        team3.name = "Three";
        Team team4 = new Team();
        team4.name = "Four";

Hier würde es sich eher anbieten, einen Konstruktor zu nutzen statt direkt auf die Variablen zuzugreifen. Das gilt als schlechter Stil.

playGame(team1, team2, team1.goales, team1.goolsAgainst);
playGame(team3, team4, team3.goales, team3.goolsAgainst);

Die Zahlen sollen die Tore im aktuellen Spiel sein, nicht die Totalanzahl an Toren ... Also nein, du sollst nicht die Objekt-Attribute goals und goalsAgainst nutzen ...

a.games = 0;
b.games = 0;

warum setzt du die Gesamtanzahl der Spiele am Anfang eines neuen Spiels auf 0? Macht keinen Sinn

a.goales = toreA;
b.goales = toreB;

macht auch keinen Sinn. Da du die Ziele der Klasse als Tore übergibst, ändert das gar nicht den Wert ...

a.goales = min + (int) (Math.random() * (max - min + 1));
b.goales = min + (int) (Math.random() * (max - min + 1));

Aha ... jetzt setzt du die Gesamtzahl der Tore zufällig fest?

b.goolsAgainst = a.goales;
a.goolsAgainst = b.goales;

und setzt dann die Anzahl der erhaltenen Tore auf die Anzahl der geschossenen?

Die ganze Funktion "playGame" kannst du in die Tonne kloppen.

public class Team {
    String name;
    int games;
    int wins;
    int draws;
    int losses;
    int goales;
    int goolsAgainst;
    int points;

}

das definiert zwar die Klasse, aber als guter Stil gilt es, wenn die Variablen privat sind und nicht von außen gelesen und verändert werden können. Du solltest dafür dann Getter und Setter programmieren.

Zudem kannst du über einen Konstruktor auch schon Werte für die Attribute übergeben und im Objekt speichern ...

Manche der Attribute hast du übrigens auch falsch geschrieben.

[leKAzz203]

@xxxcyberxxx

Erstmal danke für deine Antwort .

Hier würde es sich eher anbieten, einen Konstruktor zu nutzen statt direkt auf die Variablen zuzugreifen. Das gilt als schlechter Stil.

Konstruktor sollen wir bei dieser Übung noch nicht verwenden.

Die Zahlen sollen die Tore im aktuellen Spiel sein, nicht die Totalanzahl an Toren ... Also nein, du sollst nicht die Objekt-Attribute goals und goalsAgainst nutzen ...

Also es gibt EIN Spiel und die Tore von Team A und Team B im aktuellen Spiel sollen ausgegeben werden, oder ? Aber die Gegentore des Teams A sind doch gleichzeitig die Tore die Team B erzielt hat, oder nicht ?

Aha ... jetzt setzt du die Gesamtzahl der Tore zufällig fest?

in der Angabe steht, dass man die Toranzahl zufällig bestimmen soll ...

Die ganze Funktion "playGame" kannst du in die Tonne kloppen.

Wie würde es deiner Meinung nach besser gehen ?

[xxxcyberxxx]

@leKAzz203

Also es gibt EIN Spiel und die Tore von Team A und Team B im aktuellen Spiel sollen ausgegeben werden, oder ?

Na ja, es soll entsprechend aktualisiert werden.

Das bedeutet nicht, dass du die AKTUELLE GESAMT-TORZAHL nimmst und der Methode übergibst, sondern die Tore, die in diesem Spiel erzielt werden ... Diese addierst du auf das entsprechende Attribut drauf ...

Aber die Gegentore des Teams A sind doch gleichzeitig die Tore die Team B erzielt hat, oder nicht ?

In diesem einen Spiel, ja. Du setzt aber die Gesamt-Torzahl gleich ...

in der Angabe steht, dass man die Toranzahl zufällig bestimmen soll ...

ja, aber nicht in der Methode selbst, sondern beim Aufruf ...

Wie würde es deiner Meinung nach besser gehen ?

halte dich genau an die Anweisungen:

Diese Methode dient dazu, EIN Bewerbsspiel von zwei Mannschaften zu erfassen und auszuwerten. Die beiden Mannschaften werden als Team-Objekte übergeben, zusätzlich werden die von jeder Mannschaft in diesem Spiel geschossenen Tore an die Methode übergeben.

Die jeweils erzielten Tore entscheiden über den Ausgang des Spieles (Sieg 1 – Unentschieden – Sieg 2). Eine Mannschaft bekommt für einen Sieg 3 Punkte, für ein Unentschieden 1 Punkt, und keinen Punkt für eine Niederlage.

Die Methode soll alle relevanten Daten in den beiden Teamobjekten aktualisieren (Anzahl Spiele, Anzahl Siege/Unentschieden/Niederlagen, Tore erzielt/erhalten, Punkte).

Du addierst also die übergebenen Tore auf die Gesamttorzahlen in den Objekten und passt die Punkte entsprechend der Tore an ...

Die ganze Schleife kannst du ignorieren und auch Zufallszahlen musst du in der Methode nicht nutzen ... Du musst nur die übergebenen Werte und Objekte nutzen und anwenden

[leKAzz203]

@xxxcyberxxx

Auf welches Attribut soll das drauf addiert werden? goals?

[xxxcyberxxx]

@leKAzz203

Auf welches Attribut soll das drauf addiert werden? goals?

ja ... die Tore werden auf goals und goalsAgainst addiert, nicht überschrieben

Wenn du z.B. in der Klasse "Team" die Methoden "increaseGoals" und "increaseGoalsAgainst" hast, die einen (positiven) Integer entgegennehmen und das entsprechende Attribut anpassen, kannst du das z.B. so nutzen:

static void playGame(Team a, Team b, int toreA, int toreB) {
  // erhöhe Anzahl Spiele
  // ...

  // erhöhe Tore in den Team-Objekten
  a.increaseGoals(toreA);
  b.increaseGoalsAgainst(toreA);
  b.increaseGoals(toreB);
  a.increaseGoalsAgainst(toreB);

  // erhöhe die Anzahl der Siege / Niederlagen
  // ..
}

entsprechend übergibst du dann beim Aufruf nicht die Attribute, die im Objekt gespeichert sind, sondern "echte" Werte ...

z.B.

playGame(team1, team2, 0, 3);

[leKAzz203]

@xxxcyberxxx

Aha okay... In der Angabe stand halt, dass man die Tore zufällig ermitteln soll...

[leKAzz203]

@xxxcyberxxx

Ah ich habe deine Bearbeitung jetzt erst gelesen! okay danke!

[xxxcyberxxx]

@leKAzz203

Aha okay... In der Angabe stand halt, dass man die Tore zufällig ermitteln soll...

Nein. In der Aufgabe steht, dass du diese zufällig ermitteln KANNST, nicht musst ...

Du könntest also durchaus hingehen und z.B. sagen:

playGame(team1, team2, 0, 3);
playGame(team1, team3, 1, 1);
playGame(team2, team2, 2, 1);
...

Natürlich kannst du hier Zufallszahlen nutzen. ich nutze hier jetzt einfach mal "randA" und "randB" als Platzhalter für die Zufallszahl, die du bei jedem Aufruf erneut erstellen lässt

playGame(team1, team2, randA, randB);
playGame(team1, team3, randA, randB);
playGame(team2, team2, randA, randB);
...

[leKAzz203]

@xxxcyberxxx

Aso.... Also zusammengefasst: Es gibt ein Spiel, und die Toranzahl wird schon in der Methode übergeben. Die Tore entscheiden dann, wie das Spiel endet... Da bekommt man entsprechend die Punkte. Und in der Methode werden  Anzahl Spiele, Anzahl Siege/Unentschieden/Niederlagen, Tore erzielt/erhalten, Punkte aktualisiert und dann ausgegeben (Wieso muss man die Tore a, aktualisieren, wenn diese in der Methode eh übergeben werden, und sich dementsprechend nicht ändern?, und die Anzahl der Spiele bleibt ja auch immer nur 1)

[leKAzz203]

@xxxcyberxxx

Und was ist denn mit "Als Abschluss gib für alle Teams die Daten als Tabellenzeile (unsortiert) aus." Tabellenzeile gemeint ?

[xxxcyberxxx]

@leKAzz203

Es gibt ein Spiel,

Nein, es gibt insgesamt mehrere Spiele ...

und die Toranzahl wird schon in der Methode übergeben.

Jup, die Anzahl der Tore wird beim Aufruf mitgegeben ...

Die Tore entscheiden dann, wie das Spiel endet... Da bekommt man entsprechend die Punkte.

Und in der Methode werden Anzahl Spiele, Anzahl Siege/Unentschieden/Niederlagen, Tore erzielt/erhalten, Punkte aktualisiert

Ja

und dann ausgegeben

Nein, es steht nirgends, dass in der Mehode "playGame" die Punkte ausgegeben werden müssen ...

Nur als Abschluss des ganzen Programms ...

(Wieso muss man die Tore a, aktualisieren, wenn diese in der Methode eh übergeben werden, und sich dementsprechend nicht ändern?,

Weil es nicht nur ein Spiel gibt und ein Team somit eine Summe von Toren schießt und empfängt ...

und die Anzahl der Spiele bleibt ja auch immer nur 1)

Weil es nicht nur bei einem einzelnen Spiel bleibt ...

Und was ist denn mit "Als Abschluss gib für alle Teams die Daten als Tabellenzeile (unsortiert) aus." Tabellenzeile gemeint ?

Nachdem du alle Teams gegeneinander spielen lassen hast, gibst du eben die Daten, die in den einzelnen Teams gespeichert sind, nacheinander aus ...

Also Anzahl Spiele, Anzahl Tore, Anzahl Gegentore, Anzahl Siege usw ...

Hierfür bietet es sich an, dass du in der Klasse "Teams" noch eine Methode erstellst, die alle wichtigen Daten auf der Konsole ausgibt...

[leKAzz203]

@xxxcyberxxx

Weil es nicht nur ein Spiel gibt und ein Team somit eine Summe von Toren schießt und empfängt ...

Das sind dann die goals Attribute, die man drauf addieren soll, oder?

Nein, es gibt insgesamt mehrere Spiele ...

Logischerweise würde jedes Team 3 Spiele haben, oder

Und ja jetzt verstehe ich es. Großen Dank! Ich habe ja die Angabe komplett falsch verstanden

[xxxcyberxxx]

@leKAzz203

Das sind dann die goals Attribute, die man drauf addieren soll, oder?

Ja. Die geschossenen Tore eines Teams addierst du auf goals, die erhaltenen Tore auf goalsAgainst ...

Logischerweise würde jedes Team 3 Spiele haben, oder

bie vier Teams und jeweils nur einem einzelnen Spiel zwischen jedem Team ja ...

[leKAzz203]

@xxxcyberxxx

Wie würdest du denn die Anzahl der Spiele festlegen?

[leKAzz203]

@leKAzz203

Blödsinn! Ich habe es schon! Danke, danke und nochmal danke! Bekommst den Stern. Schönen Tag noch:)

[leKAzz203]

@leKAzz203

Die Aufgabe war so einfach. Ich habe aber echt dumm und kompliziert gedacht haha

[leKAzz203]

public class Team {
    String name;
    int games;
    int wins;
    int draws;
    int losses;
    int goales;
    int goolsAgainst;
    int points;

}

[leKAzz203]

Ich bin mir nicht sicher, ob es 100% richtig ist, da ich mir das selber beibringe

Answer 2

[HugeGameArtGD]

ungefähr so

class Team {
  // random Variablen
  var Teamname (name)
  var Gespielte Spiele (games)
  var Siege (wins)
  var Unentschieden (draws)
  var Niederlagen (losses)
  var Tore erzielt (goals)
  var Gegentore (goalsAgainst)
  var Punkte (points)

  function playGame(randomVariablen...) {
    //todo
  }

}

Woher ich das weiß: Recherche

Comments

[leKAzz203]

Ist mit EIN Bewerbsspiel in der Angabe gemeint, dass die Anzahl der Spiele 1 ist ?

[HugeGameArtGD]

@leKAzz203

Da die Methode statisch ist, wahrscheinlich nur 1 Spiel insgesamt (Alternative wäre 1 Spiel pro Methodenaufruf)

[leKAzz203]

@HugeGameArtGD

Ok danke :)