Kommandozeilenparameter startsWith("...")

maxmuster987

Aktives Mitglied
Ich möchte, dass wenn der Benutzer in der Kommandozeile Parameter eingibt, und nicht einer dieser Parameter mit einem "FH" startet, das Programm abbricht mit der Fehlermeldung "Fehlercode \"FHxxx\" nicht vorhanden - Fuellhoehe OK".

Aber falls jetzt irgendwo ein FHxxx drin vorkommt, dann soll das Ganze nicht abbrechen und auch keine Fehlermeldung ausgegeben werden.

Mein Programm aktuell gibt aber trotzdem eine Fehlermeldung aus, auch wenn ein FHxxx irgendwo in den Parametern drin steht. Es geht hierbei um Zeile 19-25.
Allerdings wenn der Parameter mit FH direkt zu Beginn steht, dann ist alles in Orndung, dann wird keine Fehlermeldung ausgegeben.

Eingabe: FH232 XL232 KO233 -> liefert richtiges Ergebnis
Eingabe: XL232 KO233 FH232 -> liefert Fehlermeldung, dass FH nirgendwo vorkommt, obwohl das nur am Ende steht, hier hätte eigentlich selbiges Ergebnis wie oben herauskommen müssen
Eingabe: XL232 KO233 KK222 -> liefert richtiges Ergebnis, dass nirgendwo FH vorkommt


Ich sage ja in meinem Code: starte bei i=0 bis kleiner der Anzahl der Kommandozeilenparameter.
WENN ein String NICHT mit FH startet, innerhalb dieses Intervalls, dann gib die Fehlermeldung aus, dass FH nicht vorhanden ist.

Ich "sehe" meinen Fehler, aber ich weiß nicht wie ich den behebe. Denn wenn die erste Eingabe kein FH ist, dann spuckt er logischerweise direkt eine Fehlermeldung aus, das will ich ja nicht. Der soll ja erst alles komplett durchlaufen und wenn er dann nirgendwo ein FH gefunden hat, dann ist es ok eine Fehlermeldung auszugeben.
So sucht er ja quasi nur den ersten String und liefert sofort Fehlermeldung, wenn es kein FH ist.


Java:
import java.io.*;
import javax.swing.*;
import java.util.*;

public class Uebung {
    public static void main (String[] args) {
        int KoZeiPa = args.length;
        int i=0;
       
        System.out.println("===========================================");
        System.out.println("=== Fuellstandsregelung eines Extruders ===");
        System.out.println("===========================================");
       
        if(KoZeiPa==0) {
            System.out.println("Keine Fehlercodes -- Extruder in Ordnung");
            System.out.println("--> Programmende");
        }
       
        for(i=0; i<KoZeiPa; i++) {
            if(!(args[i].startsWith("FH"))) {
                System.out.println("Fehlercode \"FHxxx\" nicht vorhanden - Fuellhoehe OK");
                break;
            }
        break;
        }
       
       
       
       
        System.exit(0);  
    }
}
 

fhoffmann

Top Contributor
Du kannst vor der for-Schleife eine boolsche Variable definieren boolean fhGefunden = false;.
In der for-Schleife setzt du die Variable auf true, sobald du FH findest.
Und nach der for-Schleife kannst du abfragen, ob die Variable immer noch auf false steht.
 

maxmuster987

Aktives Mitglied
Meinst du das so?

Java:
import java.io.*;
import javax.swing.*;
import java.util.*;

