# Benutzereingabe



## CMOS (9. Mai 2011)

In meinem Anfänger-Buch "Grundkurs Programmieren in Java" wird eine Benutzereingabe mit dem Tool "Prog1Tools.IOTools" realisiert.
Ich hab die auch schon heruntergeladen und auch schon in der Systemsteuerung hinzugefügt so wie hier beschrieben.
Allerdings kommt bei dem Programm:

```
import Prog1Tools.IOTools.*;
public class Übungen {
	public static void main (String[] args) {
		int i;
		i = readInteger ("i = ");
	}

}
```
Diese Meldung:

```
Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	The method readInteger(String) is undefined for the type Übungen

	at Übungen.main(Übungen.java:5)
```
Liegt das daran, dass ich ihm einen Integer liefere aber er einen String haben will?


----------



## XHelp (9. Mai 2011)

In dem Buch steht auch wie du es benutzt: 
	
	
	
	





```
i = IOTools.readInteger("i = ");
```


----------



## eRaaaa (9. Mai 2011)

XHelp hat gesagt.:


> In dem Buch steht auch wie du es benutzt:
> 
> 
> 
> ...



Oder die erste Zeile abändern

[c]import static Prog1Tools.IOTools.*;[/c]


----------



## CMOS (9. Mai 2011)

Ne das steht da nicht ^^. 
Jetzt kommt diese Meldung:

```
Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	IOTools cannot be resolved

	at Übungen.main(Übungen.java:5)
```


----------



## SlaterB (9. Mai 2011)

unter folgenden Link
[c]http://www.grundkurs-java.de/beispiele/4/4/4/IOToolsTest.java[/c]
http://www.grundkurs-java.de/beispiele/4/4/4/IOToolsTest.java 
steht


```
import Prog1Tools.IOTools;
public class IOToolsTest {
  public static void main (String[] args) {  
    int     i, j, k;
    double  d;
    char    c;
    boolean b;

    // int-Eingabe ohne Prompt
    i = IOTools.readInteger();
```
usw.


----------



## CMOS (9. Mai 2011)

Es kommt trotzdem noch die Meldung:

```
Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	IOTools cannot be resolved

	at Übungen.main(Übungen.java:6)
```


----------



## XHelp (9. Mai 2011)

CMOS hat gesagt.:


> Ne das steht da nicht ^^



Ich habe das Buch vor mir, also glaub mir ruhig, wenn ich sage, dass es da steht. Darüber hinaus steht da auch:


> Wenn Sie dieses Paket auf Ihrem Rechner installiert haben und die Klasse in einem Ihrer Programme verwenden wollen, beginnen Sie Ihr Programm mit
> 
> ```
> import Prog1Tools.IOTools;
> ...


----------



## CMOS (9. Mai 2011)

Stell dir vor ich habs auch vor mir 
Hier mein Code:

```
import static Prog1Tools.IOTools.*;

public class Übungen {
	public static void main (String[] args) {
		int i;
		i = IOTools.readInteger();
	}

}
```
Fehlermeldung:  
	
	
	
	





```
Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	IOTools cannot be resolved

	at Übungen.main(Übungen.java:6)
```


----------



## maki (9. Mai 2011)

CMOS, dein Code ist falsch, nimm doch den aus dem Buch 

Im Buch steht sicherlich nicht

```
import Prog1Tools.IOTools.*;
```


----------



## CMOS (9. Mai 2011)

Hab ich doch da stehen? Ob ich jetzt static dazu schreibe oder nicht, das macht keinen Unterschied. Im Buch steht:

```
import static Prog1Tools.IOTools.*;
```


----------



## maki (9. Mai 2011)

Wenn ich schreibe "Im Buch steht sicherlich nicht", dann heisst das: "Da ist der Fehler"
Schreib es einfach richtig ab, schon gehts.


----------



## XHelp (9. Mai 2011)

@maki, so wie ich das aus dem Buch erahnen kann wird da an dieser Stelle der Unterschied zwischen 
	
	
	
	





```
import
```
 und 
	
	
	
	





```
import static
```
 verdeutlicht:

```
import static Prog1Tools.IOTools.*;
public class MalEinNameOhneUmlaute {
    public static void main (String[] args) {
        int i = readInteger();
    }
}
```
vs

```
import Prog1Tools.IOTools;
 
