Java-Hamster1_Inspiration und Hilfestellung zu Aufgaben

Diskutiere Java-Hamster1_Inspiration und Hilfestellung zu Aufgaben im Bücher, Tutorials und Links Bereich.
J

Javinner

Guten Tag,

wie der Titel bereits sagt, eröffne ich ein Thema, in welchem alle Aufgaben des Buches Hamster1, die ich bis zum Dato gelöst habe, besprochen werden können.
Ebenso gibt es ein Video zu jeder von mir gelösten Aufgabe, in welchem ich die Vorgehensweise beschreibe (Genau das fällt mir als Neuling sehr schwer, die Vorgehensweise zu ermitteln).
https://www.youtube.com/channel/UCJYDlnTynrS3GRJl-3HWBWA/playlists
Da ich keinen seinen Aha-Erlebnisse berauben möchte, wird der Code nur auf Anfrage per PN verschickt.

Da ich selbst ein Anfänger bin, wie er im Buche steht, wird dieser YouTube Kanal nach und nach erweitert und da viele Wege nach Rom führen, bitte ich jeden, der die Aufgaben anders gelöst hat, als ich es in der Vorgehensweise beschrieben habe, dies per PN zu mitteilen.
Erstelle gerade eine große PDF zu allen Aufgaben.

LG Javinner
 
J

Javinner

Hallo an alle.
Problembeschreibung:
Die zwei Variablen von Typ Int richtung und schritt sollen im Laufe des Programms überschrieben werden.
Wie sollte man dies in diesem Fall angehen?
Im Augenblick ist es so, dass bei jedem Funktionsaufruf die Variablen richtung und schritt mit den hinterlegten Werten 0 und 1 übergeben werden.
Wie wird man diesem Problem Herr, ohne globale Variablen einsetzen zu müssen?
Hm...


Code:
   int kehrt = 180;
    int richtung = 0;
    int schritt = 1;
   
    neuesVor(3, richtung, schritt);
    drehUm(kehrt, richtung);
    neuesVor(2, richtung, schritt);
    drehUm(kehrt, richtung);
}
void neuesVor(int i, int richtung, int schritt) {
    if(richtung == 0) {
        while(i > 0) {
            vor();
            i--;
            schritt++;   
        }
    }
    if(richtung == 2) {
        while(i > 0) {
            vor();
            i--;
            schritt--;
        }
    }
    schritt = schritt;
}
void drehUm(int grad, int richtung) {
    int i = grad / 90;
    if(richtung == 2) {
        while(i > 0) {
            linksUm();
            i--;
            richtung--;
        }
    }
    if(richtung == 0) {
        while(i > 0) {
            linksUm();
            i--;
            richtung++;
        }
    }
    richtung = richtung;
}
 
J

Javinner

Bis zum Dato habe ich es, wie in dem Buch beschrieben, mit globalen Variablen gemacht. Da ab Kapitel 16 dies nicht mehr erwünscht ist, überlege ich, wie ich dies nun meistern soll.

Ein Beispiel von dem Programm, wie ich es bis zum Dato oft angewendet habe.


