# Methoden in der Main aufrufen



## Thisor (16. Dez 2015)

Ich soll ein Programm mit Methoden schreiben, welches den Verbrauch in Liter/100Km (auf 1 Nachkommastelle) und den Gesamtdurchschnittsverbrauch wiedergibt.

Vorgegeben war "Kilometerstand" und getankter Treibstoff.
Mein bisheriger Code:

```
public class Tagebuch {
    public static void main(String[] args) {
        // Kilometerstand beim Tanken
        int[] kilometer = { 105000, 105756, 106320, 106900, 107543 };

        // getankter Treibstoff
        int[] liter = { 50, 45, 42, 48 };

        // TODO: Verbrauch & Gesamtdurchschnitt
        System.out.println(calcDifferenz(kilometer));
    }

    // differenz
    public static int calcDifferenz(int[] kilometer) {
        int differenz = 0;
        for (int i = 0; i < kilometer.length - 1; i++) {
            differenz = (kilometer[i] - kilometer[i + 1]) * (-1);
        }
        return differenz;
    }
}
```

Natürlich bin ich noch nicht feritg. Aber wenn ich das Programm jetzt so starten laufe, bekomme ich nur den letzten Wert von der Differenz. Wie bekomme ich jeden Wert einzeln von der Schleife?


----------



## Joose (16. Dez 2015)

Entweder gehst du in der main dein Array "kilometer" Element für Element durch und übergibst nur eine Zahl an die Methode (anstatt des ganzen Arrays) oder die Methode liefert dir ein Array mit allen Differenzen zurück.


----------



## Thisor (16. Dez 2015)

Hab mich für innerhalb der Main-Methode entschieden:


```
public class Tagebuch {
    public static void main(String[] args) {
        // Kilometerstand beim Tanken
        int[] kilometer = { 105000, 105756, 106320, 106900, 107543 };

        // getankter Treibstoff
        int[] liter = { 50, 45, 42, 48 };

        int differenz = 0;
        for (int i = 0; i < kilometer.length - 1; i++) {
            differenz = (kilometer[i] - kilometer[i + 1]) * -1;
            System.out.println("Die Differenz beträgt : " + differenz);
            double verbrauch = 0;
            for (int j = 0; j < liter.length; j++) {
                verbrauch = (liter[j] * 100) / differenz;
            }
            System.out.println("Der Verbrauch ist : " + verbrauch);
        }
    }

}
```

Ich glaube soweit ist es auch richtig, auch wenn mir die Ausgabe noch nicht gefällt 
Ein Teilaufgabe ist nun den Verbrauch auf 1 Nachkommastelle auszugeben, glaub in dem Fall ohne auf- oder abzurunden.
Bin bei Google auf die Methode Math.Round gestoßen, aber die rundet ja auf bzw ab.
Gibt es andere Methoden dazu?


----------



## Joose (16. Dez 2015)

Du hast die Aufgabe falsch gelöst. Laut deinem Post geht es darum ein Program mit Methoden zu schreiben. 

Mein Ansatz war es in der main-Methode nur eine Schleife zu schreiben welche alle Elemenet von Array "kilometer" durchgeht und jedes Element (sowie das nochfolgende) an die Methode (welche du am Anfang schon hattest) übergibt. In der Methode gibts du dann die gewünschte Ausgabe aus.


----------



## Jardcore (16. Dez 2015)

Es gibt da mehrere Wege deine Ausgabe zu formatierten:

```
System.out.printf("Der Verbrauch ist : %.1f\n", verbrauch);
System.out.println(String.format("Der Verbrauch ist : %.1f", verbrauch));
```

Beide Methoden sorgen für eine Formatierung der Ausgabe, *%.1f *steht dabei für eine reele Zahl mit nur einer Nachkommastelle. und das *\n *steht für einen Zeilenumbruch.


----------



## JStein52 (16. Dez 2015)

Und warum gefällt dir auf- und abrunden nicht ?  Ist doch ganz ok bei dieser Aufgabe oder nicht


----------



## Jardcore (16. Dez 2015)

Hab nicht gesehen das es NICHT gerundet werden soll, habs wohl überlesen. Wer zur Hölle will denn nicht Runden ^^ das gibt doch nur falsche Ergebnisse XD

Für deinen Fall:
http://stackoverflow.com/questions/8486878/how-to-cut-off-decimal-in-java-without-rounding


----------



## Thisor (16. Dez 2015)

