Java-code

[Wirtschaftsinformatiker]

Das ist die Aufgabe: der Code ist die Lösung aber ich verstehe es nicht.

Implementieren Sie einen Aufzählungstyp Besitzer für die möglichen Besitzer einer Spielfeldzelle. Schreiben Sie eine neue Klasse SpielfeldZeileEnum, die statt int-Werten Referenzen auf Besitzer in den Zellen ablegt. Auch an der Schnittstelle (also den öf- fentlichen Methoden) der neuen Klasse SpielfeldZeileEnum sollen an den richtigen Stellen statt int-Werten Besitzer-Referenzen übergeben und geliefert werden.

Kann die Methoden gibBesitzer erklären?

class SpielfeldZeileEnum {
    private Besitzer _spalte0;
    private Besitzer _spalte1;
    private Besitzer _spalte2;

    /**
     * Initialisiert eine neue SpielfeldZeile
     */
    public SpielfeldZeileEnum() {
        _spalte0 = Besitzer.LEER;
        _spalte1 = Besitzer.LEER;
        _spalte2 = Besitzer.LEER;
    }

    /**
     * Gibt den Besitzer der angegebenen Spalte in dieser Zeile.
     *
     * @param spalte horizontale Position (0-2)
     * @return 0 (unbesetzt), 1 (Spieler 1), 2 (Spieler 2)
     */
    public int gibBesitzer(int spalte) {
        Besitzer besitzer;
        switch (spalte) {
            case 0:
                besitzer = _spalte0;
                break;

            case 1:
                besitzer = _spalte1;
                break;

            case 2:
                besitzer = _spalte2;
                break;

            default:
                throw new IllegalArgumentException(String.valueOf(spalte));
        }       
        int besitzer1 = gibBesitzer1(besitzer);
        return besitzer1;
    }
    
    private int gibBesitzer1(Besitzer besitzer)
    {
        int besitzer1 = 0;
        switch(besitzer)
        {
            case LEER:
                besitzer1 = 0;
                break;
            case KREUZ:
                besitzer1 = 1;
                break;
            case KREIS:
                besitzer1 = 2;
                break;
        }
        return besitzer1;
    }

    /**
     * Besetze die angegebene Spalte in dieser Zeile.
     *
     * @param spalte  horizontale Position (0-2)
     * @param spieler 0 (leer), 1 (Spieler 1), 2 (Spieler 2)
     */
    public void besetze(int spalte, int spieler) {
        Besitzer spieler1 = Besitzer.LEER;
        switch (spieler)
        {
            case 0:
                spieler1 = Besitzer.LEER;
                break;
            case 1:
                spieler1 = Besitzer.KREUZ;
                break;
            case 2:
                spieler1 = Besitzer.KREIS;
                break;
        }
        
        switch (spalte) {
            case 0:
                _spalte0 = spieler1;
                break;

            case 1:
                _spalte1 = spieler1;
                break;

            case 2:
                _spalte2 = spieler1;
                break;

            default:
                throw new IllegalArgumentException(String.valueOf(spalte));
        }
    }

    /**
     * Gibt an, ob die Zeile an allen Positionen belegt ist.
     */
    public boolean istVoll() {
        return (_spalte0 != Besitzer.LEER) && (_spalte1 != Besitzer.LEER) && (_spalte2 != Besitzer.LEER);
    }
}
class SpielfeldZeileEnum {
    private Besitzer _spalte0;
    private Besitzer _spalte1;
    private Besitzer _spalte2;

    /**
     * Initialisiert eine neue SpielfeldZeile
     */
    public SpielfeldZeileEnum() {
        _spalte0 = Besitzer.LEER;
        _spalte1 = Besitzer.LEER;
        _spalte2 = Besitzer.LEER;
    }

    /**
     * Gibt den Besitzer der angegebenen Spalte in dieser Zeile.
     *
     * @param spalte horizontale Position (0-2)
     * @return 0 (unbesetzt), 1 (Spieler 1), 2 (Spieler 2)
     */
    public int gibBesitzer(int spalte) {
        Besitzer besitzer;
        switch (spalte) {
            case 0:
                besitzer = _spalte0;
                break;

            case 1:
                besitzer = _spalte1;
                break;

            case 2:
                besitzer = _spalte2;
                break;

            default:
                throw new IllegalArgumentException(String.valueOf(spalte));
        }       
        int besitzer1 = gibBesitzer1(besitzer);
        return besitzer1;
    }
    
