Methoden Auslagerung von Code aus der "main" Methode sinnvoll?

TheMenox

Aktives Mitglied
Erneut einen guten Abend zusammen!

Es geht um diesen Code (Kommentare nicht beachten 😀):
Java:
// Skills von Tutorial Parts 1 - 10

package de.panjutorialsskillstest.java;

import java.util.Scanner;

public class PanjutorialsSkillsTest {


    public static void main(String[] args) {
       
        int A1, A2, B1, B2;
       
        /**String Check = "Ja";
        *String Answer;
        */
       
        /**    System.out.println("Wenn du bereit bist, gib jetzt 'Ja' ein.");
        *     Answer = Input.next();
        *    while (Answer != Check){
        *        System.out.println("Eingabe ungültig. Wenn du bereit bist, gib jetzt 'Ja' ein.");
        *        Answer = Input.next();
        *    }
        *FUNKTIONIERT NICHT?!
        */
       
        // WENN IM NACHFOLGENDEN KEINE ZAHL EINGEGEBEN WIRD; STÜRZT DAS PROGRAMM AB!!! BEHEBEN!!!
       
        declaration();
       
        Scanner Input = new Scanner(System.in);
       
        System.out.println("Alter von Person A1 bitte:");
        A1 = Input.nextInt();
        while (A1 < 0){
            System.out.println("Das von dir für Person A1 eigegebene Alter ist ungültig. Bitte gib ein Neues ein.");
            A1 = Input.nextInt();
        }
       
        System.out.println("Alter von Person A2 bitte:");
        A2 = Input.nextInt();
        while (A2 < 0){
            System.out.println("Das von dir für Person A2 eigegebene Alter ist ungültig. Bitte gib ein Neues ein.");
            A2 = Input.nextInt();
        }
       
        System.out.println("Alter von Person B1 bitte:");
        B1 = Input.nextInt();
        while (B1 < 0){
            System.out.println("Das von dir für Person B1 eigegebene Alter ist ungültig. Bitte gib ein Neues ein.");
            B1 = Input.nextInt();
        }
       
        System.out.println("Alter von Person B2 bitte:");
        B2 = Input.nextInt();
        while (B2 < 0){
            System.out.println("Das von dir für Person B2 eigegebene Alter ist ungültig. Bitte gib ein Neues ein.");
            B2 = Input.nextInt();
        }
       
        Input.close();
       
        outputresult(A1, A2, B1, B2);
    }       
   
    public static void declaration(){
   
        System.out.println("Folgende Situation: Wir haben 2 Gruppen A und B mit jeweils 2 Personen 1 und 2.");
        System.out.println("Von diesen beiden Gruppen wollen wir jeweils das Gesamtalter bestimmen und herausfinden, welche Gruppe insgesamt älter ist.");
        System.out.println("Dazu musst du nun nacheinander das Alter von allen 4 Personen eingeben und mit 'Enter' bestätigen.");
    }
   
    public static void outputresult(int A1, int A2, int B1, int B2){
       
        System.out.println("Das Gesamtalter von Gruppe A ist " + totAge(A1, A2) + " Jahre.");
        System.out.println("Das Gesamtalter von Gruppe B ist " + totAge(B1, B2) + " Jahre.");
       
        //Nicht mit Switch/Case möglich, da damit nur primitive Vergleiche gemacht werden können (kein Größer/Kleiner)!
        if (totAge(A1, A2) > totAge(B1, B2)){
            System.out.println("Gruppe A ist insgesamt " + totAgeDiff(totAge(A1, A2), totAge(B1, B2)) + " Jahre älter als Gruppe B.");
        }else if (totAge(A1, A2) < totAge(B1, B2)){
            System.out.println("Gruppe B ist insgesamt " + totAgeDiff(totAge(A1, A2), totAge(B1, B2)) + " Jahre älter als Gruppe A.");
        }else{
            System.out.println("Gruppe A und Gruppe B sind insgesamt gleich alt.");
        }
    }
   
    public static int totAgeDiff (int totAgeA, int totAgeB) {
       
        return Math.abs(totAgeA - totAgeB);
    }
   