Code:
//---------------------------------------------Globale Variable
int richtung = 0;
int achseX = 0;
int achseY = 0;
//----------------------------------------------------Hauptprogramm
/*
Der Hamster geht einmal im Kreis herum und bleibt in der Ursprungsstellung
wieder stehen.
*/
void main() {
    neuesVor();              //Schleifenbedingung ursprung negiert, Blickrichtung Ost
    while(!ursprung()) { //Solange Boolean ursprung negiert
        neuesLinks();      //Globale Variable richtung wird veraendert
        neuesVor();        //Globale Variablen achseX und achseY werden veraendert
    }neuesLinks();       //Blickrichtung Ost
}
/*
*-----------------------------------------------neuesVor
*/
void neuesVor() {
    /*
    Je nach dem, welchen Wert die globale Variable richtung hat,
    wird von den globalen Variablen achseY und achseX subtrahiert
    oder dazu addiert
    */
    if(richtung == 0) {
        achseX++;
        vor();
    } else if(richtung == 1) {
        achseY++;
        vor();
    } else if(richtung == 2) {
        achseX--;
        vor();
    } else {
        achseY--;
        vor();
    }
}
/*
*-----------------------------------------------neuesLinks
*/
void neuesLinks() {
    /*
    Bei jedem Aufruf wird die globale Variable richtung
    mit neuem Wert ueberschrieben
    */
    linksUm();
    richtung = (richtung + 1) % 4;
    /*
    1 mod 4 = 1 Blickrichtung Ost
    2 mod 4 = 2 Blickrichtung Nord
    3 mod 4 = 3 Blickrichtung West
    4 mod 4 = 0 Blickrichtung Sued
    */
}
boolean ursprung() {
    /*
    Die Ausgangskachel
    Wenn beide globalen Variablen den Wert Null liefern,
    ist das Programm zu Ende
    */
    return achseY == 0 && achseX == 0;
}

Nun suche ich nach der Lösung, wie ich die Variablen innerhalb des main-Programms überschreibe.
So war die Idee dahinter (meine Frage) die Variablen richtung und schritt so zu überschreiben,
damit diese beim nächsten Aufruf die neu ermittelte Werte weitergeben.
 
T

thecain

Das sind aber nicht "globale Variablen", die sind alle auf die Instanz bezogen.

Wobei auch die main eigtl falsch ist, da sie nicht static ist... wir wohl wieder irgendein "Pseude-Lern-Java-Tool" sein... da kann ich leider nicht weiterhelfen.

Aber deine Variablen sind auf jeden Fall nicht global so wie sie im Moment deklariert sind.
 
J

Javinner

Danke trotzdem! :)

Beim Editor handelt es sich um ein Hamster-Simulator und dieser
soll die Grundkonzepte der imperativen Programmierung vermitteln.
Da ich noch nie mit Programmieren zu tun hatte, entschied ich mich fürs Erste die Grundkonzepte zu verinnerlichen. Ich finde es sehr gelungen und es brachte und bringt mir wirklich viel, nur erschlägt es ein an manchen Stellen!

Wenn ich die Lösung habe, die ich nach wie vor suche, gebe ich bescheid, was ich gesucht habe :D
 
J

Javinner

Danach habe ich gesucht:
Eine Möglichkeit, eine definierte Variable zu überschreiben.
So ist es mir gelungen:
Code:
void main() {
    /*
    Variablen drehen
    */
    int links = 90;
    int kehrt = links * 2;
    int rechts = links * 3;
    /*
    Definierte Variable richtung: Wert gleich Null.
    */
    int richtung = 0;
 
    int a = drehUm(kehrt, richtung);
    /*
    Überschreiben der definierten Variable richtung.
    Diese liefert jetzt den Wert 2, siehe Variablen drehen und Prozedur drehUm
    */
    richtung = a;                                
}
int drehUm(int grad, int richtung) {
    int i = grad / 90;
    while(i > 0) {
        linksUm();
        i--;
        richtung = (richtung + 1) % 4;
        /*
        1 mod 4 = 1 Blickrichtung Ost
        2 mod 4 = 2 Blickrichtung Nord
        3 mod 4 = 3 Blickrichtung West
        4 mod 4 = 0 Blickrichtung Sued
        */
    }
    return richtung;
}
Also ist es möglich die definierten Variablen im Main-Abschnitt zu überschreiben, um dann mit jeder Prozedur darauf greifen zu können.
Gerade qualmt mein Kopf bei der Vorstellung der Fülle der jetzt gegebenen Möglichkeiten!
 
Zuletzt bearbeitet:
Thema: 

Java-Hamster1_Inspiration und Hilfestellung zu Aufgaben

Passende Stellenanzeigen aus deiner Region:
Anzeige

Neue Themen

Anzeige

Anzeige
Oben