public class MalEinNameOhneUmlaute {
    public static void main (String[] args) {
        int i = IOTools.readInteger();
    }
}
```


----------



## maki (9. Mai 2011)

Er müsste sich halt für eine Variante entscheiden, und die dann richtig abtippen


----------



## SlaterB (9. Mai 2011)

weil die Aufmerksamkeit von so vielen Leuten ja verdient ist nochmal ein Hinweis: 
[c]import Prog1Tools.IOTools.*;[/c]
ungleich
[c]import Prog1Tools.IOTools;[/c]


----------



## CMOS (9. Mai 2011)

So hier richtig abgetippt:

```
import static Prog1Tools.IOTools.*;

public class IOToolsTestMitStaticImport {
	public static void main (String[] args) {
		int i, j, k;
		double d;
		char c;
		boolean b;
		
		i = readInteger();
		
		System.out.print("j = ");
		j = readInteger ();
		
		k = readInteger ("k = ");
		
		d = readDouble ("d = ");
		
		c = readChar ("c = ");
		
		b = readBoolean (" b = ");
		
		System.out.println("i = " + i );
		System.out.println("j = " + j );
		System.out.println("k = " + k );
		System.out.println("d = " + d );
		System.out.println("c = " + c );
		System.out.println("b = " + b );
		
		
	}

}
```
*Fehlermeldung:*

```
Exception in thread "main" java.lang.Error: Unresolved compilation problems: 
	The method readInteger() is undefined for the type IOToolsTestMitStaticImport
	The method readInteger() is undefined for the type IOToolsTestMitStaticImport
	The method readInteger(String) is undefined for the type IOToolsTestMitStaticImport
	The method readDouble(String) is undefined for the type IOToolsTestMitStaticImport
	The method readChar(String) is undefined for the type IOToolsTestMitStaticImport
	The method readBoolean(String) is undefined for the type IOToolsTestMitStaticImport

	at IOToolsTestMitStaticImport.main(IOToolsTestMitStaticImport.java:10)
```


----------



## maki (9. Mai 2011)

Findet er den Import Prog1Tools.IOTools?


----------



## CMOS (9. Mai 2011)

Gute Frage, ich kann da aus den Fehlermeldungen nichts herauslesen. Ich hab das aber genauso befolgt wie in der Anleitung.


----------



## SlaterB (9. Mai 2011)

funktioniert einfach nur
[c]System.out.print(Prog1Tools.IOTools.class);[/c]
?
(natürlich mit main-Methode usw., Import in diesem Fall nicht so wichtig)


wahrscheinlich brauchst du
Software und Informationen



> Die IOTools
> 
> * IOToolsInstallHilfe.html (Kurz-Dokumentation und Installationsanleitung, html-Datei)
> * IOToolsInstallHilfe.pdf (Kurz-Dokumentation und Installationsanleitung, PDF-Datei)
> ...


Download von Libraries und Einbindung ins Programm ist leider ziemlich schwierig (entgegen der zitierten Beschreibung), 
schade dass viele Anfänger-Bücher sowas verlangen, vielleicht gehst du lieber zu diesem Buch:
Galileo Computing :: Java ist auch eine Insel –
das wirst du hier im Forum sowieso oft genug hören 

---

in Installationsanleitung.html habe ich noch reingeschaut, unter 2.6


> 2.6 Weiteres Vorgehen für spezielle Java-Editoren oder Java-Entwicklungsumgebungen (Die IOTools in Eclipse, Java-Editor, JOE, JBuilder etc.)


sind 4 IDEs genannt, aber NetBeans nicht, Pech


----------



## CMOS (9. Mai 2011)

Code: 
	
	
	
	





```
import static Prog1Tools.IOTools.*;

public class IOToolsTestMitStaticImport {
	public static void main (String[] args) {
		System.out.print(Prog1Tools.IOTools.class);
		
		
	}

}
```
Meldung: 

```
Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	Prog1Tools cannot be resolved to a type

	at IOToolsTestMitStaticImport.main(IOToolsTestMitStaticImport.java:5)
