Java Fibonacci Zahlen (rekursiv) berechnen

import java.util.*;
import java.lang.Math;

public class JavaApplication {
    private static Scanner input = new Scanner(System.in);

    public static void main(String[] args) {
      
        // 
        // Fibonacci Zahlen sind so definiert:
        // F_{0} = 0, F_{1} = 1 und F_{n} = F_{n-1} + F_{n-2} für n > 1
        // 
        // Ausgehend von einem Start bei 0 und 1 lauten die ersten zwölf Werte der Folge 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89.
        // Die Variablen prevnumber und number werden für die zwei Startwerte F_{0} und F_{1} deklariert. Zu Beginn werden sie mit den Werten 0 beziehungsweise 1 initialisiert.
        int prevnumber;
        
        prevnumber = 0;
        int number;
        
        number = 1;
        
        // Die Variable size bezeichnet die n-te Fibonacci Zahl, bis zu der die Ausgabe der Fibonacci Zahlen erfolgen soll.
        int size;
        
        System.out.println("Bitte geben Sie eine Zahl zwischen 2 und 93 ein");
        size = input.nextInt();
        
        // Damit die Fibonacci Zahlen nicht zu groß werden, ist hier eine Begrenzung bei 93 eingefügt worden. In der while Schleife wird geprüft, ob die Zahl kleiner gleich 93 ist und ob sie größer als 0 ist. Da nur positive ganze Zahlen als Eingabe möglich sind.
        while (size > 93 || size < 0) {
            System.out.println("Bitte geben Sie eine Zahl zwischen 2 und 93 ein");
            size = input.nextInt();
        }
        
        // Die Fibonacci Zahlen werden rekursiv mithilfe der Funktion Fibonacci berechnet.
        System.out.println(prevnumber);
        System.out.println(number);
        
        // Die Fibonacci Zahlen werden rekursiv mithilfe der Funktion Fibonacci berechnet.
        fibonacci(prevnumber, number, size, 1);
    }
    
    public static void fibonacci(int prevNumber, int number, int size, int i) {
        // Die Variable nextnumber wird für nächste Fibonacci Zahl deklariert.
        int nextnumber;
        
        // Da die Zählung der Fibonacci Zahlen bei 0 beginnt, d.h. mit F_{0} = 0, wird in der Fallunterscheidung size -1 verwendet, um die Zahl an den Indexwert anzupassen. So hat die zwölft Fibonacci Zahl, die 89, den Indexwert elf, also F_{11} = 89.
        if (i < size - 1) {
            
            // Solange wie der Wert von der Variablen i kleiner als der Wert der Variablen size - 1 ist, wird einer neuer Wert für die Variable nextnumber berechnet. Dazu wird die Summe aus prevnumber und number gebildet.
            nextnumber = prevNumber + number;
            
            // Der Variablen prevnumber wird der Wert der Variablen number zugewiesen, und dieser wird der Wert von nextnumber zugewiesen.
            prevNumber = number;
            number = nextnumber;
            
            // Der aktuelle Wert der Variablen nextnumber wird ausgegeben.
            System.out.println(nextnumber);
            
            // Die Variable i wird um 1 erhöht.
            i = i + 1;
            
            // Nun wird die Funktion Fibonacci mit den neuen Werten erneut aufgerufen.
            fibonacci(prevNumber, number, size, i);
        }
    }
}