@Jardcore  Zugegeben: in der Aufgabe steht ich soll das Programmfragment erweitern. Und nur int[] kilometer und int[] liter sind vorgegeben. Das mit der Methode habe ich erwähnt weil ich es mit Methoden versuchen wollte und der Meinung bin/war, das es so auch schöner aussieht 

EDIT: Wie übergebe ich denn jedes Wert an die Methode?
Kann ich im Parameter (double differenz(i)) eingeben? Ansonsten wüsste ich nicht wie, vllt einzeln?  Dann müsste ich ja aber jeden Wert pro Schleifendurchlauf festhalten hmm.. *grüml*

@JStein52 Es ist nicht so das mir auf-/abrunden nicht gefällt, in der Aufgabe steht bloß, dass die Ausgabe eine Nachkommestelle anzeigen soll und von auf- oder abrunden wird nichts erwähnt.


----------



## Jardcore (16. Dez 2015)

Du hast wohl unsere Namen verwechselt 

Du müsstest wohl die Differenz in den String[] args übergeben und dann parsen

```
int differenz = Integer.parseInt(args[0]);
```
Die 0 steht für den ersten Parameter.

Falls du nicht weißt wie das genau geht.


Jardcore hat gesagt.:


> Entweder über die Console "java Program.java 1 2 3 4 5 6 7"
> Oder du kannst das auch über deine IDE machen, in Eclipse kannst du zum Beispiel anhand der Run Configurations Parameter mitgeben.


Programm.java dann durch Tagebuch.java ersetzen


----------



## Thisor (16. Dez 2015)

Parsen sagt mir nichts..
Hatten wir weder im ersten noch im zweiten Semester..


----------



## Jardcore (16. Dez 2015)

Parse heißt soviel wie analysieren / übersetzten.
In deinem Fall würde versucht werden einen String in einen Integer Wert umzuwandeln.

Deine Universität sollte diese Grundlagen eigentlich in den ersten Semestern beibringen.
Nur weil du das nicht in der Uni hast, heißt es nicht das es nicht wichtig ist. (dein Arbeitgeber wird nicht fragen ob du weißt was parsen ist ^^)


----------



## JStein52 (16. Dez 2015)

Wieso willst du denn was eingeben ? Du hast doch alles was du brauchst. Du hast eine Menge von Kilometerständen und eine Menge von Benzin das du getankt hast. Dann kannst du doch für jedes Intervall den Verbrauch berechnen und am Ende mitteln ?


----------



## Thisor (17. Dez 2015)

Mh, hab ich das nicht gemacht?
Wie würde der Ansatz aussehen?
Bin für den Gedankenstoß dankbar


----------



## JStein52 (17. Dez 2015)

Stimmt, die Diskussion mit args[] und parsen von Eingaben war ja gar nicht von dir !


----------



## Thisor (17. Dez 2015)

Ich weiß nicht wie ich´s umsetzen soll.
Dazu verwirrt mich deine frage was ich in den Parameter eingeben soll.
In jede .."sinnvolle" Methode gehört doch ein Parameter rein, oder nicht?


----------



## JStein52 (17. Dez 2015)

Ja meistens ist das so. Aber es sind ja auch Methoden denkbar die keine Parameter haben.
Und nun zu deinem "Problem":  du hast ja eine funktionierende main-Methode. Du könntest jetzt im nächsten Schritt (falls die Aufgabe das verlangt) eine Methode machen z.B. berechneVerbrauch(...) die als Input den Anfangskilometerstand, den Endekilometerstand und die getankten Liter Benzin kriegt und den Verbrauch zurückliefert. Also sozusgen einen Teil dessen was du jetzt in main schon hast in eine neue Methode verlagern.


----------



## Thisor (17. Dez 2015)

also quasi so:

```
public static void main(String[] args) {
        // Kilometerstand beim Tanken
        int[] kilometer = { 105000, 105756, 106320, 106900, 107543 };
        // getankter Treibstoff
        int[] liter = { 50, 45, 42, 48 };
        double differenz = 0;
        for (int i = 0; i < kilometer.length - 1; i++) {
            differenz = (kilometer[i] - kilometer[i + 1]) * -1;
            System.out.println("Die Differenz beträgt : " + differenz);
        }
    }

    public static double calcVerbrauch(double differenz, int[] liter) {
        double verbrauch = 0;
        for (int i = 0; i < liter.length; i++) {
            verbrauch = (liter[i] * 100) / differenz;
        }
        return verbrauch;
    }
}
```