```

Stell dir vor, ich war vorgestern Bücher-Kaufen und da hab ich genau das Buch gesehen, wobei ich eigentlich ein ordnetliches Python Buch gesucht habe. Am Ende ist es dann ein C# Buch geworden ^^. Ich glaub ich bleib erst einmal bei dem...
Edit: Wie gesagt, ich hab es nach den aufgelisteten Installations-Anweisungen befolgt.
*Großeees EDIT:*
Ich bin von NetBeans auf Eclipse umgestiegen 
Da gestaltet sich das mit den Klassen wirklich einfacher. Dann noch die 7 Video-Tuts geguckt von der Reihe die ihr mir geschickt habt ( in einem anderen Beitrag ) und dann hat das soweit funktioniert! Danke nochmals...


----------



## SlaterB (9. Mai 2011)

CMOS hat gesagt.:


> Edit: Wie gesagt, ich hab es nach den aufgelisteten Installations-Anweisungen befolgt.



meinst du 'in der Systemsteuerung hinzugefügt'?
verwendest du denn die Konsole (dann wäre das evtl. nützlich, kann man noch viel falsch machen)
oder eine IDE (dann bringt Systemsteuerung ziemlich wenig)

siehe auch edit in meinem letzten Posting 

edit: geht es denn jetzt in Eclipse oder bezieht sich das Danke nur auf Eclipse, noch nicht auf das aktuelle Problem?
wäre ja recht schnelle Lösung


----------



## CMOS (9. Mai 2011)

Siehe Edit in meinem Post  Ich benutze Eclipse. Also eine IDE.


----------



## SlaterB (9. Mai 2011)

und hast du die Installationsanleitung zu Eclipse berücksichtigt?
Screenshots des Project Explorers/ der Konfiguration, wo immer du External JARs hinzugefügt hast, wären hilfreich


----------



## CMOS (9. Mai 2011)

Was sind JARs? Die Installationsanleitung für Eclipse hab ich berücksichtig, wobei es da nicht viel zu installieren gab.


----------



## SlaterB (9. Mai 2011)

JARs werde ich nicht erklären, in der Anleitung steht


> In Eclipse gehen Sie wie folgt vor:
> [..] Mit der linken Maustaste auf den Button Edit drücken. Es erscheint ein Kontext-Menü. Dort den Button Add External JARs klicken und die Datei Prog1Tools.zip, also
> c:\programme\java\other\Prog1Tools.zip
> [..]


entweder du stellst dazu Fragen, machst das noch oder bist damit fertig und zeigst mehr oder weniger überzeugend die Ergebnisse (durch Text oder eher gleich Screenshots),
ansonsten nur mit 'ich habe alles richtig gemacht' gehts nunmal nicht weiter, 
das ist einerseits allgemein wenig glaubhaft (sorry  ), steht andererseits im Widerspruch zum Nicht-Funktionieren aktuell


----------



## CMOS (9. Mai 2011)

Wenn ich unter Edit gehe finde ich da kein "Add External JARs".


----------



## SlaterB (9. Mai 2011)

das wäre gleich zwei Screenshots wert, einerseits WO du auf Edit klickst, andererseits was dann dort stattdessen zu sehen ist
(oder textuelle Beschreibung)

warum du in diesem Fall vorher
> Die Installationsanleitung für Eclipse hab ich berücksichtig, wobei es da nicht viel zu installieren gab.
schriebst könnte man auch noch diskutieren, oder eben nicht,

ich bin jetzt ne Stunde nicht da, nicht wundern


----------



## CMOS (9. Mai 2011)

Screen kann ich von dem Edit-Menü nicht machen das klappt nämlich wieder zu sobald ich wo anders hinklicke.



Gibts noch ne andere Möglichkeit der Benutzereingabe wo ich keine externen Dings-Zeugs installieren muss? Oder wie macht ihr das? Ist schon blöd wenn ein Buch so einen kack macht...


----------



## SlaterB (9. Mai 2011)

kein anderer antwortet zwischendurch?
der von mir zitierte Text enthält bei den [..] noch mehr Text, das fängt nämlich mit 


> Im Menüpunkt Window dessen Unterpunkt Preferences wählen.


an.., und da steht noch viel mehr...,
nix von gewußt, Anleitung nie wirklich gelesen?

ich habe auch schon ein anderes Buch genannt, ohne diese Probleme...


----------



## frapo (9. Mai 2011)

SlaterB hat gesagt.:


> kein anderer antwortet zwischendurch?



Neee, absolut keinen Bedarf! Geht ja wohl einigen anderen mittlerweile ebenso.

Wenn man sich die anderen Threads des TO angesehen hat, dann auch noch sowas wie 





> Ist schon blöd wenn ein Buch so einen kack macht...


 kommt... da ist ja jeglicher Bedarf gedeckt Hilfestellungen zu geben. 

Was nützt es dem 'Fragesteller' zu raten sich erstmal mit der Konsole, den Befehlen java, javac und dem Classpath, sowie packages auseinanderzusetzen, vielleicht noch erneut auf Galileo Computing :: Java ist auch eine Insel – zu verweisen? Von der FAQ hier im Forum mal gar nicht zu reden. Eigeninitiative ist ihm ein Fremdwort, eine Spur zu selbstbewusst, beratungsresistent und dreist. Möglicherweise der kommende Mann für den FDP-Vorstand aber sicher nicht mehr.

Ist ein wenig OT aber irgendwie passt dieser Account in die Diskussion http://www.java-forum.org/plauderecke/117759-anonyme-posts-erlauben.html.
Der Ton und das Auftreten einiger Zeitgenossen hier (zumindest für mich) ist einfach nervig - gleich ob sie nun anonym oder 'Benutzer' sind. 

Zum Glück gibt es immer Alternativen . Treibt man sich da zwischendurch herum, sieht man einiges relativer.


----------



## CMOS (14. Mai 2011)

Hat keiner mehr eine Idee wie ich das Problem lösen könnte? Gibt es noch andere Eingabeaufforderungs-Methoden? Wo ich keinen externe Klasse installieren muss?


----------



## SlaterB (14. Mai 2011)

Galileo Computing :: Java ist auch eine Insel –

Kapitel für Kapitel durch, da sollten nur Standard-Klassen wie Scanner auf System.in verwendet werden


----------



## CMOS (14. Mai 2011)

Naja dann hätte ich mir ja ein Buch umsonst gekauft  Bist du dir sicher das das Eingabeproblem da anders gelöst wird als mit externen Klassen?


----------



## XHelp (14. Mai 2011)

Was hat dir denn an der Anleitung auf der Buchseite nicht gepasst?


----------



## SlaterB (14. Mai 2011)

CMOS hat gesagt.:


> Naja dann hätte ich mir ja ein Buch umsonst gekauft  Bist du dir sicher das das Eingabeproblem da anders gelöst wird als mit externen Klassen?



dafür ist das zweite Buch umsonst,
ich bin mir einerseits sicher, und zweierseits ist Programmeingabe sowieso langweilig/ umständlich, 
du kannst alles direkt in den Quellcode eingeben und ein Programm neu laufen lassen


----------



## CMOS (14. Mai 2011)

Was heißt das zweite Buch ist umsonst? Gibts das kostenlos?
Edit: Ich würde gerne einfach Java lernen. Unter einfach verstehe ich, wenn ich nichts dazu installieren muss, keine externen Klassen usw. Dann muss ich noch einmal 50 € hinblättern 
Gibt es nicht doch eine andere Lösung für diese Eingabeaufforderung, also genau das gleiche wie die Prog1IOTools? Ich entschuldige mich noch einmal für die in kürzerer Vergangenheit aufgetretenen Unverschämtheiten meinerseits. Hoffentlich ist das Problem damit beseitigt?


----------



## frapo (14. Mai 2011)

CMOS hat gesagt.:


> Was heißt das zweite Buch ist umsonst? Gibts das kostenlos?



Meine Güte! Der link zum Buch wurde Dir bereits mehrfach in diesem Thread angegeben :rtfm:. Warum klickst Du nicht einfach mal drauf und lässt Dich überraschen? Ich hoffe für Dich, dass Du dann verstehst was mit kostenlos gemeint ist.


----------



## SlaterB (14. Mai 2011)

alles aber auch wirklich alles steht dir offen, es gibt so viele Möglichkeiten dass man sich gar nicht entscheiden kann, nur schmollen ist schlecht
- das neue Buch ist kostenlos, man muss es nur lesen
- im Internet nach Programmen suchen 'eine Zahl in Java eingeben' und du bekommst hunderte Lösungen
- die Installation der Library des ersten Buches ist weiter möglich, du versuchst es nur nicht, oder hast bisher zumindest noch keine qualifizierte Frage dazu gestellt (die, die beweisen, dass du die Installationsanleitung quasi nicht gelesen hast, sind nicht sinnvoll..)
- auf der Seite des ersten Buches steht der Quellcode sogar zum Download bereit, du musst nichts kompliziert installieren, sondern einfach nur eine Klasse in einem package erstellen, das normalste, was man in Java machen kann


```
package Prog1Tools;

