args[] als statische Variablen speicher oder wie?

[Cheef]

Hallo zusammen!

Wo soll ich die args[] die in der main übergeben werden abspeichern und wie komme ich an diese ran? Ich hab das momentan nur über statische Stringvariablen gelöst und wenn ein bestimmtes args[] kommt speichere ich dies in der statischen Variable.


wie habt ihr sowas gelöst???

 

[SlaterB]

> wenn ein bestimmtes args[] kommt
kommen die bei dir öfter? kann doch nur ein Array beim Start kommen,
was du dann damit machst ist deine Sache, ob staitsch oder woanders ist doch die gleiche Frage bei jeder Art von Information im Programm,
sind die StartParameter was besonders?

ich habe das noch nie irgendwo abgespeichert, aber auch selten benutzt

 

[Gast]

z.b startparameter wären -batch (also batchlauf starten) oder -produktiv/test und solche auswahlen. oder -printhpath:......


diese daten verwende ich im Programm selbst an einer bestimmten stelle.

Dachte es gibt was komfortableren und besser als diese statischen Variablen.....

 

[Guest]

> wenn ein bestimmtes args[] kommt
kommen die bei dir öfter? kann doch nur ein Array beim Start kommen,
was du dann damit machst ist deine Sache, ob staitsch oder woanders ist doch die gleiche Frage bei jeder Art von Information im Programm,
sind die StartParameter was besonders?

ich habe das noch nie irgendwo abgespeichert, aber auch selten benutzt

ist schon klar das es ein Array ist aber ich zerlege es mit einem Stringtokenizer und verwerte einzelne Elemente die ich brauche.


Beispiel:

    String add_parameter = new String();

        for (int i = 0; i < args.length; i++) {
            add_parameter += " " + args[i];
        }

        add_parameter = add_parameter.toUpperCase();

        // System.out.println(add_parameter.toString());
        StringTokenizer tokenizer =
            new StringTokenizer(add_parameter.toString(), ": ");     

        while (tokenizer.hasMoreTokens()) {
            String Response = tokenizer.nextToken();

            if (Response.equalsIgnoreCase("/PrinthPath")) {
                Printpath = tokenizer.nextToken();
              //  + ":" + tokenizer.nextToken();                          
              
            }
        }

wenn ich also /PrinthPath:"c:/Druckpfad" angebe. dann speichert er c:/Druckpfad als statische Variable ab....

 

[SlaterB]

es gibt technisch nur eine einzige alternative zu statischen Variablen: nicht-statische Variablen eines Objektes,
oder vielleicht noch Textdatei, Internetserver, DB, falls man sowas dazuzählen möchte

also ich meine mit meinem blah blah: statisch oder nicht ist erstmal nicht unbedingt die Frage,
ob du die Daten frei irgendwo global als pures String[] ablegst
oder in einer hochkomplexen Registierung mit Anmeldung und Passwort/ Sichtbarkeit versteckst,
formatiert, geparst, geprüft und typisiert, das ist schon was anderes

alles ist denkbar,
naja, von mir nur blahblah und keine kontreten Beispiele

 

[Murray]

Ich versuche immer, nicht zuviel in der main zu machen, damit man die Klasse besser wiederverwenden kann. Daher werden irgendwelche Parameter in Instanzvariablen der Klasse gespeichert und im Konstruktor übergeben. Die main-Methode prüft nur die Anzahl und Syntax der Parameter und wandelt sie in die eigentlichen (getypten) Konstruktor-Argumente um. Insofern stellt sich die Frage nach der Speicherung der reinen Paramter-Strings nicht: die werden einmal ausgewertet und dann "vergessen".

 

[Gelöschtes Mitglied 5909]

gugg dir das mal an:
http://jargs.sourceforge.net/

// edit:

ich weiß nicht was du mit deinen statischen variablen hast, du machst in der main dein hauptobjekt, übergibts die parameter und gut is, zum parsen kannste dann wie gesagt jargs nehmen

 

[Guest]