Die Methode gebe ich aus in dem ich Syso(calcVerbrauch(differenz, liter); in der Main eingebe?


----------



## JStein52 (17. Dez 2015)

Also zum Sprachgebrauch:  Die Methode gibst du nicht aus sondern du rufst sie auf.
Dann kriegt die Methode keine int[] liter als Parameter sondern nur ein int liter Denn du rufst sie in der main ja innerhalb der Schleife über die verschiedenen gefahrenen Abschnitte auf.

```
public static double calcVerbrauch(double differenz, int liter) {
        double verbrauch = 0;
            verbrauch = (liter * 100) / differenz;
        }
        return verbrauch;
    }
```

Und in der main:

```
for (int i = 0; i < kilometer.length - 1; i++) {
            differenz = (kilometer[i] - kilometer[i + 1]) * -1;
            System.out.println("Die Differenz beträgt: " + differenz);
            System.out.println("Der Verbrauch beträgt: "+calcVerbrauch(differenz, liter[i]));
        }
```


----------



## Thisor (17. Dez 2015)

Okay, das ist nice!
Einige Sachen was ich noch nicht ganz verstehe:
1. Mein return ist "verbrauch", dass ich die Methode durch den Methodenkopf aufrufe, ist mir verständlich, aber ich rufe sie auf durch: 

```
System.out.println(calcVerbrauch(differenz, liter[i]));
```
und greife gar nicht auf verbrauch zu. Und differenz wird gar nicht ausgewertet, aber liter_ schon ? 
2. Schleife wird in dem Fall für liter gar nicht benutzt? Wieso nicht? Was wenn nich nur die ersten 2 Werte gewollt hätte?
3. Ich habe gelesen das static-Methoden keinen Rückgabewert haben, aber ich arbeite doch mit return und dementsprechend habe ich doch einen Rückgabewert.._


----------



## JStein52 (17. Dez 2015)

Zu 1.)  doch du greifst darauf zu, du siehst es nur nicht so direkt, denn der Return-Wert von calcVerbrauch wird direkt im println zur Ausgabe benutzt. Und in calcVerbrauch werden beide Parameter die du übergibst ausgewertet oder was meinst du mit differen wird nicht ausgewertet ?

Zu 2.) Du berechnest ja in der Schleife die Differenz von zwei Kilometerständen und du hast den Benzinverbrauch in Liter für dieses Intervall (!!!!)  in 
	
	
	
	





```
liter[i]
```
Und wenn du nur die ersten zwei Werte gewollt hättest dann darfst du eben keine Schleife über alle Intervalle machen sondern du würdest dir explizit die Differenzen der ersten zwei Intervalle ausrechnen

zu 3.) ist Käse. Das hast du glaube ich so nicht gelesen [/code]


----------



## Thisor (23. Dez 2015)

Sorry das ich mich erst jetzt wieder melde, habe glaub etwas Pause von Programmieren gebraucht 

Zu 1.) Okay, alles klar. Ich hätte jetzt nur gedacht, dass die differenz trotzdem ausgegeben werden würde, obwohl ich nichts damit gemacht hab. Denn in der Ausgabe, also syso, wird sie ja trotzdem mitgegeben, also :

```
System.out.println(calcVerbrauch(differenz, liter[i]));
```


Zu 2.) Ich versteh´s immer noch nicht so recht..-.-".
Wenn ich nur durch

```
liter[i];
```
auf jedes Element zugreifen kann, ohne eine Schleife dafür zu erstellen, dann hätte ich doch genauso gut bei kilometer gleich :

```
differenz = (kilometer[i] - kilometer[i+1];
```
schreiben können und mir die for-Schleife sparen können.

Zu 3.) Stimmt, habe ich echt so nicht gelesen  Da stand noch ein void dahinter 

Ich muss jetzt noch den Gesamtdurchschnitt angeben. Versucht habe ich jetzt eine weitere Methode zu erstellen, bekomme aber dann 0.0 jedes mal ausgewertet.
Wenn ich es in die Main-Methode, bzw. in die for-Schleife einbaue, also so:

```
double average = calcVerbrauch(differenz, liter[i]) / kilometer.length;
```
bekomme ich für jeden Wert den Durchschnitt, das ist aber die falsche Rechnung.
Wenn ich es außerhalb der Schleife programmiere, habe ich keinen Zugriff mehr auf liter_;
Bin glaub so langsam am Ende mit meinen Ideen.._