import java.io.*;
import java.util.*;
import java.math.*;

/** Diese Klasse stellt einige einfache Methoden zum Einlesen von der Tastatur
 zur Verf&uuml;gung. Es werden diverse Werte von der Tastatur eingelesen, die
 jeweils durch ein Leerzeichen, einen Tabstop oder ein Zeilenendezeichen
 getrennt sein m&uuml;ssen.
 @author Jens Scheffler
 @version 1.01 Spezialfassung f&uuml;r <I>Programmieren 1 in Java</I>
 */
public class IOTools {

    private IOTools(){} // somit kann die Klasse nicht instanziiert werden!
    private static BufferedReader in=
               new BufferedReader(new InputStreamReader(System.in));
    private static StringTokenizer eingabe;
    private static String zeichenkette;

/** L&ouml;scht alles, was sich in der momentanen Zeile befindet.
 Das hei&szlig;t es wird der Eingabe bis zum Zeilenende keine Beachtung mehr
 geschenkt
 */
    public static void flush(){
        eingabe=null;
    }

/* Private Methode, die den Tokenizer fuellt. Dies ist uebrigens eine von
 zwei Methoden, die die Klasse zum Absturz bringen kann...*/
    private static void init(){
      zeichenkette=null;
      if (eingabe!=null && eingabe.hasMoreTokens()) return;
        while (eingabe==null || !eingabe.hasMoreTokens())
          eingabe=new StringTokenizer(readLine());
    }

/* Private Methode, die eine Fehlermeldung ausgibt */
    private static void error(Exception e,String prompt) {
      System.out.println("Eingabefehler "+e);
      System.out.println("Bitte Eingabe wiederholen...");
      System.out.print(prompt);
    }

/** Liest eine ganze Textzeile von der Tastatur ein. Soll vorher eine
 Eingabeaufforderung gemacht werden, geschieht dies durch den Parameter.
 Dieser kann jedoch auch wegfallen.
@param prompt eine eventuelle Eingabeaufforderung
@return die eingelesene Zeile.
 */
/* Dies ist die zweite Methode, die die Klasse zum Absturz bringen kann.*/
    public static String readLine(String prompt){
        flush();
        String erg="";
        System.out.print(prompt);
        try{
            erg=in.readLine();
        } catch(IOException e){
            System.err.println(""+e+"\n Programm abgebrochen...\n");
            System.exit(1);
        }
        if (erg==null) {
          System.err.println("Dateiende erreicht.\nProgramm abgebrochen...\n");
          System.exit(1);
        }
        return erg;
    }

/** Liest eine <CODE>int</CODE>-Zahl von der Tastatur ein. Soll vorher eine
 Eingabeaufforderung gemacht werden, geschieht dies durch den Parameter.
 Dieser kann jedoch auch wegfallen.
@param prompt eine eventuelle Eingabeaufforderung
@return die eingelesene Zahl.
 */
    public static int readInteger(String prompt){
        int erg;
        System.out.print(prompt);
        init();
        while(true){
            try{
                erg=Integer.parseInt(eingabe.nextToken());
            } catch (NumberFormatException e) {
              error(e,prompt);init();continue;
            }
            return erg;
        }
    }

/** Liest eine <CODE>long</CODE>-Zahl von der Tastatur ein. Soll vorher eine
 Eingabeaufforderung gemacht werden, geschieht dies durch den Parameter.
 Dieser kann jedoch auch wegfallen.
@param prompt eine eventuelle Eingabeaufforderung
@return die eingelesene Zahl.
 */
    public static long readLong(String prompt){
        long erg;
        System.out.print(prompt);
        init();
        while(true){
            try{
                erg=Long.parseLong(eingabe.nextToken());
            } catch (NumberFormatException e) {error(e,prompt);init();continue;}
            return erg;
        }
    }

/** Liest eine <CODE>double</CODE>-Zahl von der Tastatur ein. Soll vorher eine
 Eingabeaufforderung gemacht werden, geschieht dies durch den Parameter.
 Dieser kann jedoch auch wegfallen.
@param prompt eine eventuelle Eingabeaufforderung
@return die eingelesene Zahl.
 */
    public static double readDouble(String prompt){
        double erg;
        System.out.print(prompt);
        init();
        while(true){
            try{
                erg=Double.valueOf(eingabe.nextToken()).doubleValue();
            } catch(NumberFormatException e) {error(e,prompt);init();continue;}
            return erg;
        }
    }

/** Liest eine <CODE>float</CODE>-Zahl von der Tastatur ein. Soll vorher eine
 Eingabeaufforderung gemacht werden, geschieht dies durch den Parameter.
 Dieser kann jedoch auch wegfallen.
@param prompt eine eventuelle Eingabeaufforderung
@return die eingelesene Zahl.
 */
    public static float readFloat(String prompt){
        float erg;
        System.out.print(prompt);
        init();
        while(true){
            try{
                erg=Float.valueOf(eingabe.nextToken()).floatValue();
            } catch(NumberFormatException e) {error(e,prompt);init();continue;}
            return erg;
        }
    }

/** Liest eine <CODE>short</CODE>-Zahl von der Tastatur ein. Soll vorher eine
 Eingabeaufforderung gemacht werden, geschieht dies durch den Parameter.
 Dieser kann jedoch auch wegfallen.
@param prompt eine eventuelle Eingabeaufforderung
@return die eingelesene Zahl.
 */
    public static short readShort(String prompt){
        short erg;
        System.out.print(prompt);
        init();
        while(true){
            try{
                erg=Short.valueOf(eingabe.nextToken()).shortValue();
            } catch(NumberFormatException e) {error(e,prompt);init();continue;}
            return erg;
        }
    }

/** Liest eine <CODE>byte</CODE>-Zahl von der Tastatur ein. Soll vorher eine
 Eingabeaufforderung gemacht werden, geschieht dies durch den Parameter.
 Dieser kann jedoch auch wegfallen.
@param prompt eine eventuelle Eingabeaufforderung
@return die eingelesene Zahl.
 */
    public static byte readByte(String prompt){
        byte erg;
        System.out.print(prompt);
        init();
        while(true){
            try{
                erg=Byte.valueOf(eingabe.nextToken()).byteValue();
            } catch(NumberFormatException e) {error(e,prompt);init();continue;}
            return erg;
        }
    }

/** Liest einen boolschen Wert von der Tastatur ein. Soll vorher eine
 Eingabeaufforderung gemacht werden, geschieht dies durch den Parameter.
 Dieser kann jedoch auch wegfallen.
@param prompt eine eventuelle Eingabeaufforderung
@return der eingelesene Wert.
 */
    public static boolean readBoolean(String prompt){
        String try_this=readString(prompt);
        while (!try_this.equals("true") && !try_this.equals("false")) {
            error(new NumberFormatException("For input string: \"" + try_this + "\""),prompt);
            try_this=readString();
        }
        return try_this.equals("true");
    }


/** Liest ein Textwort von der Tastatur ein. Soll vorher eine
 Eingabeaufforderung gemacht werden, geschieht dies durch den Parameter.
 Dieser kann jedoch auch wegfallen.
@param prompt eine eventuelle Eingabeaufforderung
@return das eingelesene Wort.
 */
    public static String readString(String prompt){
        System.out.print(prompt);
        init();
        return eingabe.nextToken();
    }