    public static int totAge (int Age1, int Age2) {
       
        return Age1 + Age2;
    }
}
1.) Ist es bei diesem Code sinnvoll, die Methoden "declaration" und "outputresult" zu erstellen und in der "main" Methode aufzurufen - so wie ich es hier gemacht habe - oder sollte man deren Inhalt direkt in der "main" Methode integriert lassen?

2.) Könnte man hier diesen Teil des oben stehenden Codes
Java:
Scanner Input = new Scanner(System.in);
       
        System.out.println("Alter von Person A1 bitte:");
        A1 = Input.nextInt();
        while (A1 < 0){
            System.out.println("Das von dir für Person A1 eigegebene Alter ist ungültig. Bitte gib ein Neues ein.");
            A1 = Input.nextInt();
        }
       
        System.out.println("Alter von Person A2 bitte:");
        A2 = Input.nextInt();
        while (A2 < 0){
            System.out.println("Das von dir für Person A2 eigegebene Alter ist ungültig. Bitte gib ein Neues ein.");
            A2 = Input.nextInt();
        }
       
        System.out.println("Alter von Person B1 bitte:");
        B1 = Input.nextInt();
        while (B1 < 0){
            System.out.println("Das von dir für Person B1 eigegebene Alter ist ungültig. Bitte gib ein Neues ein.");
            B1 = Input.nextInt();
        }
       
        System.out.println("Alter von Person B2 bitte:");
        B2 = Input.nextInt();
        while (B2 < 0){
            System.out.println("Das von dir für Person B2 eigegebene Alter ist ungültig. Bitte gib ein Neues ein.");
            B2 = Input.nextInt();
        }
       
        Input.close();
in eine (oder mehrere) Methode(n) auslagern und diese dann in der "main" Methode aufrufen? Wenn ja, wie und ist das überhaupt sinnvoll?

Schon mal Danke im Voraus für alle Hilfe und
LG TheMenox
 
Ich hatte da was Ähnliches gemacht. Sieh mal unten den Code an.
Das was du abfragst ist prinzipiell immer das Gleiche.
Du könntest genauso eine Methode machen wie einlesen();. Dann wird das Ganze viel kürzer.
Den Text "Alter von Person B2 bitte:
könntest du vllt. vereinfachen, indem du 1,2.,3. Person sagst, was du einfach mit einer Schleife erledigen kannst.

Die Stärke von Java ist es ja gerade, dass sie objektorientiert ist.
Deshalb macht es schon Sinn so viel wie möglich in Methoden zu packen und auch Klassen zu verwenden.


Java:
public class Zinseszins {

    double betrag;
    double prozent;
    int laufzeit;

    public Zinseszins(double betrag, double prozent, int laufzeit) {

        this.betrag = betrag;
        this.prozent = prozent;
        this.laufzeit = laufzeit;

    }

    public double ergebnisBerechnen() {
        betrag = betrag *(1+prozent);
        return betrag;
    }


}

Java:
import java.util.Scanner;
import javax.swing.JOptionPane;

public class Test {

    static double number;

    public static double einlesen() {
        try {
            Scanner sc = new Scanner(System.in);
            number = Integer.parseInt(sc.nextLine());
            System.out.println("Du hast " + number + "eingegeben.");
       
        } catch (Exception e) {
            JOptionPane.showMessageDialog(null, "Sie müssen dafür eine Zahl eingegeben");
            System.exit(1);
        }
        return number;
    }


    public static void main(String[] args) {
   
        System.out.println("Geben Sie einen Betrag ein: ");
        einlesen();
        double betrag = number;
        System.out.println("Geben Sie für Prozent eine Zahl in Prozent ein (zB 0.05 für 5%): ");
        einlesen();
        double prozent = number;
        System.out.println("Geben Sie eine Laufzeit in Jahren ein (Ganzzahl): ");
        einlesen();
        int laufzeit = (int) number;
           
        Zinseszins zinsesZins = new Zinseszins(betrag, prozent, laufzeit);
 
        for(int i=0; i <= laufzeit; i++){
       
            System.out.println("Das Kapital am Ende des " + i + ". Jahres betraegt " + zinsesZins.ergebnisBerechnen());
        }

    }

}
 
