Kettenbruch

 public double werteRekursivAus() {
    return werteRekursivAus(werte.length);
    }
  
    private double werteRekursivAus(int k) {
    double erg=0;
    if(k>0) {
        erg=(1/werteRekursivAus(k-1))+werte[werte.length-k];
        }
    if(k==0) {
        erg=(1/erg)+werte[k];
    }
    return erg;
    }

public class Kettenbruch {

    // die lineare Darstellung des Kettenbruchs
    private int[] werte;

    /**
    * erzeugt einen Kettenbruch aus der linearen Darstellung
    * @param werte
    */
    public Kettenbruch(int[] werte) {
        this.werte = werte;
    }
  
    /**
    * berechnet rekursiv den Wert des Kettenbruchs
    * @return den rekursiv berechneten Wert des Kettenbruchs, bei fehlenden Werten 0
    */
    public double werteRekursivAus() {
        return this.werteRekursivAus(werte.length);
    }
  
    /**
    * berechnet iterativ den Wert des Kettenbruchs
    * @return den iterativ berechneten Wert des Kettenbruchs, bei fehlenden Werten 0
    */
    public double werteIterativAus() {
        if(werte.length!=0) {
        double ergebnis=werte[werte.length-1];
      
        for(int i=werte.length-2;i>=0;i--) {
            ergebnis=1/ergebnis+werte[i];
            }
        return ergebnis;
        }
        return 0;
    }
  
    /**
    * approximiert den Wert der Quadratwurzel von 2 mit Hilfe der Kettenbruchdarstellung mit n Elementen
    * @param n die Anzahl der fuer die Approximation verwendeten Elemente
    * @return der approximierte Wert von Wurzel 2
    */
    public static double approximiereWurzel2(int n) {
        // TODO
      
        int[]laenge=new int[n];
        Kettenbruch aproxE=new Kettenbruch(laenge);
      
        aproxE.setWert(aproxE.berechneWurzel2Folge(n));
        return aproxE.werteIterativAus();
    }

    /**
    * approximiert den Wert der eulerschen Zahl mit Hilfe der Kettenbruchdarstellung mit n Elementen
    * @param n die Anzahl der fuer die Approximation verwendeten Elemente
    * @return der approximierte Wert fuer die eulersche Zahl
    */
    public static double approximiereE(int n) {
        // TODO
        int[]laenge=new int[n];
        Kettenbruch aproxE=new Kettenbruch(laenge);
      
        aproxE.setWert(aproxE.berechneEFolge(n));
        return aproxE.werteIterativAus();
        }

    /**
    * berechnet die Folge fuer die Kettenbruch-Darstellung der Quadratwurzel von 2 mit den ersten n Elementen
    * @param n die Anzahl der Elemente
    * @return die Folge als Array, bei n <= 0 ein leeres Array
    */
    public static int[] berechneWurzel2Folge(int n) {
        // TODO
        int[] rueck=new int[n];
        rueck[0]=1;
        for(int i=1;i<n;i++) {
            rueck[i]=2;
        }
        return rueck;
    }
  
    /**
    * berechnet die Folge fuer die Kettenbruch-Darstellung der eulerschen Zahl mit den ersten n Elementen
    * @param n die Anzahl der Elemente
    * @return die Folge als Array,  bei n <= 0 ein leeres Array
    */
    public static int[] berechneEFolge(int n) {
        // TODO
        int[] rueck=new int[n];
        int e=2;
        rueck[0]=2;
      
        if (n>1) {
            for(int i=1;i<n;i++) {
            if((i+1)%3==0) {
                rueck[i]=e;
                e+=2;
            }
            else {
                rueck[i]=1;
            }
            }
        }
        return rueck;
    }
  
    private double werteRekursivAus(int k) {
        double erg=0;  
      
        if(k<=0) {
        return 0;
        }
      
        if(k>0) {
        erg=(1/this.werteRekursivAus(k-1))+werte[werte.length-k];
            }
        if(k==1 && erg!=0) {
        erg=(1/erg)+werte[werte.length-1];
        }
        return erg;
    }
  
    public void setWert (int[] array) {
        this.werte=array;
    }
  
    public int[] getWert() {
        return this.werte;
    }

}