Restbuchwert Berechnung geht nicht

[matthias953]

Hallo zusammen,

ich habe vor wenigen Wochen mein Studium angefangen, komme aber nicht in Programmieren weiter. Wir sollen eine Art Tabelle machen, wo ganz links die Jahre stehen, dann in der Mitte die Abschreibung und dann der Restbuchwert. Soweit so gut. Die Abschreibung habe ich noch hinbekommen, jedoch hänge ich nun bei dem Restbuchwert. Er will diesen nicht nehmen.. ich habe schon viel herumprobiert und bin letztendlich hier gelandet...

package MeinPaket;

import java.text.*;

public class abschreibung {

    // Anschaffungskosten
    static final double anschaffungskosten = 21000;

    // Nutzungsdauer
    static final int nutzungsdauer = 7;

    // linear degressive Abschreibung
    static final double degressiveabschreibung = 0.2;

    // Jahranzeige bis 7 Jahre inkl. Jahr 0
    static int[] jahr = { 0, 1, 2, 3, 4, 5, 6, 7 };

    // Berechnung der Abschreibung und fortlaufende Abschreibung in jeder Zeile
    public static double[] berechnung() {
        double[] abschreibung = new double[nutzungsdauer + 1];
        // double[] restbuchwert = new double[(int) (anschaffungskosten + 1)];

        for (int i = 1; i < jahr.length; i++) {
            abschreibung[i] = anschaffungskosten / nutzungsdauer;
            // restbuchwert[i] = anschaffungskosten - abschreibung[i];

    }
        return abschreibung;
    }

    public double[] restbuchwert() {
        double[] restbuchwert = new double[(int) (nutzungsdauer + 1)];
   
        for (int k = 1; k < jahr.length; k++) {
            restbuchwert[k] = anschaffungskosten - MeinPaket.abschreibung.abschreibung;
        }
        return restbuchwert;
}
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        // Überschrift Lineare Abschreibung
        System.out.println("Lineare Abschreibung: ");

        // Überschrift Jahr
        System.out.println("Jahr \t Abschreibung \t Restbuchwert");

        // Schleifenbeginn ; Array
        for (int i = 0; i < jahr.length; i++) {

            // Funktionsausgabe
            System.out.print(jahr[i]);

            // Dezimalzahlen Darstellung
            // for (i=0; system.out.printf(i));
            DecimalFormat myFormat = new DecimalFormat(",#00.00 \u00A4\u00A4");

            // Jahr 0 anpassung der leerzeichen, da 0,00 linksbündig war (zu
            // kleine Zahl im Gegensazu zu den anderen)
            String formatErgebnis = myFormat.format(berechnung()[i]);
            int k = formatErgebnis.length();
            while (k < 13) {
                formatErgebnis = " " + formatErgebnis;
                k = k + 1;
            }

            // Ausgabe als Dezimalzahl im gewünschten Format s. Oben
            // "Dezimalzahlen Darstellung"
            System.out.println("\t" + formatErgebnis);
        }
    }
}

Raus kommt nur das hier:
Lineare Abschreibung:
Jahr Abschreibung Restbuchwert
0 00,00 EUR
1 3.000,00 EUR
2 3.000,00 EUR
3 3.000,00 EUR
4 3.000,00 EUR
5 3.000,00 EUR
6 3.000,00 EUR
7 3.000,00 EUR
(Die Formatierung sieht hier etwas misslungen aus)
Leider ohne den gewünschten Restbuchwert...

Bitte um Tipps oder Hilfe!

Danke


EDIT:

