Java-Hamster1_Inspiration und Hilfestellung zu Aufgaben

Diskutiere Java-Hamster1_Inspiration und Hilfestellung zu Aufgaben im Bücher, Tutorials und Links Forum; 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,...

  1. Javinner
    Javinner Neues Mitglied
    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
     
  2. Vielleicht hilft dir dieser Java-Kurs hier weiter --> (hier klicken)
  3. Javinner
    Javinner Neues Mitglied
    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 (Text):
       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;
    }
     
  4. thecain
    thecain Aktives Mitglied
    Instanzvariablen?
    Wobei mir die Aufgabenstellung nicht ganz klar ist.
    Ist auf jeden Fall falsch.
     
  5. Javinner
    Javinner Neues Mitglied
    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 (Text):
    //---------------------------------------------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.
     
  6. thecain
    thecain Aktives Mitglied
    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.
     
  7. Javinner
    Javinner Neues Mitglied
    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
     
  8. Javinner
    Javinner Neues Mitglied
    Danach habe ich gesucht:
    Eine Möglichkeit, eine definierte Variable zu überschreiben.
    So ist es mir gelungen:
    Code (Text):
    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: 15. Aug. 2017
Die Seite wird geladen...

Java-Hamster1_Inspiration und Hilfestellung zu Aufgaben - Ähnliche Themen

Suche Hilfestellung
Suche Hilfestellung im Forum Java Basics - Anfänger-Themen
Hilfestellung zur Implementierung des Gaußsches Eliminationsverfahren
Hilfestellung zur Implementierung des Gaußsches Eliminationsverfahren im Forum Java Basics - Anfänger-Themen
Hilfestellung bei Iteratorimplementierung
Hilfestellung bei Iteratorimplementierung im Forum Java Basics - Anfänger-Themen
Hilfestellung bei einer Aufgabe
Hilfestellung bei einer Aufgabe im Forum Java Basics - Anfänger-Themen
Kreuzprodukt zweier Vektoren (Erste Java Aufgabe - Hilfestellungen und Tips erwünscht)
Kreuzprodukt zweier Vektoren (Erste Java Aufgabe - Hilfestellungen und Tips erwünscht) im Forum Java Basics - Anfänger-Themen
Thema: Java-Hamster1_Inspiration und Hilfestellung zu Aufgaben