man kann da noch sehr viel auslagern.
Insbesondere unterscheiden sich all deine while schleifen so gut wie gar nicht. Erstell eine Methode um die Eingabe einzulesen:
Java:
public static int readAge(String text) {
  System.out.println(text);
  while(true) {
    int result = Input.nextInt();
    if(result < 0)
      System.out.println("Das eingegebene Alter ist ungültig!");
    else
      return result;
  }
}
Anstatt nun vier fast identische Schleifen zu haben, hast nun nur noch 4 Aufrufe:
Java:
int a1 = readAge("Alter von Person A1 eingeben:");
int a2 = readAge("Alter von Person A2 eingeben:");
int b1 = readAge("Alter von Person B1 eingeben:");
int b2 = readAge("Alter von Person B2 eingeben:");
 
Dass ich dieses Repetitive mit den vier Personen auch zu einem zusammen fassen kann, hatte ich mir auch schon gedacht, ich weiß nur nicht, wie ich das lösen könnte...
Und zu deinem Code @javastudent25 : Ich habe gerade vor drei tagen oder so mit Java angefangen und verstehe davon deshalb vllt gerade mal die Hälfte... 😀
 
Das ist eine gute Frage 😉.
Ich bin auch gerade dabei Java zu lernen.
Ich kann dir leider keine genaue Antwort geben und ich kanns dir nicht erklären, aber er setzt while(true). Daraufhin läuft die Schleife endlos. Darin wird abgefragt, ob das Alter kleiner ist als 0, wenn die Bedinung nicht stimmt folgt else Befehl und result wird zurückgegeben..
Ich weiss jetzt nicht, wofür die while gut ist, denn das Ganze müsste auch so funktionieren:

Aber vllt. kann das jemand anders noch beantworten, würde mich nämlich auch interessieren.


Java:
    public static int readAge(String text) {
        Scanner Input = new Scanner(System.in);
        System.out.println(text);

        int result = Input.nextInt();
        if (result < 0) {
            System.out.println("Das eingegebene Alter ist ungültig!");
        }
        return result;

    }
 
PS: Ich habe vergessen zu sagen, dass nach Else bzw. nach der Rückgabe von result das Ganze aus der Endlosschleife dann automatisch rausspringt..

den Code habe ich oben auch nachbearbeitet..
 
Sorry muss mich korrigieren:
Die while Schleife macht natürlich schon Sinn, weil man nach der Eingabe eines Wertes unter 0 immer noch in der while-Schleife bleibt, bis ein korrekter Wert eingegeben wurde.
 
@thecain die Schleife wird durch das return beendet? wird der Wert sozusagen aus dem Scanner gelöscht sobald der returned wurde oder wie funktioniert das?
@javastudent25 ja eben, sonst wird das nur ein Mal geprüft und dann weiter gemacht. Das hatte ich schon versucht bevor ich mir dann angeguckt habe, wie man die while Schleife verwendet 🙂
@InfectedBytes hab deinen Vorschlag übernommen, jetzt funktioniert alles, Danke! 🙂

Jetzt meckert das Programm nur rum, dass der Scanner nie geschlossen wird, aber wenn ich den so einfüge:
Java:
public static int inputhandling(String Person){
       
        System.out.println("Alter von Person " + Person + " bitte:");
       
        Scanner Input = new Scanner(System.in);
        while (true){
            int inputAge = Input.nextInt();
            if(inputAge <0)
                System.out.println("Das von dir für Person " + Person + " eigegebene Alter ist ungültig. Bitte gib ein Neues ein.");
            else return inputAge;
        }
        Input.close();
    }
zeigt der den Fehler "unreachable code" an. Kann man den Scanner irgendwie schließen, ohne dass das Programm rummeckert?
 