    private int gibBesitzer1(Besitzer besitzer)
    {
        int besitzer1 = 0;
        switch(besitzer)
        {
            case LEER:
                besitzer1 = 0;
                break;
            case KREUZ:
                besitzer1 = 1;
                break;
            case KREIS:
                besitzer1 = 2;
                break;
        }
        return besitzer1;
    }

    /**
     * Besetze die angegebene Spalte in dieser Zeile.
     *
     * @param spalte  horizontale Position (0-2)
     * @param spieler 0 (leer), 1 (Spieler 1), 2 (Spieler 2)
     */
    public void besetze(int spalte, int spieler) {
        Besitzer spieler1 = Besitzer.LEER;
        switch (spieler)
        {
            case 0:
                spieler1 = Besitzer.LEER;
                break;
            case 1:
                spieler1 = Besitzer.KREUZ;
                break;
            case 2:
                spieler1 = Besitzer.KREIS;
                break;
        }
        
        switch (spalte) {
            case 0:
                _spalte0 = spieler1;
                break;

            case 1:
                _spalte1 = spieler1;
                break;

            case 2:
                _spalte2 = spieler1;
                break;

            default:
                throw new IllegalArgumentException(String.valueOf(spalte));
        }
    }

    /**
     * Gibt an, ob die Zeile an allen Positionen belegt ist.
     */
    public boolean istVoll() {
        return (_spalte0 != Besitzer.LEER) && (_spalte1 != Besitzer.LEER) && (_spalte2 != Besitzer.LEER);
    }
}

 

[KonradN]

Was hast Du denn bei den Methoden bisher erkannt? Wo hast Du konkrete Verständnisprobleme?

Ich will Dir ja gerne helfen, aber
a) soll ich bezüglich der kleinen Beschreibung raten, was der Sinn der Methoden ist?
b) soll ich dir Erläutern, was so ein Switch Befehl macht?

zu a) Du solltest natürlich ein generelles Verständnis entwickeln, um was es da bei den Änderungen geht. Wieso wird das was geändert? Was für Konsequenzen ergeben sich daraus. Das wäre das allgemeine Verständnis.

zu b) Wenn es so einzelne Befehle gibt, die Probleme bereiten, dann solltest Du da zuerst die Dokumentation zu lesen. (Es gibt genug Seiten im Netz, die die einzelnen Java Befehle erläutern) und dann im Anschluss etwas damit "spielen", also kleine Java Programme schreiben, die eben genau diesen Java Befehl nutzen. Man lernt in erster Linie nur durch Praxis.

Wir erklären gerne - aber dazu muss klar sein, was genau erklärt werden soll. Wenn wir nicht genau sehen, wo Du Verständnisprobleme hast, können wir nicht wirklich helfen. Da würden wir hier im Forum Dinge schreiben, die man auf zig Webseiten finden kann - wo Leute mit deutlich mehr Zeitaufwand versucht haben, etwas möglichst gut zu beschreiben (Was ein kleiner Gegensatz zum Forum ist: Man setzt sich hin und schreibt in der Regel spontan eine Antwort).

 

[yfons123]

also durch nummerierung ist schrecklich für die benennung.

wenn der code zu komplex ist dann vereinfache ihn, dazu gehören auch sinnvolle bennennungen dazu

enum Besitzer{
    LEER,KREUZ,KREIS
}
class Vector2{
    public int X;
    public int Y;
    public Vector2(int x,int y) {
        X = x;
        Y = y;
    }
    public Vector2 Add(Vector2 vector) {
        this.X += vector.X;
        this.Y += vector.Y;
        return this;
    }
    public Vector2 Sub(Vector2 vector) {
        this.X -= vector.X;
        this.Y -= vector.Y;
        
        return this;
    }
}
class Feld{
    public Vector2 position;
    public Besitzer besitzer;
}

hier wäre eine Grundstruktur um ein Feld zu erzeugen vllt kannst du damit mehr anfangen.

 

[Wirtschaftsinformatiker]

Ich

Was hast Du denn bei den Methoden bisher erkannt? Wo hast Du konkrete Verständnisprobleme?

Ich will Dir ja gerne helfen, aber
a) soll ich bezüglich der kleinen Beschreibung raten, was der Sinn der Methoden ist?
b) soll ich dir Erläutern, was so ein Switch Befehl macht?

