<jupyter_start><jupyter_text>Google Colab IntegrationDie folgende Zelle können Sie überspringen, wenn Sie mit einer lokalen Installation arbeiten. Wenn Sie das Notebook auf Google-Colab ausführen, dann müssen Sie als erstes diese Zelle ausführen und danach die Seite neu laden (F5).<jupyter_code>!echo "Update environment..."
!apt update -q  &> /dev/null
!echo "Install Java..."
!apt-get install -q openjdk-11-jdk-headless &> /dev/null
!echo "Install Jupyter java kernel..."
!curl -L https://github.com/SpencerPark/IJava/releases/download/v1.3.0/ijava-1.3.0.zip -o ijava-kernel.zip &> /dev/null
!unzip -q ijava-kernel.zip -d ijava-kernel && cd ijava-kernel && python3 install.py --sys-prefix &> /dev/null
!echo "Downloading turtle jar ..."
!curl -L https://github.com/Andreas-Forster/gyminf-programmieren/raw/master/notebooks/jturtle-0.6.jar -o jturtle-0.6.jar &> /dev/null
!echo "Done."<jupyter_output><empty_output><jupyter_text>Methoden <NAME>, Departement Mathematik und Informatik, Universität Basel<jupyter_code>%jars jturtle-0.6.jar

import static ch.unibas.informatik.jturtle.TurtleCommands.*;<jupyter_output><empty_output><jupyter_text>Motivation ```javahome();clear();penDown();int lengthLegs = 100;forward(lengthLegs);turnRight(90);forward(lengthLegs);turnRight(135);forward(Math.sqrt(lengthLegs * lengthLegs + lengthLegs * lengthLegs)) ;turnRight(90);display(drawing());```* Was macht das Programm? * Intention nicht offensichtlich.* Programm ist schlecht strukturiert  Parameterlose Methoden* Lassen uns Codeblöcke benennen```javastatic void doSomething() { // Methodenkopf    statement1;    ...                     // Methodenrumpf    statmentN;}```  Aufrufen* Können beliebig oft aufgerufen werden. * Aufruf führt Anweisungsfolge aus```javadoSomething()```  Miniübung* Wandeln Sie obiges Programm (Turtle) in eine Methode um.     * Finden Sie einen guten Namen* Rufen Sie das Programm (mehrmals) auf  Wie funktionieren Methodenaufrufe?![methodcalls](images/method-calls.png)* Bei Methodenaufruf verzweigt Programm an erste Stelle von Methode und arbeitet Anweisungen ab* Nach Abarbeitung kehrt Methode zur aufrufenden Stelle zurück  Namenskonventionen* Methoden Namen sollten mit einem Verb und Kleinbuchstaben beginnen Beispiele:* ```printHeader```* ```findMaximum```* ```traverseList```  Parameter (1)> Werte, die vom Rufer an die Methode übergeben werden```javastatic void printMax(int a, int b) {      if (a > b) {         System.out.println(a);    } else {        System.out.println(b);    }}```* ```a``` und ```b``` (im Methodenkopf) sind *formale Parameter*    * Formale Parameter sind Variablen (benannte Speicherstellen)  Parameter (2)Methode kann mit entsprechenden Werten aufgerufen werden```javaint i = 5; ...printMax(11, i * 2) ```* ```11```und ```i * 2``` sind *aktuelle* Parameter    * Aktuelle Parameter sind *Werte* oder Ausdrücke  Miniübung* Schreiben Sie eine Methode die die Summe zweier Zahlen berechnet und ausgibt.* Können Sie die Werte von Variablen innerhalb der Methode verändern?    * Verändert sich dadurch der Wert der Variablen ausserhalb der Methode?* Schreiben Sie das Programm zur Zeichnung von rechtwinkligen Dreicken so um, dass es als Parameter die Seitenlänge der beiden Katheten nimmt.* Schreiben Sie eine Methode ```setPos``` welches die Turtleposition setzt und nutzen Sie diese im Programm  Funktionen> Methoden, die Ergebniswerte an den Rufer liefern```java static int max(int a, int b) {    if (a > b) {        return a;    } else {         return b;    }}```* Typ von Rückgabewert statt ```void``` in Methodenkopf* ```return``` Schlüsselwort um Wert zurückzugeben.   Funktionen (Aufruf)Funktionsaufrufe können überall stehen, wo Ausdrücke erlaubt sindBeispiele: ```java int x = max(5, 3);```     ```javaint y = System.out.println(max(5, 3));``` ```javaif (max(a, b) == a) {    System.out.println("a > b");} else {    System.out.println("b > a");}```      Miniübungen* Schreiben Sie eine Funktion, die für eine gegebene Länge der Katheten die Länge der Hypothenuse ausrechnet* Schreiben Sie das Turtle-Programm so um, dass diese Funktion genutzt wird.  Für schnelle:* Schreiben Sie eine Methode drawCircle, die einen Kreis (mit festem Radius) an einer fixen Position zeichnet.* Schreiben Sie dann eine parameterlose Methode, die die olympischen Ringe zeichnet.<jupyter_code><jupyter_output><empty_output><jupyter_text>Rekursion Methoden können andere Methoden aufrufen. * Können Methoden sich selbst aufrufen? Experiment<jupyter_code>// experiment<jupyter_output><empty_output><jupyter_text>Rekursion (2)Eine Methode ```m()``` heisst rekursiv, wenn sie sich selbst aufruft;Direkt rekursiv:```java        public void m() {         m ();     } ```Indirekt rekursiv:```java    public void m() {         n();     }    public void n() {       m();    }```  Beispiel 1: Fakultät$n! = (n - 1)! \cdot n$$1! = 1$<jupyter_code>// Implementation<jupyter_output><empty_output><jupyter_text>Beispiel 2: Fibonacci-Folge$ f_0 = 0 $ $f_1 = 1 $$f_n = f_{n-1} + f_{n - 2}$<jupyter_code>// Implementation<jupyter_output><empty_output><jupyter_text>Beispiel 3: Sierpinski-Dreieck<jupyter_code>static void drawSierpinskiRec(double length, int depth) {
    if (depth==0){
        for (int i = 0; i < 3; i++) {
            forward(length);
            turnLeft(120);
        }
    }
    else {
        drawSierpinskiRec(length/2.0 , depth-1);
        forward(length/2);
        drawSierpinskiRec(length/2.0, depth-1);
        backward(length/2);
        turnLeft(60);
        forward(length/2);
        turnRight(60);
        drawSierpinskiRec(length/2.0,depth-1);
        turnLeft(60);
        backward(length/2);
        turnRight(60);
    }
}

static void initialize() {
    clear();
    home();
    penUp();
    backward(70);
    turnRight(90);
    backward(70);
    drawTurtle(); // zeichnet Position der Turtle
    penDown();
}

static void drawSierpinski(double length, int depth) {
    initialize();
    drawSierpinskiRec(length, depth);
    display(drawing());
}
drawSierpinski(150.0, 8)<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.12456690315129516, 'fraction_numerical': 0.015014024088434252, 'mean_word_length': 4.294323144104803, 'pattern_counts': {'":': 0, '<': 31, '<?xml version=': 0, '>': 41, 'https://': 2, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 2, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '7', 'dir': 'jupyter-structured-clean-dedup', 'id': '85304', 'license': 'CC-BY-4.0', 'n_tokens_mistral': 2146, 'n_tokens_neox': 2107, 'n_words': 559, 'path': 'notebooks/Methoden.ipynb', 'repo_name': 'Andreas-Forster/gyminf-programmieren', 'size': '6076'}