@thecain die Schleife wird durch das return beendet? wird der Wert sozusagen aus dem Scanner gelöscht sobald der returned wurde oder wie funktioniert das?
zeigt der den Fehler "unreachable code" an. Kann man den Scanner irgendwie schließen, ohne dass das Programm rummeckert?

Ich bin mal so frei und antworte dir. Durch das return wird die ganze Methode beendet. Ein return steht in einer Methode immer für einen Abschluss. Nach einem return werden keine weiteren Funkionen aufgerufen, Werte zugewiesen oder Auswertungen getätigt.

Deine Methode ist nach dem return fertig. Alles, was in der Methode gemerkt oder getan wurde, wird als abgeschlossen behandelt. Wenn du dir also Werte in einer Methode merkst, die danach nie wieder im restlichen Programmcode als Referenz/Verweis darauf noch existieren, werden diese irgendwann aus dem Speicher entfernt. Die return-Anweisung hat aber nichts mit einem Löschen direkt zu tun. Hierbei ist eher das Thema Sichtbarkeit (public, private, package, ...) entscheidend.

@thecain zeigt der den Fehler "unreachable code" an. Kann man den Scanner irgendwie schließen, ohne dass das Programm rummeckert?

Wie du es behebst, weißt du nun ja. Aber wieso ist dem so? Ich erkläre es dir kurz:

Java basiert auf der Logik, dass jeder Ausdruck vom Compiler überprüfbar sein muss. Deine Schleife basiert auf Benutzereingaben. Wenn der Benutzer unterschiedliches eingibt, wird unterschiedliches geschehen. Kurz: Entscheidungen basieren in diesem Fall auf Runtime-Ebene. Das kann der Compiler nicht auswerten, denn er weiß ja nicht was der Benutzer eingibt und entsprechend ist er überfragt.

Daraufhin sagt er dir, dass du Code hast, der nie zu erreichen ist bzw. ausführbar sein wird. So möchte man in Java Logikfehler und undefinierte wenn-dann-Probleme verhindern.
 
@VirtualIndex super, Vielen Dank für die verständliche Erklärung! 🙂
Aber kommt das mit dem unreachable Code an der Stelle nicht daher, dass die Methode durch das return vorher geschlossen wurde? So hätte ich das jetzt nach deiner vorherigen Erklärung verstanden
 
Das kannst du ganz leicht testen @TheMenox: Ändere den Rückgabewert auf void, statt int und mach statt dem return einfach mal ein System.out.println("Das Alter war gültig!"); an.

Wenn der Code dann immer noch unerreichbar ist, wird es wohl mit dem unvorhersehbaren Ablauf zu tun haben, statt mit dem (nicht mehr existenten) return.

Letztlich dürfte aber beides für einen unerreichbaren Code sorgen: ein unklarer Programmablauf zu Kompilierzeit und ein Code in einer Methode, die bereits vorher zum Abbruch/Beenden aufgefordert wurde.
 
Zuletzt bearbeitet:
nur das "Input.close();" (meine Scannervariable heißt Input) wurde als unreachable markiert

noch eine Frage zur while(true) Schleife:
bedeutet das true, dass die Schleife solange durchlaufen wird, wie die Bedingung erfüllt ist, und wenn die nicht mehr erfüllt ist, wird die Schleife beendet?
 
So an Alle die es interessiert:
Hier ist mein (vorerst) fertiger Code:

Java:
// Skills von Tutorial Parts 1 - 10
// WENN FÜR "inputAge" KEINE ZAHL EINGEGEBEN WIRD; STÜRZT DAS PROGRAMM AB!!! BEHEBEN!!!
// Differenzierung in "outputresult nicht mit Switch/Case möglich, da damit nur primitive Vergleiche gemacht werden können (kein Größer/Kleiner)!

/**String Check = "Ja";
*String Answer;
*System.out.println("Wenn du bereit bist, gib jetzt 'Ja' ein.");
*     Answer = Input.next();
*    while (Answer != Check){
*        System.out.println("Eingabe ungültig. Wenn du bereit bist, gib jetzt 'Ja' ein.");
*        Answer = Input.next();
*    }
*FUNKTIONIERT NICHT?!
*/