Ich versuche immer, nicht zuviel in der main zu machen, damit man die Klasse besser wiederverwenden kann. Daher werden irgendwelche Parameter in Instanzvariablen der Klasse gespeichert und im Konstruktor übergeben. Die main-Methode prüft nur die Anzahl und Syntax der Parameter und wandelt sie in die eigentlichen (getypten) Konstruktor-Argumente um. Insofern stellt sich die Frage nach der Speicherung der reinen Paramter-Strings nicht: die werden einmal ausgewertet und dann "vergessen".

hast du ein bischen Code, weil momentan sagt mir deine Umsetzung wenig.

 

[Murray]

An dein Beispiel angelehnt:

import java.io.File;
import java.util.Arrays;

public class Arg {
	
	private static final String STR_PRINTPATH = "/PrintPath";
	private static final String STR_COPIES = "/Copies";

	public static void main(String[] args) {
		
		File optPrintPath = null;
		int optNumberOfCopies = -1;
		
		boolean err = false;
		for ( String arg : args) {
			int colIdx = arg.indexOf( ":");
			if ( colIdx <= 0) {
				err = true;
			} else {
				try {
					String opt = arg.substring( 0, colIdx);
					String val = arg.substring( colIdx+1);
					if ( STR_PRINTPATH.equalsIgnoreCase( opt)) {
						optPrintPath = new File( val);
						continue;
					} else if ( STR_COPIES.equalsIgnoreCase( opt)) {
						optNumberOfCopies = Integer.parseInt( val);
						continue;
					}
				} catch ( Exception e) {
					System.err.println( "arg " + arg + " -> " + e);
				}
				err = true;
				break;
			}
		}
		
		if ( err) {
			System.err.println( "Parameter-Fehler!");
			System.err.println( "  Erwartet: Arg [" + STR_PRINTPATH + ":<path>] [" + STR_COPIES + ":<number>]");
			System.err.println( "  Erhalten: " + Arrays.toString( args));
			System.exit( 0);
		}
		
		Arg theArg = new Arg( optPrintPath, optNumberOfCopies);
		theArg.process();

	}
	
	private final File printPath;
	private final int numberOfCopies;
	
	public Arg( final File printPath, final int numberOfCopies) {
		this.printPath = (printPath == null) ? new File( "") : printPath;
		this.numberOfCopies = (numberOfCopies < 1) ? 0 : numberOfCopies; 
	}
	
	/*
	 * Default-Konstruktor verwendet Default-Werte
	 */
	public Arg() {
		this( null, -1);
	}
	
	/*
	 * Hier würde die eigentliche Arbeit passieren
	 */
	public void process() {
		/*
		 * Hier stehen die Paramter jetzt typsicher (als File bzw. int) in
		 * den Instanzvariablen zur Verfügung
		 */
		System.out.println( "process: printPath=" + printPath.getAbsolutePath() + ", numberOfCopies=" + numberOfCopies);
	}

}

 

[Gelöschtes Mitglied 5909]

mach dir doch ne Filemanager klasse, und übergebe ihr die args.

//main method
if (args.length != 1) // exit, print help
new FileManager(args[0]).showDirectory();

so in der art
und zum parsen der args kannste jargs nehmen (siehe oben)
sieht alles sehr umständlich aus und die main sollte möglichst klein sein.

 

[Murray]

die main sollte möglichst klein sein.

Grundsätzlich gebe ich dir da recht, allerdings bin ich der Meinung, dass das Parsen von irgednwelchen als String übergebenen Parameterlisten wirklich nur dann passieren sollte, wenn die Klasse direkt aus eine main-Methode gestartet wird (weil man eine main-Methode nunmal nur Strings und keine sauber getypten Argumente übergeben kann). Überall sonst sollte man die notwendigen Argumente sauber getypt als eindeutig definierte (Konstruktor-)Parameter übergeben. Deshalb trenne ich das Parsen von der Instanziierung. Und ob man für das Parsen eine fremde Lib verwendent, und/oder ob man das in eine zusätzliche, nur von der main aufgerufene Klassenmethode auslagert, hängt wohl in vom Umfang der Parameterliste ab.

 

[Gelöschtes Mitglied 5909]

hab auch nix anderes behauptet, aber für sowas kleines wie oben...

 

[Murray]

Gerade für so etwas kleines würde ich a) keine externe Lib bemühen wollen und b) der Meinung sein, dass man das noch guten Gewissens in der main-Methode unterbringen kann.