# Kapital nach n-Jahren berechnen



## Bierjunkie (15. Nov 2011)

Aufgabenstellung war folgende:



> *Schreiben Sie eine Funktion kn, die bei gegebenem K, p, r und n den Kapitalstock nach n Jahren berechnet.
> kn soll k1 verwenden.
> Ihre Funktion ist nur mit einer Spezifikation in Form eines strukturierten Kommentars vollständig!*




Möchte das Kapital für n-Jahre berechnen, bekomme aber immer den eingegeben Kapitalswert ausgegeben! Wie sieht den hier nun die korrekte Ausgabe aus?



```
package bank;
import java.util.Scanner;

/**
* Diese Klasse enthaelt statische Methoden zu diversen Zins− und Zineszins−Rechnungen.
*/

public class zins {

	/**
	* Berechnet das um den Zins und die Sparrate vermehrte Kapital nach einem Jahr.
	* @param k Startkapital
	* @param p Zinssatz
	* @param r Sparrate
	* @return  verzinste um die Sparrate erhoehtes Kapital
	*/
	
	public static double k1(double k, double p, double r){
		return k*(1+p/100)+r;
	}
	
	
/**
* Berechnet den Zins und das um die Sparrate vermehrte Kapital nach n Jahren.
* @param k Startkapital
* @param p Zinssatz
* @param r Sparrate
* @param n Zahl der Sparjahre
* @return das verzinste und um die Sparrate erhoehte Kapital 
*/

public static double kn(double k, double p, double r, int n){
		int i = 0;
		double res = k;
		while(i<n) {
		i = i + 1;
		}
		return res;	
}


public static void main(String args[]){
	Scanner rechner = new Scanner(System.in);
	double k,p,r,brechnung;
	int n;
	System.out.println("Geben sie das Kapital ein: ");
	k = rechner.nextDouble();
	System.out.println("Geben sie den Zinssatz ein: ");
	p = rechner.nextDouble();
	System.out.println("Geben sie das Sparrate ein: ");
	r = rechner.nextDouble();
	System.out.println("Länger der Vertragsdauer: ");
	n = rechner.nextInt();
	brechnung=kn(k,r,p,n);
	System.out.println("Das Ergebnis nach Jahren lautet: " +brechnung);
	
	
	}
}
```


----------



## Camill (15. Nov 2011)

Was genau wolltest du denn hiermit erreichen?

```
public static double kn(double k, double p, double r, int n){
        int i = 0;
        double res = k;
        while(i<n) {
        i = i + 1;
        }
        return res; 
}
```
Es wird ja lediglich das Kapital zurückgegeben. Für was eine while-Schleife die einfach nur hochzählt?


----------



## Bierjunkie (16. Nov 2011)

Ich hab gedacht, wenn ich den Kapitalstock für n-Jahre ausrechnen möchte, kann ich dieses mit einer While-Schleife erledigen und hab in den Hinweisen eine solche Schleife gefunden und getestet! In der Aufgabe davor musste ich ein Programm schreiben, welches den Kapitalstock von einem bzw. zwei Jahren ausrechnen sollte. Dort hatte ich lediglich eine If/Else-Anweisung getätigt und fertig war ich. Doch wie sieht es nun mit n-Jahren aus?


----------



## Camill (16. Nov 2011)

Wie sieht denn die Formel für das berechnen des Kapitals nach n Jahren aus?

Für ein Jahr sieht es laut der Methode 
	
	
	
	





```
k1
```
 folgendermaßen aus: 
	
	
	
	





```
k*(1+p/100)+r
```
Würde man das bei 2 Jahren einfach mit 2 Multiplizieren(Kenne mich mit Kapitalrechnung nicht aus deßhalb die Frage ?


----------



## Gossi (17. Nov 2011)

Camill hat gesagt.:


> Wie sieht denn die Formel für das berechnen des Kapitals nach n Jahren aus?
> 
> Für ein Jahr sieht es laut der Methode
> 
> ...



Nein, man müsste k1 immer wieder mit dem neuen Kapital aufrufen, Zinsezins sollte man hier nicht aus den Augen verlieren ^^

Mach dir doch nen Beispiel auf nem Zettel:



Jahr|Betrag|Zinsen|Zinssatz
1|1000|100|10
2|1100|110|10
3|1210|121|10
4|1331|133,1|10
5|1464,1|146,41|10
oder in Pseudocode:


```
kn {
   kapital = übergebenesKapital
   Solange wie ein Counter < als n {
        kapital = k1;
        counter erhöhen;
   }
   zurückgeben kapital
}
```


----------



## faetzminator (17. Nov 2011)

Wenn die Formel [c]K_n = K_0 * (1 + p/100)^n[/c] lautet, dann machen wir das doch auch so 

```
int result = K * Math.pow(1 + p / 100, n)
```
Alternativ kann man - wenn man [c]Math.pow()[/c] nicht verwenden darf - natürlich auch eine eigene Methode [c]pow[/c] schreiben:

```
public static double pow(double d, int n) {
    double result = 1;
    for (int i = 0; i < n; i++) {
        result *= d;
    }
    return result;
}
```


----------



## Gossi (17. Nov 2011)

So wie ich das verstehe muss er aber k1 und kn benutzen ^^


----------