package de.panjutorialsskillstest.java;

import java.util.Scanner;

public class PanjutorialsSkillsTest {

    public static void main(String[] args) {          
        declaration();      
        int A1 = inputhandling("A1");
        int A2 = inputhandling("A2");
        int B1 = inputhandling("B1");
        int B2 = inputhandling("B2");
        outputresult(A1, A2, B1, B2);
    }  
  
    public static void declaration(){  
        System.out.println("Folgende Situation: Wir haben 2 Gruppen A und B mit jeweils 2 Personen 1 und 2.");
        System.out.println("Von diesen beiden Gruppen wollen wir jeweils das Gesamtalter bestimmen und herausfinden, welche Gruppe insgesamt älter ist.");
        System.out.println("Dazu musst du nun nacheinander das Alter von allen 4 Personen eingeben und mit 'Enter' bestätigen.");
    }
  
    public static int inputhandling(String Person){      
        System.out.println("Alter von Person " + Person + " bitte:");
        Scanner Input = new Scanner(System.in);
        int inputAge = Input.nextInt();
        while (true){
            if(inputAge < 0)
                System.out.println("Das von dir für Person " + Person + " eigegebene Alter ist ungültig. Bitte gib ein Neues ein.");
            else{
                Input.close();
                return inputAge;
            }
        }
    }
  
    public static void outputresult(int A1, int A2, int B1, int B2){      
        System.out.println("Das Gesamtalter von Gruppe A ist " + totAge(A1, A2) + " Jahre.");
        System.out.println("Das Gesamtalter von Gruppe B ist " + totAge(B1, B2) + " Jahre.");
        if (totAge(A1, A2) > totAge(B1, B2)){
            System.out.println("Gruppe A ist insgesamt " + totAgeDiff(totAge(A1, A2), totAge(B1, B2)) + " Jahre älter als Gruppe B.");
        }else if (totAge(A1, A2) < totAge(B1, B2)){
            System.out.println("Gruppe B ist insgesamt " + totAgeDiff(totAge(A1, A2), totAge(B1, B2)) + " Jahre älter als Gruppe A.");
        }else{
            System.out.println("Gruppe A und Gruppe B sind insgesamt gleich alt.");
        }
    }
  
        public static int totAgeDiff (int totAgeA, int totAgeB) {      
            return Math.abs(totAgeA - totAgeB);
        }
  
        public static int totAge (int Age1, int Age2) {      
            return Age1 + Age2;
        }
}

Noch mal Vielen Dank an Alle, die mit ihrer Hilfe (Erklärungen, Codes) dazu beigetragen haben!!!
 
Zuletzt bearbeitet:
nur das "Input.close();" (meine Scannervariable heißt Input) wurde als unreachable markiert

Das steht nicht zur Diskussion 😉, nur weshalb es unerreichbar ist, ist die Frage.

noch eine Frage zur while(true) Schleife:
bedeutet das true, dass die Schleife solange durchlaufen wird, wie die Bedingung erfüllt ist, und wenn die nicht mehr erfüllt ist, wird die Schleife beendet?

Jede Schleife wird solange durchlaufen, wie die Bedingung gilt. Ausnahme ist die do-while-Schleife, welche immer mindestens 1 mal durchläuft. Bei jeder Bedingung ist am Ende das Ergebnis ein boolescher Ausdruck.

Was heißt das nun konkret? Jede Bedingung muss mit wahr (true) oder falsch (false) beantwortbar sein. Von mathematischen Aussagen bis hin zu Vergleichen ist somit alles möglich. true als Bedingung ist natürlich weiterhin true/wahr. Denn was soll aus einem einzig wahren denn herauskommen, außer etwas einzig wahres? Also bleibt die Bedingung erfüllt. Es gibt in dem Fall ja auch nichts, was sich ändern könnte, wie z. B. irgendeine Variable.
 