zu a) Du solltest natürlich ein generelles Verständnis entwickeln, um was es da bei den Änderungen geht. Wieso wird das was geändert? Was für Konsequenzen ergeben sich daraus. Das wäre das allgemeine Verständnis.

zu b) Wenn es so einzelne Befehle gibt, die Probleme bereiten, dann solltest Du da zuerst die Dokumentation zu lesen. (Es gibt genug Seiten im Netz, die die einzelnen Java Befehle erläutern) und dann im Anschluss etwas damit "spielen", also kleine Java Programme schreiben, die eben genau diesen Java Befehl nutzen. Man lernt in erster Linie nur durch Praxis.

Wir erklären gerne - aber dazu muss klar sein, was genau erklärt werden soll. Wenn wir nicht genau sehen, wo Du Verständnisprobleme hast, können wir nicht wirklich helfen. Da würden wir hier im Forum Dinge schreiben, die man auf zig Webseiten finden kann - wo Leute mit deutlich mehr Zeitaufwand versucht haben, etwas möglichst gut zu beschreiben (Was ein kleiner Gegensatz zum Forum ist: Man setzt sich hin und schreibt in der Regel spontan

Was hast Du denn bei den Methoden bisher erkannt? Wo hast Du konkrete Verständnisprobleme?

Ich will Dir ja gerne helfen, aber
a) soll ich bezüglich der kleinen Beschreibung raten, was der Sinn der Methoden ist?
b) soll ich dir Erläutern, was so ein Switch Befehl macht?

zu a) Du solltest natürlich ein generelles Verständnis entwickeln, um was es da bei den Änderungen geht. Wieso wird das was geändert? Was für Konsequenzen ergeben sich daraus. Das wäre das allgemeine Verständnis.

zu b) Wenn es so einzelne Befehle gibt, die Probleme bereiten, dann solltest Du da zuerst die Dokumentation zu lesen. (Es gibt genug Seiten im Netz, die die einzelnen Java Befehle erläutern) und dann im Anschluss etwas damit "spielen", also kleine Java Programme schreiben, die eben genau diesen Java Befehl nutzen. Man lernt in erster Linie nur durch Praxis.

Wir erklären gerne - aber dazu muss klar sein, was genau erklärt werden soll. Wenn wir nicht genau sehen, wo Du Verständnisprobleme hast, können wir nicht wirklich helfen. Da würden wir hier im Forum Dinge schreiben, die man auf zig Webseiten finden kann - wo Leute mit deutlich mehr Zeitaufwand versucht haben, etwas möglichst gut zu beschreiben (Was ein kleiner Gegensatz zum Forum ist: Man setzt sich hin und schreibt in der Regel spontan eine Antwort).

Ich verstehe die gibBesitzer und gibBesitzer1 nicht.

 

[Wirtschaftsinformatiker]

Was hast Du denn bei den Methoden bisher erkannt? Wo hast Du konkrete Verständnisprobleme?

Ich will Dir ja gerne helfen, aber
a) soll ich bezüglich der kleinen Beschreibung raten, was der Sinn der Methoden ist?
b) soll ich dir Erläutern, was so ein Switch Befehl macht?

zu a) Du solltest natürlich ein generelles Verständnis entwickeln, um was es da bei den Änderungen geht. Wieso wird das was geändert? Was für Konsequenzen ergeben sich daraus. Das wäre das allgemeine Verständnis.

zu b) Wenn es so einzelne Befehle gibt, die Probleme bereiten, dann solltest Du da zuerst die Dokumentation zu lesen. (Es gibt genug Seiten im Netz, die die einzelnen Java Befehle erläutern) und dann im Anschluss etwas damit "spielen", also kleine Java Programme schreiben, die eben genau diesen Java Befehl nutzen. Man lernt in erster Linie nur durch Praxis.

Wir erklären gerne - aber dazu muss klar sein, was genau erklärt werden soll. Wenn wir nicht genau sehen, wo Du Verständnisprobleme hast, können wir nicht wirklich helfen. Da würden wir hier im Forum Dinge schreiben, die man auf zig Webseiten finden kann - wo Leute mit deutlich mehr Zeitaufwand versucht haben, etwas möglichst gut zu beschreiben (Was ein kleiner Gegensatz zum Forum ist: Man setzt sich hin und schreibt in der Regel spontan eine Antwort).

Was die Methoden gib Besitzer und GibBeaitzer1 genau machen und warum ist eine private und andere public?

 

[yfons123]