_EDIT:
Was genau ist mit static denn überhaupt gemeint?
Ich dachte static bedeutet gleich statische-Methode. Aber bedeutet statisch sein nicht so viel, dass man die Werte nicht mehr umändern kann? Ich kann ja damit dann weiter arbeiten und dann gibt es doch auch noch überladene Methoden ??
Und was genau ist mit dynamisch gemeint? _

_EDIT2:
Und wofür brauche ich void-Methoden wenn sie sowieso keinen Rückgabe, also kein return Wert haben?  
_


----------



## Thisor (24. Dez 2015)

Ich krieg den Gesamtdurchschnitt nicht raus, egal ob in der Main-Methode oder in einer neuen Methode, ich bekomme nur den Durchschnitt nur vom letzten Wert und komme nicht weiter...


```
public class TageBuch2 {
    public static void main(String[] args) {
        // Kilometerstand beim Tanken
        int[] kilometer = { 105000, 105756, 106320, 106900, 107543 };

        // getankter Treibstoff
        int[] liter = { 50, 45, 42, 48 };

        double differenz = 0;

        //ermittelt den Distanz wie viel Km jedes mal gefahren worden ist
        for (int i = 0; i < kilometer.length - 1; i++) {
            differenz = (kilometer[i] - kilometer[i + 1]) * -1;

            //Auswertung vom Durschnitt
            System.out.println("Der Verbrauch in Liter/100 Km : " + roundScale2(calcVerbrauch(differenz, liter)));

        }
        double average = 0;
        for (int i = 0; i < calcVerbrauch(differenz, liter); i++) {
            average = calcVerbrauch(differenz, liter) + calcVerbrauch(differenz, liter);
            // System.out.println(average);
            System.out.println(durchschnitt(differenz, liter));
        }
    }

    //Methode um Ergebniss zu runden
    private static double roundScale2(double d) {
        return Math.rint(d * 10) / 10;
    }

    //Methode um den Durchschnitt auszurechnen, wird in der Main wiedergegeben
    public static double calcVerbrauch(double differenz, int[] liter) {
        double verbrauch = 0;
        for (int i = 0; i < liter.length; i++) {
            verbrauch = (liter[i] * 100) / differenz;
        }
        return verbrauch;
    }

    //fail versuch um den gesamtdurchschnitt auszurechnen
    public static double durchschnitt(double differenz, int[] liter) {
        double verbrauch = 0;
        double durchschnitt = 0;
        for (int i = 0; i < liter.length; i++) {
            verbrauch = (liter[i] * 100) / differenz;
        }
        return durchschnitt += verbrauch;
    }
}
```


----------



## Thisor (24. Dez 2015)

So, habs endlich gelöst bekommen  

Kann ich die letzte Methode schöner gestalten? 
Oder geht es an sich viel leichter / einfacher als meine Art das Programmiert haben?

```
public class TageBuch2 {

    public static void main(String[] args) {

        // Kilometerstand beim Tanken
        int[] kilometer = { 105000, 105756, 106320, 106900, 107543 };

        // getankter Treibstoff
        int[] liter = { 50, 45, 42, 48 };

        double differenz = 0;
        double average = 0;

        // ermittelt den Distanz wie viel Km jedes mal gefahren worden ist
        for (int i = 0; i < kilometer.length - 1; i++) {
            differenz = (kilometer[i] - kilometer[i + 1]) * -1;

            // Auswertung vom Durschnitt
            System.out.println("Der Verbrauch in Liter/100 Km : " + roundScale2(calcVerbrauch(differenz, liter)));

            average += durchschnitt(differenz, liter);
        }
        System.out.println();
        System.out.println("Der Gesamtdurchschnitt beträgt : " + roundScale2(average / liter.length));

    }

    // Methode um Ergebniss zu runden
    private static double roundScale2(double d) {
        return Math.rint(d * 10) / 10;
    }

    // Methode um den Durchschnitt auszurechnen, wird in der Main wiedergegeben
    public static double calcVerbrauch(double differenz, int[] liter) {
        double verbrauch = 0;

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

            verbrauch = (liter[i] * 100) / differenz;

        }
        return verbrauch;

    }

    // fail versuch um den gesamtdurchschnitt auszurechnen
    public static double durchschnitt(double differenz, int[] liter) {
       
        double verbrauch = 0;
        double durchschnitt = 0;

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

            verbrauch = (liter[i] * 100) / differenz;

        }
        return durchschnitt += verbrauch;

    }
}
```


----------