Nein, im Gegenteil! Die Anzahl der Durchläufe hängt strikt mit der Bedingung zusammen! Deine Schleife läuft endlos, weil deine Bedingung (wahr ist und bleibt immer wahr!) immer wahr ergibt. Also wird ein Durchlauf getätigt, erneut geprüft, es bleibt wahr, also nochmal durchlaufen, usw.

Würde deine Bedingung nach dem 10. Mal plötzlich false/unwahr werden, dann wird auch deine Schleife kein 11. Mal durchlaufen 😉.

Ich gehe nun schlafen und kann morgen leider nicht helfen. Andere werden dir sicher genauso schnell und kompetent weiterhelfen können. Viel Glück mit Java und lass dich nicht von Menschen verunsichern, die Java konstant scheiße finden.
 
Genau so ist es @TheMenox! Stell dir das bildlich vor: Wenn du dein Haus abreißt, ist der permanent laufende Föhn auch definitiv vernichtet. So ist es auch mit deiner Schleife. Wenn du die ganze Methode vernichtest, wird auch die relativ kleine darin liegende Schleife tödlich verunglücken 😉. Du kannst ja auch kein Auto verschrotten und das Autoradio läuft weiter 😀.
 
Hey ho,

anscheinend machst du keine Prüfung ob überhaupt ein gültiges Alter eingegeben wurde, deswegen würde ich die ganze while Geschichte rausschmeißen. Wenn man einfach mal einen Buchstaben eingibt, stürzt dein Programm sowieso ab. Deshalb ist das an der Stelle nur unnötig. Gehe lieber davon aus das der User ein Alter über 0 angibt, denn wenn man schon anfängt etwas zu prüfen, sollte man alle Fälle abdecken. (z.B durch einen regulären Ausdruck der nur Ganze Zahle zulässt)

Insgesamt würde ich das ganze objektorientierter Betrachten und vielleicht ein Group Objekt erstellen, welches die Zählung vornimmt. Dabei kann man sogar noch Comparable implementieren und damit den Vergleich zweier Gruppen vornehmen.
Spontan fällt mir da sowas ein:
Java:
public class Group implements Comparable<Group> {
  
    private static int LESS = 1;
    private static int EQUAL = 0;
    private static int GREATER = -1;
  
    private String name;
    private int totalAge;
  
    public Group(String name) {
        this.name = name;
    }
  
    public void addAge(int age) {
        this.totalAge += age;
    }
  
    public String getName() {
        return name;
    }
  
    public int getTotalAge() {
        return totalAge;
    }

    @Override
    public int compareTo(Group o) {
        if(this.getTotalAge() < o.getTotalAge()) {
            return LESS;
        }
        if(this.getTotalAge() > o.getTotalAge()) {
            return GREATER;
        }
        return EQUAL;
    }
}

Dinge die du über die Console erfragen willst, kannst du in einer einzelnen Methode abfragen und nur einen einzigen Scanner benutzen.
Java:
    private int askQuestion(String question) {
        System.out.println(question);
        return input.nextInt();
    }
Vielleicht auch noch mehr Objekte spendieren die dir helfen Codeduplizierung zu vermeiden.

Mit einer Doppelten Schleife könntest du dann wiederrum

Beste Grüße,
Jar

P.S: Zum Vergleichen zweier Group Objekte kannst du dann einfach groupA.compareTo(groupB) aufrufen. Und das gibt dir einen Wert von -1 bis 1 zurück
 
Zuletzt bearbeitet:
Hier einmal der genannte objektorientiertere Ansatz:
Die Hauptklasse ist nur der Einstiegspunkt in das Programm...
Java:
public class Main {
    public static void main(String[] args) {
        new GroupAgeComperator(2,2);
   }
}

Die eigentliche Arbeit wird im GroupAge Comperator gemacht, dieser besitzt 2 Gruppen mit variabler Größe. Es werden alle Abfrage in Verschachtelten Schleifen durchlaufen. Insgesamt habe ich auf Fehlerüberprüfungen verzichtet.

Java:
public class GroupAgeComperator {
    private final Scanner input = new Scanner(System.in);

    private static final int EQUAL = 0;
    private static final int LESS = 1;
    private static final int GREATER = -1;