Was die Methoden gib Besitzer und GibBeaitzer1 genau machen und warum ist eine private und andere public?

die public ist der einstiegs punkt von außen
die private ist eine helfer methode die miserabel benannt ist.

du übergibst die nummer ein welches feld du willst udn diese gibt dir dann ein int zurück basierend darauf wer der Besitzer ist

weil es irgendwer für richtig befunden hat Java enums wie C enums zu benutzen und das auch noch in schlechter form
Warum man dem Enum nicht gleich die Zahl zugeordnet hat weis ich nicht und es macht auch keinen Sinn das irgendwie mit switch cases zusammen zu schustern

 

[Blender3D]

Kann die Methoden gibBesitzer erklären?

Schreibe sie um dann versteht man sie besser.

import besitzerEnum.SpielfeldZeileEnum.Besitzer;

public class StartBesitzer {

    public static void main(String[] args) {
        SpielfeldZeileEnum zeile = new SpielfeldZeileEnum(3);
        zeile.besetze(Besitzer.KREIS, 0);
        zeile.besetze(Besitzer.KREUZ, 2);
        System.out.println(zeile);
        zeile.besetze(Besitzer.KREUZ, 1);
        System.out.println(zeile);
    }
}

public class SpielfeldZeileEnum {
    public enum Besitzer {
        LEER, KREUZ, KREIS
    };

    private Besitzer[] zeile;

    public SpielfeldZeileEnum(int size) {
        zeile = new Besitzer[size];
    }

    public void besetze(Besitzer b, int spalte) {
        zeile[spalte] = b;
    }

    public Besitzer gibBesitzer(int spalte) {
        return zeile[spalte];
    }

    public boolean istVoll() {
        for (Besitzer b : zeile) {
            if (b == Besitzer.LEER)
                return false;
        }
        return true;
    }

    public int size() {
        return zeile.length;
    }

    @Override
    public String toString() {
        StringBuffer tmp = new StringBuffer();
        for (int i = 0; i < size(); i++) {
            char c = '_';
            if (zeile[i] == Besitzer.KREUZ)
                c = 'x';
            else if (zeile[i] == Besitzer.KREIS)
                c = 'O';
            tmp.append(c);
        }
        return tmp.toString();
    }
}

 

[Wirtschaftsinformatiker]

Was hast Du denn bei den Methoden bisher erkannt? Wo hast Du konkrete Verständnisprobleme?

Ich will Dir ja gerne helfen, aber
a) soll ich bezüglich der kleinen Beschreibung raten, was der Sinn
b) soll ich dir Erläutern, was so ein Switch Befehl macht?

zu a) Du solltest natürlich ein generelles Verständnis entwickeln, um was es da bei den Änderungen geht. Wieso wird das was geändert? Was für Konsequenzen ergeben sich daraus. Das wäre das allgemeine Verständnis.

zu b) Wenn es so einzelne Befehle gibt, die Probleme bereiten, dann solltest Du da zuerst die Dokumentation zu lesen. (Es gibt genug Seiten im Netz, die die einzelnen Java Befehle erläutern) und dann im Anschluss etwas damit "spielen", also kleine Java Programme schreiben, die eben genau diesen Java Befehl nutzen. Man lernt in erster Linie nur durch Praxis.

Wir erklären gerne - aber dazu muss klar sein, was genau erklärt werden soll. Wenn wir nicht genau sehen, wo Du Verständnisprobleme hast, können wir nicht wirklich helfen. Da würden wir hier im Forum Dinge schreiben, die man auf zig Webseiten finden kann - wo Leute mit deutlich mehr Zeitaufwand versucht haben, etwas möglichst gut zu beschreiben (Was ein kleiner Gegensatz zum Forum ist: Man setzt sich hin und schreibt in der Regel spontan eine Antwort).

Soll 49 in Zeile 9 unbedingt aufgeschrieben wird, was passiert ohne 49 leer nur()?

 

[KonradN]

Ich nehme mal an, dass Du nun im falschen Thread antgewortet hast und die Frage nach https://www.java-forum.org/thema/java-code.200503/ gehört.

Was passiert, wenn Du da kein Argument angibst, kann ich Dir nicht sagen, da wir die Implementierung nicht kennen. Es gibt aber zwei Möglichkeiten:

a) Wenn es einen Konstruktor ohne Parameter geben sollte, dann würde dieser aufgerufen.
b) Sollte es so einen Konstruktor nicht geben, dann lässt sich der Code nicht übersetzen.