public class Uebung {
    public static void main (String[] args) {
        int KoZeiPa = args.length;
        int i=0;
        final int d = 50;
        final double alpha = 5.;
        String eing = "";
        boolean fhGefunden = false;
        
        System.out.println("===========================================");
        System.out.println("=== Fuellstandsregelung eines Extruders ===");
        System.out.println("===========================================");
        
        if(KoZeiPa==0) {
            System.out.println("Keine Fehlercodes -- Extruder in Ordnung");
            System.out.println("--> Programmende");
        }
        
        for(i=0; i<KoZeiPa; i++) {
            if(!(args[i].startsWith("FH"))) {
                System.out.println("Fehlercode \"FHxxx\" nicht vorhanden - Fuellhoehe OK");
                break;
            }
        fhGefunden=true;   
        }
 

LimDul

Top Contributor
Nein, das ist immer noch falsch.

Wenn du einen Parameter findest, der mit FH beginnt dann setzt du fhGefunden auf true.
Nach der Schleife prüfst du, ob die Variable true oder false ist und gibst entsprechend die Fehlermeldung aus.
 

maxmuster987

Aktives Mitglied
Hab jetzt das Ausrufezeichen entfernt. Wenn Parameter mit FH startet, dann ist jetzt true. Falls nicht, dann else false und Fehlercode-Ausgabe.
Hab was falsch gemacht, sonst würde es jetzt funktionieren... 😕

Java:
import java.io.*;
import javax.swing.*;
import java.util.*;

public class Uebung {
    public static void main (String[] args) {
        int KoZeiPa = args.length;
        int i=0;
        final int d = 50;
        final double alpha = 5.;
        String eing = "";
        boolean fhGefunden = false;
        boolean ende = true;
        int h = 240;
        System.out.println("===========================================");
        System.out.println("=== Fuellstandsregelung eines Extruders ===");
        System.out.println("===========================================");
        
        if(KoZeiPa==0) {
            System.out.println("Keine Fehlercodes -- Extruder in Ordnung");
            System.out.println("--> Programmende");
        }
        
        for(i=0; i<KoZeiPa; i++) {
            if((args[i].startsWith("FH"))) {
                fhGefunden=true;
            }
            else {
                fhGefunden=false;
                System.out.println("Fehlercode \"FHxxx\" nicht vorhanden - Fuellhoehe OK");
            }
        break;
        }
 

KonradN

Super-Moderator
Mitarbeiter
Also das generelle Pattern für so ein Vorgehen ist immer gleich:
1. Annahme treffen
2. In einer Schleife prüfen, ob die Annahme NICHT zutrifft -> Annahme ist falsch
3. Nun hast du NACH der Schleife entweder die Gewissheit: Annahme ist richtig, oder Annahme ist falsch.

Es ist IMMER ein Fehler, wenn Du eine Schleife erstellst um alle Elemente zu prüfen und Du dann für jedes Element eine Bewertung mit if/else machst. Da kannst Du also direkt aufmerken und sagen: Das passt da nicht rein!


Ich nerve Dich einfach noch einmal mit dem Hinweis: mach Methoden! Die Unterteilung in mehrere kleine Methoden macht Dir das Leben deutlich einfacher!

Das macht es deutlich einfacher, denn dann brauchst Du die erste Annahme nicht (die Du in einer lokalen Variable speichern müsstest).

Du machst eine Methode mit einer Fragestellung wie: Gibt es ein Element für das eine Bedingung gilt?
Die Logik ist dann richtig einfach:
  • Prüfe alle Elemente. Wenn Du ein Element findest, das die Bedingung erfüllt: Gib true zurück.
  • Nach der Schleife weisst du: es wurde kein Element gefunden - also ist das Ergebnis false.

Also ein einfaches:
Java:
public static boolean argumentStartsWithFH(String[] args) {
    for(int i=0; i<args.length; i++) {
        if(args[i].startsWith("FH")) {
            return true;
        }
    }
    return false;
}

Wobei das noch relativ komplex ist - es bietet sich eine for each Schleife an, die den Code noch übersichtlicher machen würde.
 

Jw456

Top Contributor
Java:
for(i=0; i<KoZeiPa; i++) {
            if((args[i].startsWith("FH"))) {
                fhGefunden=true;
            }
            else {
                fhGefunden=false;
                System.out.println("Fehlercode \"FHxxx\" nicht vorhanden - Fuellhoehe OK");
            }
Denke mal nach was du hier machst, wenn du zB das Übergibst

"XL232 KO233 FH232 KK222"

bei den ersten beiden Durchgängen bleibt der Boolean false
beim dritten Durchgang wird er true
aber beim vierten wider false.
 

maxmuster987

Aktives Mitglied
In einer Schleife prüfen, ob die Annahme NICHT zutrifft -> Annahme ist falsch
Also bleibt mein Ausrufezeichen doch stehen?!

Ich nerve Dich einfach noch einmal mit dem Hinweis: mach Methoden! Die Unterteilung in mehrere kleine Methoden macht Dir das Leben deutlich einfacher!
Ich würde ja gerne deine Methoden nutzen, die du gerne ansprichst, aber ich habe wirklich noch keine Ahnung, wie man das richtig verwendet.
Es ist ja nicht so, dass ich noch keine Methode geschrieben habe, aber ich schreibe die immer nur für Berechnungen bspw. Volumina, Drehzahlen o.Ä. Weil da übergebe ich dann in main die Parameter bspw. volumen(hoehe, durchmesser, laenge) und berechne dann separat in der Methode volumen das Ganze und return das Ergebnis.
Aber für diesen Fall bzw. sobald "boolean", "String" oder sowas vorkommt, versage ich bei den Methoden, dann komm ich da nicht weiter.
Wenn ich das richtig verstehen würde, dann wäre das Ganze bestimmt um einiges einfacher tatsächlich.

Also ein einfaches:
Java:
Code:
public static boolean argumentStartsWithFH(String[] args) {
    for(int i=0; i<args.length; i++) {
        if(args[i].startsWith("FH")) {
            return true;
        }
    }
    return false;
}
Das ist ja jetzt die Methode, die prüfen soll, ob FH gefunden wird oder nicht.
Lass mich das kurz in Worte fassen, ob ich richtig verstanden habe, was die da in dem Abschnitt macht:

Der Methode wird ein String[] args übergeben.
Beim Startwert i=0 läuft die for-Schleife so lange weiter, wie sie kleiner der Länge der Eingaben der Kommandozeilenparameter ist.
Innerhalb der for-Schleife wird geprüft OB einer der Angaben mit FH beginnt, wenn dem so ist, dann wird true zurückgegeben.
Jedes Mal, wenn ein Parameter mit FH startet, wird true zurückgegeben.
Wenn jetzt die for-Schleife abgearbeitet ist, dann wird doch false aber zurückgegeben, oder nicht? Das heißt doch, die for-Schleife hat mir nichts gebracht, weil am Ende wird eh false zurückgegeben oder hab ich hier einen Denkfehler?

Weitere Frage: Da steht jetzt die Methode. Wie übergebe ich dieser Methode innerhalb von main die nötigen Parameter String[] args?
 

Jw456

Top Contributor
wenn es ohne Methode sein soll dann etwa so.

Java:
boolean fhGefunden = false;
for(i=0; i<KoZeiPa; i++) {
            if((args[i].startsWith("FH"))) {
                fhGefunden=true;
                brake;
            }
   }
   if (fhGefunden == false){
           System.out.println("Fehlercode \"FHxxx\" nicht vorhanden - Fuellhoehe OK");
    }
 

temi

Top Contributor
Beim Startwert i=0 läuft die for-Schleife so lange weiter, wie sie kleiner der Länge der Eingaben der Kommandozeilenparameter ist.
Innerhalb der for-Schleife wird geprüft OB einer der Angaben mit FH beginnt, wenn dem so ist, dann wird true zurückgegeben...
...und damit die Methode sofort beendet.

Falls die Bedingung auf keinen der Fälle zutrifft, dann wird die Methode am Ende mit false beendet.

Du kannst die Methode auch noch erweitern und zusätzlich den Suchbegriff mit übergeben.
Java:
public static boolean argumentStartsWith(String[] args, String searchStr) {
    for(int i=0; i<args.length; i++) {
        if(args[i].startsWith(searchStr)) {
            return true;
        }
    }
    return false;
}

Dann kannst du sie bei Bedarf auch für andere Fälle, wie "XL" oder "KO" verwenden.
 

maxmuster987

Aktives Mitglied
Wenn eines gefunden wurde wird trure zurückgeben und die Methode wird beendet .
Die for läuft nicht weiter.
Es werden nach dem ersten Fund keine weiteren Prüfungen gemacht.
...und damit die Methode sofort beendet.

Falls die Bedingung auf keinen der Fälle zutrifft, dann wird die Methode mit false beendet.

Ahaaaa, das wusste ich noch nicht bisher, dass dann die Methode direkt beendet wird. Das ist gut zu wissen, dann ist das einleuchtend.
PS: "return" beendet die Methode sofort.
 

KonradN

Super-Moderator
Mitarbeiter
Es ist ja nicht so, dass ich noch keine Methode geschrieben habe, aber ich schreibe die immer nur für Berechnungen bspw. Volumina, Drehzahlen o.Ä. Weil da übergebe ich dann in main die Parameter bspw. volumen(hoehe, durchmesser, laenge) und berechne dann separat in der Methode volumen das Ganze und return das Ergebnis.
Aber für diesen Fall bzw. sobald "boolean", "String" oder sowas vorkommt, versage ich bei den Methoden, dann komm ich da nicht weiter.
Wenn ich das richtig verstehen würde, dann wäre das Ganze bestimmt um einiges einfacher tatsächlich.
Auf den Punkt möchte ich kurz eingehen, denn die Methode, die du da schreibst, macht nichts anderes:
  • Es bekommt die Parameter (Hier dann halt das Array mit Strings oder ggf noch zusätzlich den Anfang wie vorgeschlagen wurde).
  • Es gibt am Ende das Ergebnis zurück.

Das ist also wirklich 1:1 das Gleiche. Den Rückgabetyp musst du dann halt nur auch immer richtig anpassen. Bei der Berechnung des Volumens hattet Du am Ende eine Zahl zurück gegeben (also int, double, float oder so). Jetzt willst Du aber etwas Anderes zurückgeben: Ob etwas gefunden wurde oder nicht - das ist ein Wahrheitswert und die werden in Java mit dem Typ boolean abgedeckt.

Das mag auf den ersten Blick etwas verwirrend wirken, aber lass Dich davon nicht abschrecken. Übe statt dessen etwas. Schreibe en paar Methoden, die irgendwas machen. Wenn Du magst, dann kann man Dir da auch gerne ein paar Übungen an die Hand geben, so dass Du da nach und nach mehr Erfahrung bekommst. Denn ich bin sicher: Wenn Du das einfach ein bisschen mehr gemacht hast, dann wird das auch für Dich sehr einfach sein.
 

LimDul

Top Contributor
Was für solche Sachen auch sehr hilfreich ist, ist Boolesche Algebra: https://de.wikipedia.org/wiki/Boolesche_Algebra

Weil damit kann man solche Aussagen umformen:
Nicht mindestens ein Parameter starte mit FH ist äquivalent zu folgenden Aussagen
  • Alle Parameter starten nicht mit FH
  • Es gibt mindestens einen Parameter der mit FH startet

Und dann kann man sich überlegen, welche der Aussagen man am einfachsten prüfen kann - das ist in meinen Augen die dritte.

Wenn man das in eine Methode implementiert, was wie @KonradN schon sagte, sinnvoll ist, kann man wie folgt vorgehen:

Schritt 1: Name der Methode, möglichst sprechend: mindestensEinParameterStartetMitFH
Schritt 2: Was gibt zurück? Ich möchte wissen ob die Aussage wahr oder falsch ist - das ist der Datentyp boolen: boolean mindestensEinParameterStartetMitFH
Schritt 3: Was muss ich ihr übergeben? Die Parameter, die ich prüfen will, also args:
Java:
boolean mindestensEinParameterStartetMitFH(String[] args)
Jetzt implementiert man sie, ich muss also durch alle Parameter durchgehen:

Java:
boolean mindestensEinParameterStartetMitFH(String[] args) {
  for (String arg : args) {
  }
}
Dann muss ich den Parameter prüfen, ob er mit FH startet:
Java:
boolean mindestensEinParameterStartetMitFH(String[] args) {
  for (String arg : args) {
    if (arg.startsWith("FH")) {
    }
  }
}
Was ist, wenn er mit FH startet? Nun, ich hab einen gefunden, der mit FH startet, damit muss die gesamte Methode true zurückgeben:
Java:
boolean mindestensEinParameterStartetMitFH(String[] args) {
  for (String arg : args) {
    if (arg.startsWith("FH")) {
      return true;
    }
  }
}
Was ist, wenn ein Parameter nicht mit args startet? Nun, das hilft mir erst mal nicht, weil es könnte ja ein anderer mit args starten. Den meine Frage ist ja äquivalent zu "Alle Parameter starten nicht mit FH". Also kein else Zwei sinnvoll.
Aber was ist, wenn die Schleife zuende ist? Nun, wenn sie zuende ist und die Methode nicht beendet wurde, dann startet offensichtlich kein Parameter mit FH - also muss man dann false zurückgeben:
Java:
boolean mindestensEinParameterStartetMitFH(String[] args) {
  for (String arg : args) {
    if (arg.startsWith("FH")) {
      return true;
    }
  }
  return false;
}

Das ist eine sehr hilfreiche Taktik das Problem in ganz ganz kleine Einzelprobleme zu zerlegen und für die Einzelprobleme einzelne Methoden zu schreiben.
 
Zuletzt bearbeitet:

KonradN

Super-Moderator
Mitarbeiter
Evtl. ist das Buch Captain Ciaociao erobert Java etwas für Dich - einfach einmal die Leseprobe anschauen:

Ansonsten hatte ich im Sinn, dass Du einfach mal eine Methode getGreeting schreibst:
a) diese gibt einfach nur "Hallo Welt!" zurück.
b) diese bekommt einen Namen als Parameter und gibt dann "Hallo, <name>!" zurück bzw, wenn name nicht gesetzt ist: "Hallo Welt!" zurück.

Wenn Du diese ersten Schritte hast: Einfach mal das ausgliedern von Codeteilen probieren. Also da einfach mal schauen, was Du da an Anregungen bekommen hast.
  • Du hattest Code, der nach einer Eingabe fragt und diese Eingabe musste gültig sein.
  • Du hast etwas gemacht, wenn bestimmte Eingaben gemacht wurden -> das passt auch gut in eine eigene Methode.

So einfach als Übung den ganzen Code so zerlegen, dass keine Methode länger ist als z.B. 10 Zeilen. Nicht mehr wie zwei Einrückungen, dabei nie zwei gleiche Einrückungen (Also nie Schleife in Schleife oder if in if. if in Schleife oder Schleife in if wäre noch ok)

Das wären dann so direkt ein paar Übungen. Da braucht es dann auch kein Buch. Deine "Lösung" einfach im Forum posten - Du bekommst dann ganz sicher viele gute Hinweise (Am Anfang nicht verzweifeln, wenn es nicht perfekt ist - das braucht viel Übung! Daher machst Du das ja!)
 

Ähnliche Java Themen


Oben