    private Group groupA;
    private Group groupB;

    public GroupAgeComperator(int sizeOfGroupA, int sizeOfGroupB) {
        groupA = new Group("A", sizeOfGroupA);
        groupB = new Group("B", sizeOfGroupB);
    
        startToWork();
    }

    private void startToWork() {
        showDeclaration();
        askGroup(groupA, groupB);
        showResult();
    }

    private void showDeclaration(){
        System.out.println("Folgende Situation: Wir haben 2 Gruppen A und B mit jeweils 2 Personen 1 und 2.");
        System.out.println("Von diesen beiden Gruppen wollen wir jeweils das Gesamtalter bestimmen und herausfinden, welche Gruppe insgesamt älter ist.");
        System.out.println("Dazu musst du nun nacheinander das Alter von allen 4 Personen eingeben und mit 'Enter' bestätigen.");
    }

    private void showResult() {
    
        System.out.println(groupA);
        System.out.println(groupB);
    
        switch(groupA.compareTo(groupB)) {
        case EQUAL:
            System.out.println("Beide Gruppen sind gleich alt");
            break;
        case LESS:
            showCompareText("jünger");
            break;
        case GREATER:
            showCompareText("älter");
            break;
        }
    }

    private void showCompareText(String text) {
        System.out.println(String.format("Gruppe %s ist insgesamt %d Jahre %s als Gruppe %s",
                groupA.getName(),
                groupA.differenceTo(groupB),
                text,
                groupB.getName()));
    }

    private int ask(String question) {
        System.out.print(question);
        return input.nextInt();
    }

    private void askGroup(Group... groups) {
        for(Group group : groups) {
            for(int peopleNum = 0; peopleNum < group.getSize(); peopleNum++) {
                group.addAge(
                        ask(String.format("Alter von Person %d in Gruppe %s bitte:",
                                peopleNum + 1,
                                group.getName())));
            }
        }
    }
}

Die Group Klasse ermöglicht vereinfachten Zugriff auf die Daten und ist auch nur für die Datenhaltung zuständig, hier wird nichts weiter gemacht als die Eingaben des Users zu speichern und bei Bedarf komfortabel aufbereitet (compareTo, differenceTo, toString).
Java:
public class Group implements Comparable<Group> {

    private String name;
    private int totalAge;

    private int size;

    public Group(String name, int size) {
        this.name = name;
        this.size = size;
    }

    public void addAge(int age) {
        this.totalAge += age;
    }

    public String getName() {
        return name;
    }

    public int getTotalAge() {
        return totalAge;
    }

    public int getSize() {
        return size;
    }

    public int differenceTo(Group o) {
        return Math.abs(this.getTotalAge() - o.getTotalAge());
    }

    @Override
    public int compareTo(Group o) {
        if(this.getTotalAge() < o.getTotalAge()) {
            return 1;
        }
        if(this.getTotalAge() > o.getTotalAge()) {
            return -1;
        }
        return 0;
    }

    @Override
    public String toString() {
        return "Das Gesamtalter von Gruppe "+ name +" ist " + totalAge + " Jahre.";
    }
}

Ich hoffe das hilft auch mal weg von der reinen Main bzw mainMethode zu kommen. In der objektorientierten Programmierung sollte man versuchen alles in Objekte zu kapseln.
 
Zuletzt bearbeitet:
@Jardcore Als erstes ein mal Dankeschön für deine sehr ausführliche Antwort + Code!
Allerdings habe ich erst vor ein paar Tagen mit Java angefangen und verstehe deswegen den Großteil deines Codes nicht xD Da ich aber sowieso vorhabe mit meinen wachsenden Skills dieses kleine sinnlose Programm weiterzuentwickeln und zu verbessern, speicher ich mir deinen Code einfach mal ab und gucke mir den später noch mal an😀
 