    /** Liest ein Zeichen von der Tastatur ein. Soll vorher eine
 Eingabeaufforderung gemacht werden, geschieht dies durch den Parameter.
 Dieser kann jedoch auch wegfallen.
@param prompt eine eventuelle Eingabeaufforderung
@return das eingelesene Zeichen.
 */
    public static char readChar(String prompt){
        String try_this=readString(prompt);
        while (!(try_this.length() == 1)) {
            error(new NumberFormatException("For input string: \"" + try_this + "\""),prompt);
            try_this=readString();
        }
        return try_this.charAt(0);


    }

/** Liest eine ganze Textzeile von der Tastatur ein.
@return die eingelesene Zeile.
 */
    public static String readLine(){
        return readLine("");
    }

/** Liest eine <CODE>int</CODE>-Zahl von der Tastqtur ein.
@return die eingelesene Zahl.
 */
    public static int readInteger(){
            return readInteger("");
    }

/** Liest eine <CODE>int</CODE>-Zahl von der Tastqtur ein.
@return die eingelesene Zahl.
 */
    public static int readInt(){
            return readInteger("");
    }

/** Liest eine <CODE>int</CODE>-Zahl von der Tastatur ein. Soll vorher eine
 Eingabeaufforderung gemacht werden, geschieht dies durch den Parameter.
 Dieser kann jedoch auch wegfallen.
@param prompt eine eventuelle Eingabeaufforderung
@return die eingelesene Zahl.
 */
    public static int readInt(String prompt){
            return readInteger(prompt);
    }

/** Liest eine <CODE>long</CODE>-Zahl von der Tastatur ein.
@return die eingelesene Zahl.
 */
    public static long readLong(){
            return readLong("");
    }

/** Liest eine <CODE>double</CODE>-Zahl von der Tastatur ein.
@return die eingelesene Zahl.
 */
    public static double readDouble(){
        return readDouble("");
    }

/** Liest eine <CODE>short</CODE>-Zahl von der Tastatur ein.
@return die eingelesene Zahl.
 */
    public static short readShort(){
        return readShort("");
    }

/** Liest eine <CODE>byte</CODE>-Zahl von der Tastatur ein.
@return die eingelesene Zahl.
 */
    public static byte readByte(){
        return readByte("");
    }

/** Liest eine <CODE>float</CODE>-Zahl von der Tastatur ein.
@return die eingelesene Zahl.
 */
    public static float readFloat(){
        return readFloat("");
    }

/** Liest ein Zeichen von der Tastatur ein.
@return das eingelesene Zeichen
 */
    public static char readChar(){
      return readChar("");
    }
    
/** Liest ein Textwort von der Tastatur ein.
@return das eingelesene Wort.
 */
    public static String readString(){
        return readString("");
    }

