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
 
@Jardcore habe jetzt versuch deinen Code auch noch anders einzubauen, allerdings wird in der Konsole so immer ausgegeben, die Eingabe wäre ungültig. Wie könnte man das verändern, dass das funktioniert?
Java:
public static void ready(){
        System.out.println("Wenn du bereit bist, gib jetzt 'Ja' ein und bestätige mit 'Enter'.");
        Scanner Input = new Scanner(System.in);
        String regEx = "[Ja]";
        String Check = Input.next();
        while (true){
            if(Check.matches(regEx)){
                System.out.println("Los geht's!");
            }else{
                System.out.println("Ungültige Eingabe! Wenn du bereit bist, gib jetzt 'Ja' ein und bestätige mit 'Enter'.");
                Check = Input.next();
 
Generell sollte man niemals ein while(true) benutzten... das ist ein schlechter Stil ^^
könntest das schreiben:
Java:
    ...
        boolean isInputValid = false;
      
        do {
            input = Input.next();
            isInputValid = input.matches(regEx);
          
            if(isInputValid) {
                break;
            }
          
            System.out.println("Das von dir für Person " + person
                        + " eingegebene Alter ist ungültig. Bitte gib ein Neues ein.");
          
        } while(!isInputValid);
      
        return Integer.parseInt(input);
    }

P.S: in Java werden Variablennamen klein geschrieben und Methodennamen im CamelCase... also dasIstEinMethodenname()
 
Der Reguläre Ausdruck [Ja] bedeutet, dass entweder ein J oder ein a vorkommen soll. Aber ich denke mal, dass nicht geprüft werden sollte, ob der Ausdruck ein J oder a enthält. Daher wäre eher ein Ausdruck wie "^Ja$" oder "^[jJ][aA]$" angeraten.

^ steht für den Anfang und $ für das Ende.

Wenn man unsicher mit regulären Ausdrücken ist, würde ich immer einen online Regex Tester empfehlen. Z.B. unter https://regex101.com/.

Konrad
 
Es funktioniert auch wenn man einfach die eckigen Klammern weglässt
Dann braucht man gar keinen regulären Ausdruck sondern kann einfach zwei Strings vergleichen
 
Ok, ein paar Erläuterungen:
[ ... ] Definiert immer eine Auswahl. Also [0-9a-zA-Z] wäre ein Zeichen in einem der Bereiche von 0-9, a-z oder A-Z.
{ ... } Kann eine Anzahl definieren, also z.B. {1} genau ein Vorkommen (was default ist und weg gelassen werden könnte.) {5-7} wäre dann 5 bis 7 mal. Volles Beispiel wäre da z.B. [0-9]{3-10} steht für eine Zahl mit 3 - 10 Stellen.
* steht für beliebig viele vorkommen.
. steht für ein beliebiges Zeichen.
( ... ) Klammert einen Bereich und wird bei Regulären Ausdrücken für Rückgaben verwendet. Also ich könnte also id=([0-9)*) angeben und dann würde der Zahl hinter id= gesucht und die würde ich als ein match zurück bekommen.

Das ist aber nun wirklich eine ganz ganz minimale und oberflächige Beschreibung. Reguläre Ausdrücke sind recht komplex und hier kann ich nur jedem empfehlen, sich da mal intensiv ein paar Stunden mit auseinander zu setzen.
 
Wenn ich die Schleife so aufbaue, funktioniert das
Java:
while (true){
            if(Answer.matches(ready)){
                System.out.println("Los geht's!");
                return Answer;
            }else{
                System.out.println("Ungültige Eingabe! Wenn du bereit bist, gib jetzt 'Ja' ein und bestätige mit 'Enter'.");
                Answer = Input.next();
            }
        }
Kann ich die Methode - und damit die Schleife - auch anders schließen, also ohne return?

Edit:
Okay hat sich erledigt, habe die Schleife jetzt wie folgt aufgebaut, dann hat sich das auch mit dem while(true) ^^
Java:
while (!Answer.matches(ready)){
            System.out.println("Ungültige Eingabe! Wenn du bereit bist, gib jetzt 'Ja' ein und bestätige mit 'Enter'.");
            Answer = Input.next();
        }
 
Zuletzt bearbeitet:
Nein ich habe trotzdem nur eine. Meine ganze Methode für den "Bereit-Check" sieht so aus:
Java:
public static void Check(){
        System.out.println("Bist du bereit? Dann gib jetzt 'Ja' ein und bestätige mit 'Enter'.");
        Scanner Input = new Scanner(System.in);
        String ready = "Ja";
        String answer = Input.next();
        while (!answer.matches(ready)){
            System.out.println("Ungültige Eingabe! Wenn du bereit bist, gib jetzt 'Ja' ein und bestätige mit 'Enter'.");
            answer = Input.next();
        }
        System.out.println("Los geht's!");
    }
 
Ja, das funktioniert alles wunderbar 🙂 @JStein52

Konsole:
Folgende Situation: Wir haben 2 Gruppen A und B mit jeweils 2 Personen 1 und 2.
Von diesen beiden Gruppen soll jeweils das Gesamtalter bestimmt und beide Werte vergleichen werden.
Dazu musst du nun nacheinander das Alter von allen 4 Personen eingeben und mit 'Enter' bestätigen.
Bist du bereit? Dann gib jetzt 'Ja' ein und bestätige mit 'Enter'.
ja
Ungültige Eingabe! Wenn du bereit bist, gib jetzt 'Ja' ein und bestätige mit 'Enter'.
jaja
Ungültige Eingabe! Wenn du bereit bist, gib jetzt 'Ja' ein und bestätige mit 'Enter'.
januar
Ungültige Eingabe! Wenn du bereit bist, gib jetzt 'Ja' ein und bestätige mit 'Enter'.
NeinJaNeib
Ungültige Eingabe! Wenn du bereit bist, gib jetzt 'Ja' ein und bestätige mit 'Enter'.
NeinJaNein
Ungültige Eingabe! Wenn du bereit bist, gib jetzt 'Ja' ein und bestätige mit 'Enter'.
JaJa
Ungültige Eingabe! Wenn du bereit bist, gib jetzt 'Ja' ein und bestätige mit 'Enter'.
JaJ
Ungültige Eingabe! Wenn du bereit bist, gib jetzt 'Ja' ein und bestätige mit 'Enter'.
ja
Ungültige Eingabe! Wenn du bereit bist, gib jetzt 'Ja' ein und bestätige mit 'Enter'.
januar
Ungültige Eingabe! Wenn du bereit bist, gib jetzt 'Ja' ein und bestätige mit 'Enter'.
Ja8
Ungültige Eingabe! Wenn du bereit bist, gib jetzt 'Ja' ein und bestätige mit 'Enter'.
8Ja
Ungültige Eingabe! Wenn du bereit bist, gib jetzt 'Ja' ein und bestätige mit 'Enter'.
+Ja
Ungültige Eingabe! Wenn du bereit bist, gib jetzt 'Ja' ein und bestätige mit 'Enter'.
Ja.
Ungültige Eingabe! Wenn du bereit bist, gib jetzt 'Ja' ein und bestätige mit 'Enter'.
JA
Ungültige Eingabe! Wenn du bereit bist, gib jetzt 'Ja' ein und bestätige mit 'Enter'.
jA
Ungültige Eingabe! Wenn du bereit bist, gib jetzt 'Ja' ein und bestätige mit 'Enter'.

macht alles keine Probleme
Was dachtest du denn, könnte daran Probleme machen?
 
Zuletzt bearbeitet:
Hmm ... Du meinst bestimmt anders herum. ready ist ja schon lower case somit muss answer zu lowercase werden. Eine Überprüfung auf einen genauen String würde ich aber immer mit equals bzw. equalsIgnoreCase machen.

Also statt answer.toLowerCase().matches(ready) würde ich answer.equalsIgnoreCase(ready) schreiben.

Oder wenn man das schon per regulärem Ausdruck machen will, dann würde ich den regulären Ausdruck anpassen. Das wäre dann noch viel effektiver. Und das könnte man über die regulären Ausdrücke
[jJ][aA]
(?i)ja
erreichen. Evtl. gibt es noch mehr Möglichkeiten, aber das ist, was mir so direkt einfällt.
 
Ja, das sind zwei reguläre Ausdrücke.
[jJ] steht für ein kleines j oder ein großes. Analog das [aA]
(?i) ist ein modifier - i ist dabei insensitive case. Wenn man dies ausschalten wollte, dann ginge dies mit (?-i).

Also als Beispiel:
(?i)abc(?-i)dEf
abc ist case sensitive, d.h. bei dem Teil ist die Groß-/Kleinschreibung egal.
aber dEf ist wieder case sensitive, d.h. es muss wirklich ein kleines d, großes E und kleines f sein.
 

Zurück
Oben