Ahh okay 🙂
Dann geb ich dir einfach paar allgemeine Tipps:
Versuche bei Aufgaben immer von der Realität auf die Java Welt zu schließen. Da Java eine objektorientierte Sprache ist versucht man auch hier die Realität möglichst gut abzubilden.
Google oder belese dich am besten wie man Objekte Instanziert, was überhaupt eine Instanz ist. (Stichwort: new)
 
Ich weiß nicht obs schon jemand gesagt hat (wenn ja ignoriert das einfach) aber die while schleife oben in deinem Kommentar funktioniert nicht weil man Strings in Java nicht mit == oder != vergleicht. Probiers mal mit equals.
 
Moin,

Ich weiß nicht obs schon jemand gesagt hat (wenn ja ignoriert das einfach) aber die while schleife oben in deinem Kommentar funktioniert nicht weil man Strings in Java nicht mit == oder != vergleicht. Probiers mal mit equals.
Zum einen das 🙂

Zum anderen ist FUNKTIONIERT NICHT?! keine Fehlerbeschreibung! 🙄
Du solltest immer dabei schreiben, was genau nicht funktioniert (Was erwartest Du? Was passiert stattdessen?)

Gruß Klaus
 
(@InfectedBytes) Habe übrigens gerade ein Problem bei der "while(true)" Schleife entdeckt:
wenn ein ungültiger Wert - also ein Wert < 0 - eingegeben wird, wird das print out Statement unendlich ausgeführt und das Programm läuft nicht normal weiter. Habe das deswegen wieder ohne while(true) und if/else gemacht, funktioniert ja auch 🙂
 
Wie gesagt würde ich die Prüfung komplett entfernen, oder halt alles prüfen. Wenn du einen Buchstaben eingibst wird dein Programm auch abstürzen.

Du kannst übrigens eleganter Prüfen ob deine Eingabe korrekt ist, wenn du einen regulären Ausdruck benutzt.

Java:
String regEx = "[1-9]{1}[0-9]*";
String input;
if(input.matches(regEx)) {
    // do Something
}

regEx beschreibt hierbei eine ganze Zahl ohne führende 0, dass heißt die if Bedingung ist nur erfüllt wenn ein gültiger Wert in deinem Input vorkommt.

Noch genauer gesagt: Die erste Ziffer muss eine 1 2 3 4 5 6 7 8 oder 9 ([1-9])sein und zwar nur 1 mal ({1}) und danach darf beliebig oft oder keinmal (*) eine Zahl von 0 - 9 ([0-9]) kommen.
 
Zuletzt bearbeitet:
Das mein Programm bei einem Buchstaben abstürzt habe ich gemerkt, wusste aber nicht wie ich das beheben kann, das passiert doch aber auch, wenn ich gar nichts prüfe oder nicht?

Und dein Code schließt auch Buchstaben und Zeichen aus?
 
(@InfectedBytes) Habe übrigens gerade ein Problem bei der "while(true)" Schleife entdeckt:
wenn ein ungültiger Wert - also ein Wert < 0 - eingegeben wird, wird das print out Statement unendlich ausgeführt und das Programm läuft nicht normal weiter. Habe das deswegen wieder ohne while(true) und if/else gemacht, funktioniert ja auch 🙂
liegt daran, dass du einen Scanner verwendest und nextInt liest zwar bis zum nächsten \n, dieses wird aber nicht aus dem Puffer gelöscht. Daher müsstest du das übrig gebliebene \n erst entfernen
 
Ach so, mein Problem war gerade wieder, dass die Schleife durch das true, was ich wieder verwendet hatte unendlich durchläuft. Jetzt habe ich das einfach so geändert, so funktioniert das wieder
Java:
public static int inputhandling(String Person){       
        System.out.println("Alter von Person " + Person + " bitte:");
        Scanner Input = new Scanner(System.in);
        String regEx = "[1-9]{1}[0-9]*";
        String input = Input.next();
        while (true){
                if(input.matches(regEx)) {
                    return Integer.parseInt(input);               
                }else {
                    System.out.println("Das von dir für Person " + Person + " eingegebene Alter ist ungültig. Bitte gib ein Neues ein.");
                    input = Input.next();
                }   
        }
    }
 

Zurück
Oben