    /** Liest einen boolschen Wert von der Tastatur ein.
@return das eingelesene Wort.
 */
    public static boolean readBoolean(){
        return readBoolean("");
    }

    /** Wandelt eine double-Zahl in einen String um.
     Bei der &uuml;blichen Umwandlung von double-Werten in einen String
     findet eine Rundung statt. So wird etwa die Zahl 0.1, obwohl intern
     nicht darstellbar, dennoch auf dem Bildschirm ausgegeben. Diese
     Methode umgeht die Rundung */
    public static String toString(double d) {
      if (Double.isInfinite(d) || Double.isNaN(d))
        return ""+d;
      return (new BigDecimal(d)).toString();
    }
}
```


----------



## CMOS (14. Mai 2011)

Das ist aber nicht das gesamte Buch oder?


----------



## XHelp (14. Mai 2011)

CMOS hat gesagt.:


> Das ist aber nicht das gesamte Buch oder?



Und wie kommst du dazu?


----------



## frapo (14. Mai 2011)

CMOS hat gesagt.:


> Das ist aber nicht das gesamte Buch oder?



Doch, ist es. Recht weit oben links findest Du das Inhaltsverzeichnis. Du kannst Dir das Buch auch laden, an der Größe wirst Du dann sehen, dass es recht umfangreich ist. 

Kommst Du mit dem Buch nicht zurecht, dann gehe mal auf www.javabuch.de - Das Handbuch der Java-Programmierung. Dort gibt es auch ein Kompendium zum herunterladen.


----------



## CMOS (14. Mai 2011)

Wieso gibt es dann auch im Laden zu kaufen wenn es das kostenlos zum runterladen gibt? Vielen Dank!


----------



## frapo (14. Mai 2011)

CMOS hat gesagt.:


> Wieso gibt es dann auch im Laden zu kaufen wenn es das kostenlos zum runterladen gibt? Vielen Dank!



Das frag mal den Autor . Hat mich bisher nicht interessiert.

Bitte!


----------