Ich möchte in diesem Part die Anschaffungskosten - die berechnete Abschreibung machen, jedoch sagt er mir "abschreibung" cannot resolved or is not a field.

 public double[] restbuchwert() {
        double[] restbuchwert = new double[(int) (nutzungsdauer + 1)];
   
        for (int k = 1; k < jahr.length; k++) {
            restbuchwert[k] = anschaffungskosten - MeinPaket.abschreibung.abschreibung;
        }
        return restbuchwert;

 

[JStein52]

Ja, wo ist denn die Ausgabe für den restbuchwert ? Ich finde kein println dafür

 

[matthias953]

Muss ich das mit Println ausgeben? Mir wurde bei dem restbuchwert von einem Kommilitonen geholfen. Dort wurde "return restbuchwert;" benutzt und die Zahlen wurden trotzdem ausgegeben?

Also ich hab das auch mal probiert jetzt mit Sysout, aber er gibt die Zahlen trotzdem nicht aus.
Die Sysout Ausgabe muss doch in der restbuchwert Methode ausgegeben werden oder wie kann ich die Berechnung in der Main Methode benutzen?

    public static double[] restbuchwert() {
        double[] restbuchwert = new double[(int) (nutzungsdauer + 1)];
      
        for (int k = 1; k < jahr.length; k++) {
            restbuchwert[k] = anschaffungskosten - (anschaffungskosten / nutzungsdauer) ;
            System.out.println(restbuchwert[k]);
        }
        return restbuchwert;

EDIT: Habe es in der MainMethode hinbekommen auszugeben, jedoch kommt das dabei raus:

Lineare Abschreibung:
Jahr Abschreibung Restbuchwert
0[D@1db9742
00,00 EUR
1[D@d93b30
3.000,00 EUR
2[D@16d3586
3.000,00 EUR
3[D@154617c
3.000,00 EUR
4[D@a14482
3.000,00 EUR
5[D@140e19d
3.000,00 EUR
6[D@17327b6
3.000,00 EUR
7[D@14ae5a5
3.000,00 EUR

 

[Xyz1]

So, ich habe etwa 400 Beiträge (vergangene) nach Zinseszinsrechnung durchsucht, aber konnte ihn nicht mehr finden. Jedenfalls, diese Frage gab es hier bereits! Und ich hab ein adaequate Antwort dazu erstellt.

Du musst Jahr, Abschreibung und Restbuchwert JEDES MAL mit einem sout ausgeben lassen...

 

[JStein52]

Nimm mal den println aus deiner methode restbuchwert raus, Diese Methode liefert dir ja die Restbuchwerte als doule-Array zurück. Du solltest jetzt in deiner main-Methode die Werte noch richtig ausgeben. Zeige mal deine main-Methode wie die jetzt aussieht

 

[matthias953]

Also das mit ln ist mir gerade auch aufgefallen habe soweit die richtige Formatierung, jedoch sind nun Restbuchwert und Abschreibung vertauscht. Die Zahlen machen ebenfalls keinen Sinn^^

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        // Überschrift Lineare Abschreibung
        System.out.println("Lineare Abschreibung: ");

        // Überschrift Jahr
        System.out.println("Jahr \t Abschreibung \t Restbuchwert");

        // Schleifenbeginn ; Array
        for (int i = 0; i < jahr.length; i++) {

            // Funktionsausgabe
            System.out.print(jahr[i]);
         
            System.out.print("\t" + MeinPaket.abschreibung.restbuchwert());

            // Dezimalzahlen Darstellung
            // for (i=0; system.out.printf(i));
            DecimalFormat myFormat = new DecimalFormat(",#00.00 \u00A4\u00A4");

            // Jahr 0 anpassung der leerzeichen, da 0,00 linksbündig war (zu
            // kleine Zahl im Gegensazu zu den anderen)
            String formatErgebnis = myFormat.format(berechnung()[i]);
            int k = formatErgebnis.length();
            while (k < 13) {
                formatErgebnis = " " + formatErgebnis;
                k = k + 1;
            }

            // Ausgabe als Dezimalzahl im gewünschten Format s. Oben
            // "Dezimalzahlen Darstellung"
            System.out.println("\t" + formatErgebnis);
        }

Raus kommt:

Lineare Abschreibung:
Jahr Abschreibung Restbuchwert
0 [D@1db9742 00,00 EUR
1 [D@d93b30 3.000,00 EUR
2 [D@16d3586 3.000,00 EUR
3 [D@154617c 3.000,00 EUR
4 [D@a14482 3.000,00 EUR
5 [D@140e19d 3.000,00 EUR
6 [D@17327b6 3.000,00 EUR
7 [D@14ae5a5 3.000,00 EUR

 

[JStein52]

deine Ausgabe ist ein bisschen verkorkst. Ich würde die Schleife so machen:

double[] abschreibung = berechnung();
double[] restbuchwert = restwert();

for (int i = 0; i < jahr.length; i++) {

            // Funktionsausgabe
            System.out.print(jahr[i]);
      
            System.out.print("\t" + restbuchwert[i]);

            // Dezimalzahlen Darstellung
            // for (i=0; system.out.printf(i));
            DecimalFormat myFormat = new DecimalFormat(",#00.00 \u00A4\u00A4");

            // Jahr 0 anpassung der leerzeichen, da 0,00 linksbündig war (zu
            // kleine Zahl im Gegensazu zu den anderen)
            String formatErgebnis = abschreibung[i];
            int k = formatErgebnis.length();
            while (k < 13) {
                formatErgebnis = " " + formatErgebnis;
                k = k + 1;
            }

            // Ausgabe als Dezimalzahl im gewünschten Format s. Oben
            // "Dezimalzahlen Darstellung"
            System.out.println("\t" + formatErgebnis);
        }

 

[matthias953]

So, ich habe etwa 400 Beiträge (vergangene) nach Zinseszinsrechnung durchsucht, aber konnte ihn nicht mehr finden. Jedenfalls, diese Frage gab es hier bereits! Und ich hab ein adaequate Antwort dazu erstellt.

Du musst Jahr, Abschreibung und Restbuchwert JEDES MAL mit einem sout ausgeben lassen...

Wie ist das gemeint? Bin leider absoluter Neuling. Also ich muss doch eigentlich immer eine Berechnung machen lassen und diese dann Ausgeben?

Hast du ein konkretes Beispiel?

 

[JStein52]

Hast du ein konkretes Beispiel?

siehe oben

 

[matthias953]

deine Ausgabe ist ein bisschen verkorkst. Ich würde die Schleife so machen:

double[] abschreibung = berechnung();
double[] restbuchwert = restwert();

for (int i = 0; i < jahr.length; i++) {

            // Funktionsausgabe
            System.out.print(jahr[i]);
      
            System.out.print("\t" + restbuchwert[i]);

            // Dezimalzahlen Darstellung
            // for (i=0; system.out.printf(i));
            DecimalFormat myFormat = new DecimalFormat(",#00.00 \u00A4\u00A4");

            // Jahr 0 anpassung der leerzeichen, da 0,00 linksbündig war (zu
            // kleine Zahl im Gegensazu zu den anderen)
            String formatErgebnis = abschreibung[i];
            int k = formatErgebnis.length();
            while (k < 13) {
                formatErgebnis = " " + formatErgebnis;
                k = k + 1;
            }

            // Ausgabe als Dezimalzahl im gewünschten Format s. Oben
            // "Dezimalzahlen Darstellung"
            System.out.println("\t" + formatErgebnis);
        }

Danke schon mal für deine Hilfe.

Irgendwie lässt er mich nicht

String formatErgebnis = abschreibung[i];

setzen, weil er sagt cannot convert from double to string. Wie löse ich das Problem? Das hatte ich jetzt schon mehrfach, dass er sagt cannot convert from double to int zum Beispiel.

Was ich mich noch Frage ist, dass du ganz oben bei

double []  restbuchwert = restwert();

"Restwert" stehen hast. Was bedeutet das? Ist damit der Restbuchwert einfach gemeint oder wie?

Das ganze sieht bei mir nun so aus:

        double[] abschreibung = berechnung();
        double[] restbuchwert = restbuchwert();
   
        // Schleifenbeginn ; Array
        for (int i = 0; i < jahr.length; i++) {

            // Funktionsausgabe
            System.out.print(jahr[i]);
   
            System.out.print("\t" + MeinPaket.abschreibung.restbuchwert());

            // Dezimalzahlen Darstellung
            DecimalFormat myFormat = new DecimalFormat(",#00.00 \u00A4\u00A4");

            // Jahr 0 anpassung der leerzeichen, da 0,00 linksbündig war (zu
            // kleine Zahl im Gegensazu zu den anderen)
            String formatErgebnis = abschreibung[i];
            int k = formatErgebnis.length();
            while (k < 13) {
                formatErgebnis = " " + formatErgebnis;
                k = k + 1;
            }

            // Ausgabe als Dezimalzahl im gewünschten Format s. Oben
            // "Dezimalzahlen Darstellung"
            System.out.println("\t" + formatErgebnis);
        }
    }

 

[JStein52]

Ach so ja. Sorry.

String formatErgebnis = Double.toString(abschreibung[i]);

 

[JStein52]

double []  restbuchwert = restwert();

Das ist der Aufruf deiner Methode restwert() und die liefert ja ein double-Array mit den ganzen restwerten zurück.

Edit:

ach so, ich sehe gerade ich hatte mich verschrieben. Du hast das korrigiert

 

[matthias953]

Ach so ja. Sorry.

String formatErgebnis = Double.toString(abschreibung[i]);

Danke.

double []  restbuchwert = restwert();

Das ist der Aufruf deiner Methode restwert() und die liefert ja ein double-Array mit den ganzen restwerten zurück.

Edit:

ach so, ich sehe gerade ich hatte mich verschrieben. Du hast das korrigiert

Ja ich habe mich schon gewundert, da ich ja keine Restwert Methode habe ^^

Also jetzt meckert der Compiler nicht mehr rum, aber die Zahlen sind nicht mehr formatiert und ebenfalls noch verdreht ;/ . Ich blick echt nicht durch in Java :C

Hier nochmal der gesamte Code:

package MeinPaket;

import java.text.*;

public class abschreibung {

    // Anschaffungskosten
    static final double anschaffungskosten = 21000;

    // Nutzungsdauer
    static final int nutzungsdauer = 7;

    // linear degressive Abschreibung
    static final double degressiveabschreibung = 0.2;

    // Jahranzeige bis 7 Jahre inkl. Jahr 0
    static int[] jahr = { 0, 1, 2, 3, 4, 5, 6, 7 };

    // Berechnung der Abschreibung und fortlaufende Abschreibung in jeder Zeile
    public static double[] berechnung() {
        double[] abschreibung = new double[nutzungsdauer + 1];
        // double[] restbuchwert = new double[(int) (anschaffungskosten + 1)];

        for (int i = 1; i < jahr.length; i++) {
            abschreibung[i] = anschaffungskosten / nutzungsdauer;
            // restbuchwert[i] = anschaffungskosten - abschreibung[i];

        }
        return abschreibung;
    }

    public static double[] restbuchwert() {
        double[] restbuchwert = new double[(int) (nutzungsdauer + 1)];

        for (int k = 1; k < jahr.length; k++) {
            restbuchwert[k] = anschaffungskosten - (anschaffungskosten / nutzungsdauer);
        }
        return restbuchwert;
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        // Überschrift Lineare Abschreibung
        System.out.println("Lineare Abschreibung: ");

        // Überschrift Jahr
        System.out.println("Jahr \t Abschreibung \t Restbuchwert");

        double[] abschreibung = berechnung();
        double[] restbuchwert = restbuchwert();
   
        // Schleifenbeginn ; Array
        for (int i = 0; i < jahr.length; i++) {

            // Funktionsausgabe
            System.out.print(jahr[i]);
   
            System.out.print("\t" + MeinPaket.abschreibung.restbuchwert());
           

            // Dezimalzahlen Darstellung
            DecimalFormat myFormat = new DecimalFormat(",#00.00 \u00A4\u00A4");

            // Jahr 0 anpassung der leerzeichen, da 0,00 linksbündig war (zu
            // kleine Zahl im Gegensazu zu den anderen)
            String formatErgebnis = Double.toString(abschreibung[i]);
            int k = formatErgebnis.length();
            while (k < 13) {
                formatErgebnis = " " + formatErgebnis;
                k = k + 1;
            }

            // Ausgabe als Dezimalzahl im gewünschten Format s. Oben
            // "Dezimalzahlen Darstellung"
            System.out.println("\t" + formatErgebnis);
        }
    }
}

Raus kommt:

Lineare Abschreibung:
Jahr Abschreibung Restbuchwert
0 [D@1db9742 0.0
1 [D@d93b30 3000.0
2 [D@16d3586 3000.0
3 [D@154617c 3000.0
4 [D@a14482 3000.0
5 [D@140e19d 3000.0
6 [D@17327b6 3000.0
7 [D@14ae5a5 3000.0

 

[JStein52]

Du hast wieder einen Fehler eingebaut und wenn der restbuchwert hinten stehen soll musst du die Ausgaben umdrehen:

// Schleifenbeginn ; Array
        for (int i = 0; i < jahr.length; i++) {

            // Funktionsausgabe
            System.out.print(jahr[i]);
  

            // Dezimalzahlen Darstellung
            DecimalFormat myFormat = new DecimalFormat(",#00.00 \u00A4\u00A4");

            // Jahr 0 anpassung der leerzeichen, da 0,00 linksbündig war (zu
            // kleine Zahl im Gegensazu zu den anderen)
            String formatErgebnis = Double.toString(abschreibung[i]);
            int k = formatErgebnis.length();
            while (k < 13) {
                formatErgebnis = " " + formatErgebnis;
                k = k + 1;
            }

            // Ausgabe als Dezimalzahl im gewünschten Format s. Oben
            // "Dezimalzahlen Darstellung"
            System.out.print("\t" + formatErgebnis);
            System.out.println("\t" + restbuchwert[i]);
          
        }

 

[JStein52]

MeinPaket.abschreibung.restbuchwert()

Übrigens: das kannst du einfach so aufrufen:
restbuchwert()
weil du das ja in der gleichen Klasse im gleichen package aufrufst.

 

[matthias953]

Übrigens: das kannst du einfach so aufrufen:
restbuchwert()
weil du das ja in der gleichen Klasse im gleichen package aufrufst.

Achso, ja da hast du Recht, aber erst nachdem ich

double[] restbuchwert = restbuchwert();

in die Methode eingefügt habe und die damit quasi Importiert habe, richtig?

Also ich habe nun mal geschaut. Die Abschreibung steht nun vorne, so wie es sein soll, jedoch funktioniert der DecimalFormat nicht mehr, da ich die Ausgabe ja in Euro haben möchte und mit zwei Nullen hinter dem Komma(das Fehlt auch noch).

Das mit dem DecimalFormat krieg ich schon irgendwie hin.. mal rumtesten. Was mir noch sorgen macht ist, das bei dem Restbuchwert immer noch so Zahlen wie z.B. : [D@14991ad rauskommen.


EDIT: Die Formatierung zu EUR habe ich wieder hinbekommen.

 

[JStein52]

[D@14991ad

das sollte aber nicht sein. Zeige nochmal die Ausgabe

 

[matthias953]

Lineare Abschreibung:
Jahr      Abschreibung      Restbuchwert
0        00,00 EUR       [D@14991ad
1     3.000,00 EUR       [D@d93b30
2     3.000,00 EUR       [D@16d3586
3     3.000,00 EUR       [D@154617c
4     3.000,00 EUR       [D@a14482
5     3.000,00 EUR       [D@140e19d
6     3.000,00 EUR       [D@17327b6
7     3.000,00 EUR       [D@14ae5a5

Also das die Zahlen rechtsbündig und perfekt ausgerichtet sind bekomme ich hin (Die sind auch schon untereinander, jedoch formatiert das Board hier die nochmal falsch). Das mit den komischen Zahlen verstehe ich nicht. Auch nach längerem drauf schauen bin ich ratlos

 

[JStein52]

Und der Code dazu ? die main-Methode

 

[matthias953]

Ups, Sorry.

Hier:

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        // Überschrift Lineare Abschreibung
        System.out.println("Lineare Abschreibung: ");

        // Überschrift Jahr
        System.out.println("Jahr \t Abschreibung \t Restbuchwert");

        double[] abschreibung = berechnung();
        double[] restbuchwert = restbuchwert();
       
        // Schleifenbeginn ; Array
        for (int i = 0; i < jahr.length; i++) {

            // Funktionsausgabe
            System.out.print(jahr[i]);
           
            // Dezimalzahlen Darstellung
            DecimalFormat myFormat = new DecimalFormat(",#00.00 \u00A4\u00A4");

            // Jahr 0 anpassung der leerzeichen, da 0,00 linksbündig war (zu
            // kleine Zahl im Gegensazu zu den anderen)
            Double.toString(abschreibung[i]);
            String formatErgebnis = myFormat.format(abschreibung[i]);
            int k = formatErgebnis.length();
            while (k < 13) {
                formatErgebnis = " " + formatErgebnis;
                k = k + 1;
            }

            // Ausgabe als Dezimalzahl im gewünschten Format s. Oben
            // "Dezimalzahlen Darstellung"
            System.out.print("\t"+ formatErgebnis);
            System.out.println("\t"+ " " + " " + " " + restbuchwert());

 

[JStein52]

System.out.println("\t"+ " " + " " + " " + restbuchwert());

Dachte ich mir. das muss so heissen:

System.out.println("\t"+ " " + " " + " " + restbuchwert[i]);

Sorry, ich habe den Namen des double-Arrays etwas löd gewählt. das heisst jetzt genauso wie deine Methode restbuchwert() !

 

[JStein52]

double[] restbuchwert = restbuchwert();

Zur Erklärung. Mit dieser Zeile wird ein double-Array namens restbuchwert angelegt und es wird deine Methode restbuchwert() aufgerufen und deren ergebnis im array restbuchwert abgelegt.

 

[matthias953]

Dachte ich mir. das muss so heissen:

System.out.println("\t"+ " " + " " + " " + restbuchwert[i]);

Sorry, ich habe den Namen des double-Arrays etwas löd gewählt. das heisst jetzt genauso wie deine Methode restbuchwert() !

// Hat sich erledigt, danke für die Erklärung
Okay. Sieht schon mal besser aus, jedoch verstehe ich nicht was dieses jetzt zu bedeuten hat? Ist das eine Zuweisung der Variable i von

for (int i = 0; i < jahr.length; i++) {

?
// Ende

Desweiteren habe ich nun das Problem, dass er nicht den neu berechneten Wert , sprich 21.000 - 3.000 = 18.000, dann 18.000 - 3.000 = 15.000 , sondern er macht nur 18.000 überall hin.

Muss ich eine neue Schleife machen und den Code reinkopieren, weil bei Jahr 0 zeigt er Restbuchwert 0 aufgrund der Schleife (da ja bei Abschreibung Jahr 0 wirklich 0 abgeschrieben wird) ?

Danke für deine gute Hilfe!

EDIT:

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        // Überschrift Lineare Abschreibung
        System.out.println("Lineare Abschreibung: ");

        // Überschrift Jahr
        System.out.println("Jahr \t Abschreibung \t Restbuchwert");

        double[] abschreibung = berechnung();
        double[] restbuchwert = restbuchwert();
       
        // Schleifenbeginn ; Array
        for (int i = 0; i < jahr.length; i++) {

            // Funktionsausgabe
            System.out.print(jahr[i]);
           
            // Dezimalzahlen Darstellung
            DecimalFormat myFormat = new DecimalFormat(",#00.00 \u00A4\u00A4");

            // Jahr 0 anpassung der leerzeichen, da 0,00 linksbündig war (zu
            // kleine Zahl im Gegensazu zu den anderen)
            Double.toString(abschreibung[i]);
            String formatErgebnis = myFormat.format(abschreibung[i]);
            int k = formatErgebnis.length();
            while (k < 13) {
                formatErgebnis = " " + formatErgebnis;
                k = k + 1;
            }

            // Ausgabe als Dezimalzahl im gewünschten Format s. Oben
            // "Dezimalzahlen Darstellung"
            System.out.print("\t"+ formatErgebnis);
            System.out.println("\t"+ " " + " " + " " + restbuchwert[i]);
        }
    }
}

Ausgabe:
Lineare Abschreibung:
Jahr Abschreibung Restbuchwert
0 00,00 EUR 0.0
1 3.000,00 EUR 18000.0
2 3.000,00 EUR 18000.0
3 3.000,00 EUR 18000.0
4 3.000,00 EUR 18000.0
5 3.000,00 EUR 18000.0
6 3.000,00 EUR 18000.0
7 3.000,00 EUR 18000.0

 

[JStein52]

Nein, ich denke der Fehler ist in deiner restbuchwert-Methode. Da schreibt er in jedes Array-Element ja den gleichen Wert rein:

public static double[] restbuchwert() {
        double[] restbuchwert = new double[(int) (nutzungsdauer + 1)];
    
        for (int k = 1; k < jahr.length; k++) {
            restbuchwert[k] = anschaffungskosten - (anschaffungskosten / nutzungsdauer) ;
            System.out.println(restbuchwert[k]);
        }
        return restbuchwert;

 

[JStein52]

jedoch verstehe ich nicht was dieses jetzt zu bedeuten hat?

Man greift auf die einzelnen Elemente eines Arrays zu indem man den gewünscht Index in eckigen Klammern dahinter schreibt !

 

[JStein52]

Probier es mal so:

public static double[] restbuchwert() {
        double[] restbuchwert = new double[(int) (nutzungsdauer + 1)];
        restbuchwert[0] = anschaffungspreis;
        for (int k = 1; k < jahr.length; k++) {
            restbuchwert[k] = restbuchwert[k-1] - (anschaffungskosten / nutzungsdauer) ;
            //System.out.println(restbuchwert[k]);
        }
        return restbuchwert;
}

 

[matthias953]

Nein, ich denke der Fehler ist in deiner restbuchwert-Methode. Da schreibt er in jedes Array-Element ja den gleichen Wert rein:

public static double[] restbuchwert() {
        double[] restbuchwert = new double[(int) (nutzungsdauer + 1)];
   
        for (int k = 1; k < jahr.length; k++) {
            restbuchwert[k] = anschaffungskosten - (anschaffungskosten / nutzungsdauer) ;
            System.out.println(restbuchwert[k]);
        }
        return restbuchwert;

Stimmt. Das heißt doch eigentlich ich muss das so ungefähr machen :

    public static double[] restbuchwert() {
        double[] restbuchwert = new double[(nutzungsdauer +1)];

        for (int k = 1; k < jahr.length; k++) {
            restbuchwert[k] = berechnung() - (anschaffungskosten / nutzungsdauer);
        }
        return restbuchwert;

Bzw. ich muss ja auf meine Berechnung zurückgreifen, damit er weiß Aha da sind es nur noch 18.000 bzw. 15.000 usw. richtig?

 

[JStein52]

Du willst jedes jahr einen bestimmten Betrag vom restbuchwert des vorjahres subtrahiern oder ? Und zwar willst du anschaffungspreis/nutzungsdauer subtrahieren ?

 

[matthias953]

Also ich hab das mal so probiert wie du das gemacht hast. Es funktioniert...

Ich blick in Java echt nicht durch irgendwie. Voll kompliziert

Ich hätte das so wie von mir oben drüber gepostet gemacht, aber da hätte er gemeckert "The operator - is undefined for the argument type(s) double[] double .

EDIT:

Du willst jedes jahr einen bestimmten Betrag vom restbuchwert des vorjahres subtrahiern oder ? Und zwar willst du anschaffungspreis/nutzungsdauer subtrahieren ?

Genau, richtig. Ich merke gerade das was ich gemacht habe ergibt keinen Sinn. Das wären ja dann 3000 - 3000 ...

 

[JStein52]

aber da hätte er gemeckert "The operator - is undefined for the argument type(s) double[] double .

Ja, und zwar deshalb weil deine Methode berechnung() ein double[] zurückliefert. Das passt aber an dieser Stelle nicht.

 

[matthias953]

Achso. Was bedeuten denn diese Klammern [] bei Double? Das war doch der Zugriff auf das Array wie du gesagt hattest. Was bedeutet das, wenn dort nichts drin steht?

 

[JStein52]

Schau dir nochmal das Thema Arrays und Methoden sowie Methodenaufrufe an. Speziell auch Return-Werte von Methoden.

 

[matthias953]

Schau dir nochmal das Thema Arrays und Methoden sowie Methodenaufrufe an. Speziell auch Return-Werte von Methoden.

Ja werde ich nochmal machen... leider versteht man kaum etwas in den Vorlesungen und die Folien vom Prof sind auch solala ^^

 

[JStein52]

Was bedeutet das, wenn dort nichts drin steht?

double[] meinArray;

bedeutet das er ein Array namens meinArray dessen Element double's sind anlegt. Damit ist noch nichts über die Grösse des Arrays festgelegt.

double[] meinArray = new double[10];

legt ebenfalls ein Array an mit 10 Elementen;

double[] meinArray = berechnen();

legt wieder ein Array an und zwar mit dem Inhalt den die Methode berechnen() zurückliefert.

 

[JStein52]

leider versteht man kaum etwas in den Vorlesungen und die Folien vom Prof sind auch solala

Ja, kann ich mir gut vorstellen. Aber schau mal hier:
http://openbook.rheinwerk-verlag.de...tml#dodtp394ff2f8-9134-4eb3-a6b4-469ed4572a74
Ich weiss nicht ob du das kennst? Ist zwar kein Tutorial aber zum Nachschlagen ist das Buch ganz gut und alles online verfügbar. Schau dir mal das Kap. 3 an. Da steht schon viel din.

 

[matthias953]

Ja, kann ich mir gut vorstellen. Aber schau mal hier:
http://openbook.rheinwerk-verlag.de...tml#dodtp394ff2f8-9134-4eb3-a6b4-469ed4572a74
Ich weiss nicht ob du das kennst? Ist zwar kein Tutorial aber zum Nachschlagen ist das Buch ganz gut und alles online verfügbar. Schau dir mal das Kap. 3 an. Da steht schon viel din.

Danke! Da hab ich auch schon ab und zu reingeschaut, sonst wäre ich gar nicht weitergekommen .

Allerdings habe ich noch ein Problem. Die Abschreibungs-Zahlen hat er formatiert in Euro und mit Komma, aber für die Restbuchwert Zahlen tut er das nicht.

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        // Überschrift Lineare Abschreibung
        System.out.println("Lineare Abschreibung: ");

        // Überschrift Jahr
        System.out.println("Jahr \t Abschreibung \t Restbuchwert");

        double[] abschreibung = berechnung();
        double[] restbuchwert = restbuchwert();
    
        // Schleifenbeginn ; Array
        for (int i = 0; i < jahr.length; i++) {

            // Funktionsausgabe
            System.out.print(jahr[i]);
        
            // Dezimalzahlen Darstellung
            DecimalFormat myFormat = new DecimalFormat(",#00.00 \u00A4\u00A4");

            // Jahr 0 anpassung der leerzeichen, da 0,00 linksbündig war (zu
            // kleine Zahl im Gegensazu zu den anderen)
            Double.toString(abschreibung[i]);
            String formatErgebnis = myFormat.format(abschreibung[i]);
            int k = formatErgebnis.length();
            while (k < 13) {
                formatErgebnis = " " + formatErgebnis;
                k = k + 1;
            }

            // Ausgabe als Dezimalzahl im gewünschten Format s. Oben
            // "Dezimalzahlen Darstellung"
            System.out.print("\t"+ formatErgebnis);
            System.out.println("\t"+ " " + " " + " " + " " + restbuchwert[i]);
        }
    }
}

Ausgabe:
Lineare Abschreibung:
Jahr Abschreibung Restbuchwert
0 00,00 EUR 21000.0
1 3.000,00 EUR 18000.0
2 3.000,00 EUR 15000.0
3 3.000,00 EUR 12000.0
4 3.000,00 EUR 9000.0
5 3.000,00 EUR 6000.0
6 3.000,00 EUR 3000.0
7 3.000,00 EUR 0.0


EDIT: Hab es gelöst. Aber geht das nicht irgendwie schlauer bzw einfacher? Hab das jetzt so gemacht:

public static void main(String[] args) {
        // TODO Auto-generated method stub

        // Überschrift Lineare Abschreibung
        System.out.println("Lineare Abschreibung: ");

        // Überschrift Jahr
        System.out.println("Jahr \t Abschreibung \t Restbuchwert");

        double[] abschreibung = berechnung();
        double[] restbuchwert = restbuchwert();
       
        // Schleifenbeginn ; Array
        for (int i = 0; i < jahr.length; i++) {

            // Funktionsausgabe
            System.out.print(jahr[i]);
           
            // Dezimalzahlen Darstellung
            DecimalFormat myFormat = new DecimalFormat(",#00.00 \u00A4\u00A4");

            // Jahr 0 anpassung der leerzeichen, da 0,00 linksbündig war (zu
            // kleine Zahl im Gegensazu zu den anderen)
            Double.toString(abschreibung[i]);
            Double.toString(restbuchwert[i]);
            String formatErgebnis = myFormat.format(abschreibung[i]);
            String formatErgebnisRestbuchwert = myFormat.format(restbuchwert[i]);
            int k = formatErgebnis.length();
            while (k < 13) {
                formatErgebnis = " " + formatErgebnis;
                k = k + 1;
            }

            // Ausgabe als Dezimalzahl im gewünschten Format s. Oben
            // "Dezimalzahlen Darstellung"
            System.out.print("\t"+ formatErgebnis);
        //Stem.out.print("\t\t\t" + formatErgebnisRestbuchwert);
            System.out.println("\t"+ " " + " " + " " + " " + formatErgebnisRestbuchwert);
        }
    }
}

 

[JStein52]

Ja, weil du dafür ja auch noch keine Formatierung durchführst. Da wirst du das gleiche machen müssen wie für abschreibung. So etwa:

String formatErgebnisAbschreibung = myFormat.format(abschreibung[i]);
            int k = formatErgebnisAbschreibung.length();
            while (k < 13) {
                formatErgebnisAbschreibung = " " + formatErgebnisAbschreibung;
                k = k + 1;
            }
String formatErgebnisRestwert = myFormat.format(restbuchwert[i]);
            int k = formatErgebnisRestwert.length();
            while (k < 13) {
                formatErgebnisRestwert = " " + formatErgebnisRestwert;
                k = k + 1;
            }
            // Ausgabe als Dezimalzahl im gewünschten Format s. Oben
            // "Dezimalzahlen Darstellung"
            System.out.print("\t"+ formatErgebnisAbschreibung);
            System.out.println("\t"+ " " + " " + " " + " " + formatErgebnisRestwert);

 

[matthias953]

Ja, weil du dafür ja auch noch keine Formatierung durchführst. Da wirst du das gleiche machen müssen wie für abschreibung. So etwa:

String formatErgebnisAbschreibung = myFormat.format(abschreibung[i]);
            int k = formatErgebnisAbschreibung.length();
            while (k < 13) {
                formatErgebnisAbschreibung = " " + formatErgebnisAbschreibung;
                k = k + 1;
            }
String formatErgebnisRestwert = myFormat.format(restbuchwert[i]);
            int k = formatErgebnisRestwert.length();
            while (k < 13) {
                formatErgebnisRestwert = " " + formatErgebnisRestwert;
                k = k + 1;
            }
            // Ausgabe als Dezimalzahl im gewünschten Format s. Oben
            // "Dezimalzahlen Darstellung"
            System.out.print("\t"+ formatErgebnisAbschreibung);
            System.out.println("\t"+ " " + " " + " " + " " + formatErgebnisRestwert);

Jup, hab ich mir gedacht. Ich lerne definitiv dazu! Und zwar mehr von dir als von meinem Prof

Das war's erstmal für heute... ich muss noch zwei andere Abschreibungen machen in dem Programm, aber dafür habe ich heute glaube ich keinen Nerv mehr.

Ich danke dir recht herzlich für deine Zeit und deine Hilfe! Von dir müsste es mehr Menschen geben

 

[JStein52]

Freut mich dass ich dir helfen konnte.

 

[JStein52]

Kleiner Hinweis noch. Diese zwei Zeilen

Double.toString(abschreibung[i]);
Double.toString(restbuchwert[i]);

brauchst du jetzt natürlich nicht mehr.

 

[matthias953]

Kleiner Hinweis noch. Diese zwei Zeilen

Double.toString(abschreibung[i]);
Double.toString(restbuchwert[i]);

brauchst du jetzt natürlich nicht mehr.

Warum nicht mehr? Ich bin echt blöd das ich das nicht verstehe.

 

[JStein52]

Nein, du bist nicht blöd aber dir fehlt noch ein bisschen Verständnis dafür. Das kommt schon.
Und diese zwei Anweisungen brauchst du nicht mehr weil sie da quasi nix tun. Sie wandeln zwar den i.ten Wert im jeweiligen double-Array in einen String um. Aber mit diesem umgewandelten String wird ja nichts gemacht. Es wäre der return Wert der toString(...)-Methode.
etwas sinnvolles würde dann z.B. so aussehen:

String meinString = Double.toString(abschreibung[i]);

.

Aber natürlich auch nur wenn mit meinString dann auch was gemacht wird.
Aber wenn du gerade zu viel hast dann darfst du dich gerne auch später wieder mal melden um Fragen zu klären.

 

[matthias953]

Nein, du bist nicht blöd aber dir fehlt noch ein bisschen Verständnis dafür. Das kommt schon.
Und diese zwei Anweisungen brauchst du nicht mehr weil sie da quasi nix tun. Sie wandeln zwar den i.ten Wert im jeweiligen double-Array in einen String um. Aber mit diesem umgewandelten String wird ja nichts gemacht. Es wäre der return Wert der toString(...)-Methode.
etwas sinnvolles würde dann z.B. so aussehen:

String meinString = Double.toString(abschreibung[i]);

.

Aber natürlich auch nur wenn mit meinString dann auch was gemacht wird.
Aber wenn du gerade zu viel hast dann darfst du dich gerne auch später wieder mal melden um Fragen zu klären.

Danke für die Erklärung. Leider hast du Recht und ich bin im Uni Stress, da ich ein duales Studium mache und unter der Woche noch arbeiten muss und jeweils Donnerstags und Samstags bis abends in die Uni muss.

Ist das so, weil ich vorher versucht habe einen neuen String zu machen mit Abschreibung und Restbuchwert, aber dann im Endeffekt in den vorhanden String meine Abschreibung und den Restbuchwert reingemacht habe?

Auf dein Angebot werde ich gerne wieder zurückkommen, vielleicht nicht heute, aber definitiv in den nächsten Tagen wenn mir hier und da mal wieder ein Problem begegnet das ich nicht lösen kann.

 

[JStein52]

Ist das so, weil ich vorher versucht habe einen neuen String zu machen mit Abschreibung und Restbuchwert, aber dann im Endeffekt in den vorhanden String meine Abschreibung und den Restbuchwert reingemacht habe?

Ja genau. Du hattest vorher mal eine Version wo du die doubles als String gebraucht hattest, Und dafür waren die zwei Statements gedacht. Aber der format-Methode kannst du die Zahlen als double übergeben:

myFormat.format(abschreibung[i])

Und deshalb brauchst du das andere nicht. Und das klingt ja ganz schön stressig was du da machst.

 

[Xyz1]

Mal 'ne Dumme Frage... Ist das mit Verzinsung? Wird erst abgeschrieben, dann verzinst - oder wird erst verzinst, dann abgeschrieben? Bin da nicht so firm drin.

 

[TheFrog]

@matthias953 ich möchte dir jetzt nicht den Tag verderben aber:

1.) wenn du schon die Grundlagenvorlesungen aus dem ersten Semester als "Stress" empfindest..
2.) eine Vorlesung dient mehr der kurzen Wiederholung des Stoffs und als Diskussionsplattform. Professoren erwarten, dass du dich daheim mit der Literatur befasst und vorbereitet in die Vorlesung kommst. (FH/Uni != Schule)
3.) es ist also deine Aufgabe dir den Stoff beizubringen und nicht die des Professors!
4.) Suche den Fehler bei dir und nicht bei anderen..

Positiv finde ich, dass du die Initiative ergriffen hast selbst aktiv zu werden und dich hier im Forum meldest.

Einen schönen Sonntag