# Hilfe für absoluten Neuling



## MisterNewb (10. Nov 2011)

Hallo,

ich bin ein wirklich absoluter Java-Anfänger und habe 0 Vorkenntnisse.

Ich soll eine Aufgabe bearbeiten, die wie folgt lautet:

Die Eingabe des Benutzers entsprechen einem Wort. Geben sie das eingegeben Wort rückwärts aus. Ermitteln sie außerdem die Länge des Wortes und geben sie dieses auf der Standartausgabe aus.

Eigentlich nicht schwer, aber ich habe das ganze noch nicht wirklich verstanden und will hier deswegen einige Sachen fragen. Ich möchte bei dieser Gelegenheit auch wissen, was die einzelnen Dinge bewirken, das habe ich bis jetzt nämlich auch nicht verstanden..
Hier der Anfang, ich möchte es gerne Schritt für Schritt erstellen, um es auch nachvollziehen zu können.


```
import java.io.*;


public class nummer3 {
	
	public static void main(String[ ] args) throws IOException {
```

Was bewirkt das:

-import java.io.*
-public static void main(String[ ] args) throws IOException


Wie gehe ich weiter vor?
Ich verstehe nicht, wie ich meinen String jetzt so definiere, dass er meiner Eingabezeile entspricht.


----------



## chalkbag (10. Nov 2011)

MisterNewb hat gesagt.:


> Was bewirkt das:
> 
> -import java.io.*
> -public static void main(String[ ] args) throws IOException
> ...



Import java.io.* sorgt dafür das alle Klassen welche im Package java.io definiert sind, dir in dieser (this) Klasse zur Verfügung stehen.

Public static void main(String[] args) ist der Aufruf des Javaprogramms oder auch als Hauptmethode bezeichnet. Soll bedeuteten, immer (mit Ausnahmen) wenn du dein Javaprogramm startest wird diese Methode zuerst aufgerufen (natürlich kommen davor noch Variablendeklarationen etc..). Also kurz, bei dieser Methode startet dein Programm. 

Wie gehst du weiter vor, da stellt sich die Frage, was habt ihr schon gelernt.

Kennst du z.B. die Klasse Scanner mit der du leicht ein Wort einlesen kannst, welches der Benutzer per Kommandozeile eingegeben hat.
Kennst du die Klasse String mit der du z.B. mit length und charAt() die einzelnen Zeichen deines String ermitteln könntest.
Ich nehme an du weißt wie eine Schleife funktioniert?

Kurz: Was hast du schon gelernt?


----------



## Michael... (10. Nov 2011)

Was bei manchem digital native zwar verpönnt ist, aber m.M. trotzdem weiterhilft: Bücher. ;-)
Es gibt einige (auch online) Bücher, in denen diese Grundlagen erläutert werden.


----------



## MisterNewb (10. Nov 2011)

> Wie gehst du weiter vor, da stellt sich die Frage, was habt ihr schon gelernt.



Gute Frage.^^
Also wir sind per Folien schon einiges "durchgegangen", aber gelernt hat man noch nicht wirklich etwas..

Der Dozent hat eben alles schnell überflogen, bishin zu Schleifen bzw. do-while.
Also die Grundlagen eben bis Schleifen.




> Kennst du z.B. die Klasse Scanner mit der du leicht ein Wort einlesen kannst, welches der Benutzer per Kommandozeile eingegeben hat.
> Kennst du die Klasse String mit der du z.B. mit length und charAt() die einzelnen Zeichen deines String ermitteln könntest.
> Ich nehme an du weißt wie eine Schleife funktioniert?



Scanner hab ich noch nicht gehört, das mit length hat der Dozent schon erwähnt.


Als nächstes muss ich doch etwas mit BufferedReader eingeben, weil es per tastatur geschehen soll, oder?

Hab mir schonmal den Endschritt überlegt:


```
System.out.println("Vorwärts:");
System.out.println("Rückwärts:");
System.out.println("Buchstaben:");
```

Hier fehlt aber noch ein Zwischenschritt. Es ist ja kein Problem, im Internet herauszufinden, wie man zB. die Buchstaben zählt, aber ich habe hier ein Problem.
Ich weiß nicht, wie ich das "Vorwärts:" + den String kombiniere.




> Was bei manchem digital native zwar verpönnt ist, aber m.M. trotzdem weiterhilft: Bücher.
> Es gibt einige (auch online) Bücher, in denen diese Grundlagen erläutert werden.



Hab mir schon 2 Informatik-Bücher bestellt, dauert aber noch ein paar Tägchen. Online-Bücher mag ich nicht so, ich halte ein Buch lieber in der Hand.


----------



## Michael... (10. Nov 2011)

MisterNewb hat gesagt.:


> Ich weiß nicht, wie ich das "Vorwärts:" + den String kombiniere.


genau mit dem von Dir geschriebenen 
	
	
	
	





```
+
```
 ;-)

```
String rueckwaertsString = "streawkceur";
System.out.println("rueckwaerts: " + rueckwaertsString);
```
Wichtig für diese Aufgabenstellung ist, dass man mit Schleifen umgehen kann und dass man die Methoden von String kennt: String (Java Platform SE 6) hier findet man auch die bereits erwähnten Methoden length() und charAt(int i)
Falls das mit dem Einlesen der Benutzereingabe Probleme macht. Kann man ja erst einmal einen festen Wert vorgeben und mit diesem den Rest umsetzen. Wenn das klappt, kann man das dann ganz leicht durch eine Benutzereingabe ersetzen.


----------



## Fab1 (10. Nov 2011)

Hi



> Hier fehlt aber noch ein Zwischenschritt. Es ist ja kein Problem, im Internet herauszufinden, wie man zB. die Buchstaben zählt, aber ich habe hier ein Problem.
> Ich weiß nicht, wie ich das "Vorwärts:" + den String kombiniere.



weiß jetzt zwar nicht genau was du damit meinst, aber


```
System.out.println("Vorwärts:" + StringVariable);
```

ich hoffe ich hab hier nicht falsch verstanden.


hier mal ein Ansatz um einen String rückwärts auszugeben. Da ich nicht weiß wie ihr die Texteingabe machen sollt bzw. es sich in der Aufgabe so anhört, als müsstet ihr nur einen Namen in einem String speichern. Wie auch immer hier ein Ansatz:


```
public class Test {

	
	public static void main(String[] args) {
		

		String eingabe = javax.swing.JOptionPane.showInputDialog("Bitte ein Wort eingeben:");
		
		int stelle = eingabe.length()-1;
		String back = "";
		
		while(0<=stelle){
			
			back = back + eingabe.charAt(stelle);
			
			stelle=stelle-1;
		}
		
		System.out.println("Rückärts: " + back);
	}

}
```


----------



## dehlen (10. Nov 2011)

Ich würde mir eher den BufferedReader und den StringBuffer zu Hilfe nehmen.
Die Eingabe über die Konsole ist mit dem BufferedReader ganz einfach zu realisieren und der StringBuffer bietet praktischerweise gleich eine reverse() und eine length() Methode.

Also vllt so:

```
import java.io.*;

public class Nummer3 {
public static void main(String[] args) {
BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
StringBuffer x;
System.out.println("Geben sie ein Wort ein: ");
try {
x = new StringBuffer().append(r.readLine());
int length = x.length();
System.out.println("========================");
System.out.println("Eingegebenes Wort: "+x.toString());
System.out.println("Wort rückwärts: "+x.reverse().toString());
System.out.println("Länge des Wortes: "+length);
}
catch(IOException e) {
System.out.println("Bei der Worteingabe ist was schief gelaufen!");
}

}
}
```
Sry wegen falscher Formatierung oder sonstiger Fehler habs gerade im Browser getippt

Falls was unklar ist frag einfach


----------



## Fab1 (10. Nov 2011)

ich denke der Sinn der Aufgabe ist es, mit der Schleife zu machen. Die reverse Methode von dehlen zu benutzen ist sicher die einfachere, aber ich denke das dies euer Lehrer nicht wollte.  kannst ja mal beides testen.


----------



## MisterNewb (11. Nov 2011)

import java.io.*;
import java.util.*;
Ich hab das ganze jetzt so gelöst:



```
public class hausaufgabe3 {

	public static void main(String[] args) throws IOException {
		

		
		BufferedReader eingabe =new BufferedReader(new InputStreamReader(System.in));
		String s;
		
		s = eingabe.readLine();

		
		StringBuffer bf= new StringBuffer(300);
		bf.append(s);
		
		
		
		System.out.println("Vorwärts:" + s);
		System.out.println();
		System.out.println("Rückwärts:" + bf.reverse());
		System.out.println("Buchstaben:" + s.length());
```


Mein Dozent hat jetzt aber gesagt, ich soll es mit ner Schleife machen.

Als Tipp hab ich das bekommen: S.charAt(x)

???:L???:L


----------



## Gast2 (11. Nov 2011)

Du wirst reverse() wohl nicht verwenden dürfen, denn genau das sollst du ja programmieren 
Also musst du dich mit ner Schleife durch den String hangeln und den umgedrehten String per Hand zusammen bauen.
mit String#charAt(int i) bekommst du den Buchstaben an der Stelle i.


----------



## Camill (11. Nov 2011)

Das ganze ist doch recht einfach mit einer Schleife:

```
//...

	String forward = "abc";
	String reverse = "";
	
	for(int i = forward.length()-1; i >= 0; i--) {
		reverse += forward.charAt(i);
	}

	//...
```


----------



## Fab1 (12. Nov 2011)

Anscheinend hast du meinen Post nicht gelesen, schade eigentlich.


----------



## MisterNewb (12. Nov 2011)

Ich versuche das alles zu verstehen, was ihr mir schreibt, aber es fällt mir schwer, alles nachzuvollziehen.
Ich habe meine Aufgaben eigentlich nur anhand von den Folien aufgebaut und Beispielen, und diese dann versucht auf die gegebene Themenstellung umzubauen.
Sicher nicht der beste Weg, aber ich verstehe momentan noch nicht, was ich wann nutzen muss, um ein bestimmtes resultat zu erhalten. Woher denn auch, unser Dozent verliert 1-2 Sätze über eine Folie, geht zur nächsten über und meint dann, wir könnten danach alles anwenden, was er in nem Nebensatz mal kurz erwähnt hat. -.-




> hier mal ein Ansatz um einen String rückwärts auszugeben. Da ich nicht weiß wie ihr die Texteingabe machen sollt bzw. es sich in der Aufgabe so anhört, als müsstet ihr nur einen Namen in einem String speichern. Wie auch immer hier ein Ansatz:



Problem ist, dass du Sachen verwendest, die ich nicht kenne.


```
import java.io.*;
 
public class Nummer3 {
public static void main(String[] args) {
BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
StringBuffer x;
System.out.println("Geben sie ein Wort ein: ");
try {
x = new StringBuffer().append(r.readLine());
int length = x.length();
System.out.println("========================");
System.out.println("Eingegebenes Wort: "+x.toString());
System.out.println("Wort rückwärts: "+x.reverse().toString());
System.out.println("Länge des Wortes: "+length);
}
catch(IOException e) {
System.out.println("Bei der Worteingabe ist was schief gelaufen!");
}
 
}
}
```

Was ist denn zB try und catch?

Wir kennen bis jetzt nur do, while und if.


Ich weiß, dass ihr mir alle helfen wollt, aber ich kann eben nur mit den Dingen arbeiten, die mir zur Vefügung stehen. Ich habe es natürlich auch nicht explizit erwähnt, sry.

Könntet ihr mir das nochmal mit do, if und while erklären?


----------



## dehlen (12. Nov 2011)

Zu aller erstmal, wirf am besten mal meine Lösung über Bord, denn ihr sollt es ja per Schleife lösen.
Trotzdem beantworte ich dir gerne deine Fragen.

try/catch:
Beim einlesen eines Strings können Fehler auftreten(Exceptions). Um dieses Abzufangen benutzt man try/catch/finally.
Du versuchst also eine Handlung im try Block durchzuführen. Läuft aber etwas schief, springt er in den catch Block, derjenigen Exception die aufgetreten ist. Dort gibst du dann z.B eine Meldung aus, die dem User sagt was er falsch gemacht hat.

Zu if: if its eine ganz normale Überprüfung von Bedingung also: falls(Bedingung) dann {tu was};
Zu while: While ist eine Schleife. Du sagt dem Programm also: solange(Bedingung) {tu was};
Hier musst du natürlich drauf achten, das du eine Abbruchbedingung hast, denn sonst läuft die Schleife ja ewig durch.

Die do while Schleife unterscheidet sich dann nur noch dadurch, das zu erst im do Block eine Aktion ausgeführt wird und danach wird erst geprüft ob die Bedingung der while Schleife überhaupt erfüllt ist.

Zurück zu deinem Thema:
Lies den String per BufferedReader aus, wie du es bereits machst.
Und dann kannst du mit einer Schleife und charAt deinen String rückwärts bilden. Lösungen dazu findest du bereits in vorigen Posts.
Du lässt die Schleife quasi solange durchlaufen, wie dein String lang ist. Und bei jedem Durchgang hängst du den letzten Buchstaben des Strings an den neuen Rückwärts-String.

Beispiel von Camill:

```
String forward = "abc";
    String reverse = "";
    
    for(int i = forward.length()-1; i >= 0; i--) {
        reverse += forward.charAt(i);
    }
```


Überleg dir was da passiert. Also die for Schleife fängt bei 2 an und geht bis 0, da die Länge des Strings forward = 2 ist. Solange i nicht kleiner als 0 ist wird i um eins verringert. Also 1.Runde:
i =2
der String reverse = reverse +forward.charAt(i); So i ist ja 2 das heißt Reverse ist nun c weil das der Buchstabe an der zweiten Stelle des Strings forward ist.
Nun wird i um eins verringert. i= 1, und der String Reverse bekommt den zweiten Buchstaben des Strings forward also b. Da der String Reverse von eben schon das c hatte ist der String nun cb.
Das wird nun noch einmal gemacht sodass du cba hast. i ist dann gleich 0 und daher wird die for Schleife dann abgebrochen.


----------



## Fab1 (12. Nov 2011)

Hallo,

natürlich ist es sinnvoll, wenn du nur die Sachen verwendest, die du bereits kennst.

Die von dir beschriebene Aufgabe sollte auch kein Problem sein. Das einzige bei dem ich mir momentan nicht im klaren bin, ist wie die Abfrage 
	
	
	
	





```
Die Eingabe des Benutzers entsprechen einem Wort.
```
 Ich hätte dies einfach so verstanden. Du speicherst eine Zeichenkette "Text" in einer Variable. Und der Inhalt wird dann rückwärts ausgegeben. Sowie auch die Länge des Inhalts.

Nehmen wir mal das Beispiel. Die Benutzereingabe wird in der Variablen "eingabe" gespeichert.

Mithilfe von ".length" erhält man die Länge des Inhalts in der Variablen. (Es werden die einzelnen Zeichen gezählt).

Jetzt gibt es die Möglichkeit charAt(x); Das x steht für den Index der Buchstaben. 
Merke: Index fängt immer von 0 an. z.B. 


```
String eingabe = "Hallo";
System.out.println(eingabe.charAt(0)); // Der Buchstabe "H" wird ausgegeben.
```

Nun musst du dir überlegen. Du möchtest nicht den ersten Buchstaben sondern den letzten. Um den letzten zu erhalten muss man die Länge des Strings wissen. 
Also eingabe.length allerdings handelt es sich hier um einen Index und somit nimmt man 
eingabe.length-1

Dies kannst du zum Beispiel in einer Variablen speichern.


```
int anzahlBuchstaben = eingabe.length()-1;
```

Dies wäre im Fall Hallo also der letzte Buchstabe kurzer Test.


```
public class Testlauf{
	

public static void main(String[]args){

String eingabe = "Hallo";
int anzahlBuchstaben = eingabe.length()-1;
System.out.println(eingabe.charAt(anzahlBuchstaben)); // Der Buchstabe mit dem Index eingabe.length()-1 wird ausgegeben

System.out.println(eingabe.length()); // gibt die Länge des Strings aus.
	
      }
}
```

Jetzt musst du dir überlegen wie du es mithilfe einer z.B. While-Schleife schaffst den letzten bis zum ersten Buchstaben auszugeben.


----------



## MisterNewb (12. Nov 2011)

```
String forward = "abc";
    String reverse = "";
    
    for(int i = forward.length()-1; i >= 0; i--) {
        reverse += forward.charAt(i);
    }
```

Vielen Dank schonmal, ich habe jetzt zumindest mal den Sinn der Schleifen verstanden.
Man lässt die Schleife solange laufen, bis der Wert 0 ist und diese bricht dann automatisch ab, weil man es für 0 so festgelegt hat.
Was sagt dieses int aus?

Ich würde aber gerne die Schleife mit do und while bzw. if lösen.




> Die von dir beschriebene Aufgabe sollte auch kein Problem sein. Das einzige bei dem ich mir momentan nicht im klaren bin, ist wie die Abfrage Die Eingabe des Benutzers entsprechen einem Wort. Ich hätte dies einfach so verstanden. Du speicherst eine Zeichenkette "Text" in einer Variable. Und der Inhalt wird dann rückwärts ausgegeben. Sowie auch die Länge des Inhalts.



Genau so ist es gemeint!



> Nun musst du dir überlegen. Du möchtest nicht den ersten Buchstaben sondern den letzten. Um den letzten zu erhalten muss man die Länge des Strings wissen.
> Also eingabe.length allerdings handelt es sich hier um einen Index und somit nimmt man
> eingabe.length-1



Also eingabe.length-1 gibt mir immer den letzten Buchstaben des Strings aus?


```
public class Testlauf{
    
 
public static void main(String[]args){
 
String eingabe = "Hallo";
int anzahlBuchstaben = eingabe.length()-1;
System.out.println(eingabe.charAt(anzahlBuchstaben)); // Der Buchstabe mit dem Index eingabe.length()-1 wird ausgegeben
 
System.out.println(eingabe.length()); // gibt die Länge des Strings aus.
    
      }
}
```

Ich hab das mal in Java getestet, hier fehlt ja nicht nur, wie du gesagt hast, noch die Schleife, sondern auch noch das Buffered Reader, oder? Weil man hier nur 0 & 5 als ergebnis erhält, ohne etwas eingeben zu haben.


----------



## dehlen (12. Nov 2011)

was das int in der Schleife macht das lies mal bitte selber nach 
In dem Beispiel von GEEK brauchst du keinen BufferedReader.
Hier wird kein Wort eingegeben, was du Mithilfe des BufferedReaders auslesen müsstest, sondern hier wird das Wort sofort im Code festgelegt, nämlich "Hallo"

EDIT:
wenn du es per while lösen willst, dann schaue dir die erste Lösung von GEEK an.


> Also eingabe.length-1 gibt mir immer den letzten Buchstaben des Strings aus?


Jein.
charAt(eingabe.length()-1 bestimmt den letzten Buchstaben eines Strings.


----------



## Fab1 (12. Nov 2011)

mein Beispiel diente nur zur Erklärung der Funktion der entsprechenden Methoden. Es gibt es mehrere Möglichkeiten zu Speicherung von Eingaben. Ich hingegen glaube, dass du bei der Aufgabe keine Benutzereingabe brauchst.
Trotz allem würdest du dazu (Arten von Benutzereingaben) oben ein paar bereits genannte Beispiele finden.



> Was sagt dieses int aus?



Das ist eine normale Deklaration einer Variablen die allerdings nur innerhalb der Schleife gültig ist.

Edit: ich tippe ganz klar zu langsam :>


----------



## Camill (12. Nov 2011)

MisterNewb hat gesagt.:


> ```
> String forward = "abc";
> String reverse = "";
> 
> ...




Mit while-Schleife:

```
String forward = "abc";
    String reverse = "";
    
    int i = forward.length()-1;
    while(i >= 0) {
    	reverse += forward.charAt(i);
    	i--;
    }
```


----------



## MisterNewb (12. Nov 2011)

Also...



> mein Beispiel diente nur zur Erklärung der Funktion der entsprechenden Methoden. Es gibt es mehrere Möglichkeiten zu Speicherung von Eingaben. Ich hingegen glaube, dass du bei der Aufgabe keine Benutzereingabe brauchst.
> Trotz allem würdest du dazu (Arten von Benutzereingaben) oben ein paar bereits genannte Beispiele finden.



Ich verstehe das nicht ganz. In deinem Beispiel ist ein Wort fest definiert und wird dann umgewandelt.
Ich brauche es aber so, dass jedes Wort umgewandelt wird, was man eingiebt.

```
String forward = "abc";
    String reverse = "";
    
    int i = forward.length()-1;
    while(i >= 0) {
        reverse += forward.charAt(i);
        i--;
    }
```

Selbes Problem wie oben.


----------



## dehlen (12. Nov 2011)

Aha ok, nun ist schonmal klar, das du den User Wörter eingeben lassen willst, also braucht du den BufferedReader.
Ich verstehe dein Problem nicht ganz genau. Du findest hier alles was du brauchst in diesem Thema, um das Programm fertigzustellen.
Also:
BufferedReader -> Wort einlesen
while Schleige-> Wort rückwärts bilden
length-> Länge ermitteln
System.out.println-> Alles ausgeben


----------



## MisterNewb (12. Nov 2011)

Ich habe in dem Thread hier Schleifen und auch sonst alle Infos, aber nicht, wie man die Schleife mit dem Buffered Reader aufbaut, jedenfalls nicht mit while.


```
import java.io.*;

public class hausaufgabe4 {
 
    public static void main(String[] args) throws IOException {
        
 
        
        BufferedReader eingabe =new BufferedReader(new InputStreamReader(System.in));
        String s;
        System.out.println("Bitte Wort eingeben:");
        
        s = eingabe.readLine();
```

soweit bin ich jetzt.


----------



## dehlen (12. Nov 2011)

String mit BufferedReader einlesen:

```
import java.io.*;
String s = "";
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
try {
s = br.readLine();
}
```

hit while Schleifen den String rückwärts bilden:

```
String r = "";
int i = s.length();

while(i > 0) {
r += s.charAt(i-1);
i--;
}
```


----------



## MisterNewb (12. Nov 2011)

```
import java.io.*;

public class hausaufgabe4 {
 
    public static void main(String[] args) throws IOException {
        
 String s="";
 String r="";
        
        BufferedReader eingabe =new BufferedReader(new InputStreamReader(System.in));
        
        System.out.println("Bitte Wort eingeben:");
        
        s = eingabe.readLine();
        int i = s.length()-1;
        System.out.println("Länge" + i);
        
        while(i > 0) {
            r += s.charAt(i);
            i--;
            
            System.out.println("Rückwärts" +r);
            
        }
        
    	 
    }
	}
```


Irgendetwas stimmt hier nicht. Gebe ich zB "affe" ein ist das Ergebnis:

Bitte Wort eingeben:
affe
Länge3
Rückwärtse
Rückwärtsef
Rückwärtseff

ok, hinter Rückwärts & Länge fehlt der : und ein Leerzeichen, aber wieso spuckt er das Rückwärts 3x aus? Die Länge stimmt auch nicht.


----------



## dehlen (12. Nov 2011)

Leerzeichen bei den System.out.println Anweisungen !
und int i = s.length();
nicht -1

EDIT:
Achse und das letzte System.out.println aus der while Schleife nehmen.
Also so:

```
import java.io.*;

public class Test  {

public static void main(String[] args) throws IOException {
String s = "";
String r = "";
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Geben sie ein Wort ein: ");

s = br.readLine();
int i = s.length();

System.out.println("Ursprünglich: "+s);
System.out.println("Länge: "+i);

while(i > 0) {
r += s.charAt(i-1);
i--;
}
System.out.println("Rückwärts: "+r);

}
}
```


----------



## MisterNewb (12. Nov 2011)

gesagt, getan, jetzt kommt:



> Bitte Wort eingeben:
> affe
> Länge: 4
> Exception in thread "main" java.lang.StringIndexOutOfBoundsException: String index out of range: 4
> ...


----------



## dehlen (12. Nov 2011)

s.charAt(i-1);
nicht s.charAt(i);


----------



## devo22 (12. Nov 2011)

MisterNewb hat gesagt.:


> gesagt, getan, jetzt kommt:


Es funktioniert, wenn du in der letzten while-Schleife i >= 0 definierst, nicht i > 0.


----------



## dehlen (12. Nov 2011)

devo22 hat gesagt.:


> Es funktioniert, wenn du in der letzten while-Schleife i >= 0 definierst, nicht i > 0.



Nein würde es nicht.
Er muss einfach nur in der while Schleife ein -1 ergänzen bei der charAt Methode.
Durch das >= 0 wäre der Index trotzdem noch zu groß beim ersten Durchlauf der while Schleife.

PS: Klassennamen schreibt man groß.
EDIT: Schau dir einfach den Post von mir an (NR 25) da ist es richtig, so wie es funktioniert.


----------



## MisterNewb (12. Nov 2011)

wenn ich das s.char verändere kommt:


> Bitte Wort eingeben:
> affe
> Länge: 4
> Rückwärts: e
> ...



Das Rückwärts soll aber nur 1x kommen.



> Es funktioniert, wenn du in der letzten while-Schleife i >= 0 definierst, nicht i > 0.



Wenn ich das zusätzlich noch mache kommt:



> Bitte Wort eingeben:
> affe
> Länge: 4
> Rückwärts: e
> ...


----------



## dehlen (12. Nov 2011)

MisterNewb hat gesagt.:


> wenn ich das s.char verändere kommt:
> 
> 
> Das Rückwärts soll aber nur 1x kommen.
> ...



Lies meine Posts!
Das System.out.println muss aus der while Schleife raus und die Bedingung bleibt so wie sie war.


----------



## MisterNewb (12. Nov 2011)

sry, hab das edit nichtmehr gesehen.


----------



## MisterNewb (12. Nov 2011)

noch ne dumme frage:

warum wird das i nicht als string definiert, stattdessen aber mit dem int versehen? ich hab mich jetzt zwar schon schlau gemacht, was int bedeutet, verstehe diesen punkt aber noch nicht so richtig.


----------



## devo22 (12. Nov 2011)

MisterNewb hat gesagt.:


> noch ne dumme frage:
> 
> warum wird das i nicht als string definiert, stattdessen aber mit dem int versehen? ich hab mich jetzt zwar schon schlau gemacht, was int bedeutet, verstehe diesen punkt aber noch nicht so richtig.


int steht für Integer, einen Datentyp für Zahlen. i ist die Länge deines Wortes, also ist das eine Zahl und kann kein String sein.


----------



## dehlen (12. Nov 2011)

MisterNewb hat gesagt.:


> noch ne dumme frage:
> 
> warum wird das i nicht als string definiert und mit dem int versehen? ich hab mich jetzt zwar schon schlau gemacht, was int bedeutet, verstehe diesen aber noch nicht so richtig.



Tut mir leid da kann ich dir nicht folgen. Wie kann man denn eine Variable als String definieren aber mit einem int versehen ?!

Beides sind Datentypen. Strings enthalten Zeichenketten also Wörter. 
int repräsentiert einen Zahlenwert zwischen − 2,147,483,648 bis 2,147,483,647. 


Schau mal in die Insel in die ersten Kapitel, dort werden all solche Dinge erklärt


----------



## MisterNewb (12. Nov 2011)

dehlen hat gesagt.:


> Tut mir leid da kann ich dir nicht folgen. Wie kann man denn eine Variable als String definieren aber mit einem int versehen ?!
> 
> Beides sind Datentypen. Strings enthalten Zeichenketten also Wörter.
> int repräsentiert einen Zahlenwert zwischen − 2,147,483,648 bis 2,147,483,647.
> ...



hab den satz editiert, du hast ihn leider davor noch erwischt


----------



## MisterNewb (12. Nov 2011)

Ich hab noch eine Aufgabe, aber keine Angst, die hab ich schon fertig.
Nur eine Sache funktioniert nicht:


```
import java.io.*;

public class Hausaufgabe1{
    
    public static void main(String[] args) throws IOException {
        
        // Benötigte Variablen deklarieren
        String eingabeZeile;
        double m= 0.0;
        double yard;
        double f;
        String Eingabezeile;
        double m1 = 0.0;
        double y1 ;
        BufferedReader eingabe =new BufferedReader(new InputStreamReader(System.in));
        String s;
        // möglich ist auch: double m=0.0, y;    }
        
        
        do  {
        	
        	
            /* Berechnung m in yard und feet */
            // Für die Eingabe von der Tastatur
            System.out.println("Geben Sie die Meter ein:");
            s = eingabe.readLine();
            m = Double.parseDouble(s); // Umwandlung von String in Double
            yard =    m* 1.0936133;
            // Formel feet
        f = m * 3.2808399;
        
        if (m==0);
        {
        
            System.out.println("Yards:" + yard);
            System.out.println("Feet:" + f);
            System.out.println();
            
    
            

        
            
            /* Berechnung yard in m */
            // Für die Eingabe von der Tastatur
            System.out.println("Geben sie Yard ein:");
            s=eingabe.readLine();
            yard = Double.parseDouble(s);
            m= yard* 0.9144;
        System.out.println("Meter:" + m);
        { while (Math.abs(m) >0);
        System.out.println("Das wars!");
        
        }
        }
        }
        }
        }
```

Ich will, dass wenn die if-Bedingung erfüllt ist, alles aufhört, das Programm also bis ganz nach unten durchgeht. Was stimmt denn da an der if-Konstruktion nicht?


----------



## Fab1 (12. Nov 2011)

hab den Code nur überflogen, aber ich nehme erstmal an dass hier das Semikolon weg kommt 


```
if (m==0){
	        	System.out.println("Es wird unten weitergemacht.");
	        }else{
	        	 {
	        	        
	                 System.out.println("Yards:" + yard);
	                 System.out.println("Feet:" + f);
	                 System.out.println();

	                 /* Berechnung yard in m */
	                 // Für die Eingabe von der Tastatur
	                 System.out.println("Geben sie Yard ein:");
	                 s=eingabe.readLine();
	                 yard = Double.parseDouble(s);
	                 m= yard* 0.9144;
	             System.out.println("Meter:" + m);
	             { while (Math.abs(m) >0){
	             System.out.println("Das wars!");
	             }
	             }
	             }
	             }
```

Weiß nicht genau, ob du das so wolltest. Sah aber für den ersten Blick so aus. Schau dir deine Semikolon bei deinem geposteten Code mal nochmal an vorallem Zeile 32 und Zeile 51


----------



## MisterNewb (12. Nov 2011)

Ist nun weg, unten bei der geschweiften Klammer kommt noch eine Fehlermeldung:



> Syntax error, insert "while ( Expression ) ;" to complete DoStatement



Was muss ich denn noch an dem while ändern?


----------



## Fab1 (12. Nov 2011)

Ah sry ich seh gerade ich hab das mit der Do While Schleife übersehen. 


Somit kommt in Zeile 51 natürlich ein Semikolon und nicht die Klammer wie ich geschrieben habe. Tut mir Leid.

Der Fehler hat etwas mit den geschweiften Klammern zu tun. Evtl. postest du nochmal deinen jetzigen Code oder du probierst selbst nochmal rum.

Es ist so, dass die geschweiften Klammern erst nach deiner While Bedingung geschlossen werden und das mag der Compiler nicht.


----------



## MisterNewb (12. Nov 2011)

Also, wenn ich das if-konstrukt weglasse funktioniert alles, dann endet die anwendung aber nicht, wenn man bei meter 0 eingiebt.


----------



## MisterNewb (13. Nov 2011)

noch jemand ne idee?


----------



## Camill (13. Nov 2011)

Was genau soll das Programm denn machen? Nur das umwandeln von: 
- Meter in Yard & Feet
- Yard in Meter
oder noch etwas?


----------



## MisterNewb (13. Nov 2011)

Das Programm soll:

Meter in Yard & Feet 
und
Yard in Meter umrechnen

Sobald man 0 eingiebt, soll es aber enden. Sonst soll es immer weiterlaufen.

Und ohne die if Schleife habe ich das Problem, dass es erst nach der Yard-Eingabe endet, es soll aber schon nach der ersten Eingabe enden.


----------



## Camill (13. Nov 2011)

Ich nehme an es soll Menügesteuert ablaufen oder sollen beide Abfragen(Meter & Yard) direkt hintereinander abgefragt werden?


----------



## MisterNewb (14. Nov 2011)

Es soll nacheinander ablaufen, also erst Meter in Yard und Feet, wenn man keine 0 eintippt, soll es weiterlaufen, dass man die nächste Eingabe machen kann, die dann Yard umwandelt.


----------



## Marcinek (14. Nov 2011)

Hier sind drei Seiten Postings. Und man unterhält sich nun nach dem "Uhh was muss ich eigentlich machen".

@TO: Findest du nicht, dass deine defizite so stark sind, dass eine konsequente Einarbeitung in das Thema benötigt wird. 

Ich denke das Forum kann dir hier nicht weiterhelfen als mit einer Komplettlösung und diese würde für dich und deine Ausbildung doch eher kontroproduktiv sein.


----------



## MisterNewb (14. Nov 2011)

Hab das Problem gelöst: 


```
import java.io.*;

public class Hausaufgabe1{
    
    public static void main(String[] args) throws IOException {
        
        // Benötigte Variablen deklarieren
        double m= 0.0;
        double yard;
        double f;
        
        BufferedReader eingabe =new BufferedReader(new InputStreamReader(System.in));
        String s;
        
        
        do  {
        	
        	
            /* Berechnung m in yard und feet */
            // Für die Eingabe von der Tastatur
            System.out.println("Geben Sie die Meter ein:");
            s = eingabe.readLine();
            m = Double.parseDouble(s); // Umwandlung von String in Double
            yard =    m* 1.0936133;
            // Formel feet
        f = m * 3.2808399;
        
       if (m>0){
        
            System.out.println("Yards:" + yard);
            System.out.println("Feet:" + f);
            System.out.println();
        
    
            

        
            
            /* Berechnung yard in m */
            // Für die Eingabe von der Tastatur
            System.out.println("Geben sie Yard ein:");
            s=eingabe.readLine();
            yard = Double.parseDouble(s);
            m= yard* 0.9144;
        System.out.println("Meter:" + m);
        
       }
        } while(Math.abs(m) >0);
        System.out.println("Das wars!");
        
        }
        }
```

Jetzt noch Struktogramme schreiben und ich bin endlich erlöst


----------



## MisterNewb (14. Nov 2011)

Marcinek hat gesagt.:


> Hier sind drei Seiten Postings. Und man unterhält sich nun nach dem "Uhh was muss ich eigentlich machen".
> 
> @TO: Findest du nicht, dass deine defizite so stark sind, dass eine konsequente Einarbeitung in das Thema benötigt wird.
> 
> Ich denke das Forum kann dir hier nicht weiterhelfen als mit einer Komplettlösung und diese würde für dich und deine Ausbildung doch eher kontroproduktiv sein.



Ich habe nicht umsonst erwähnt, dass ich ein absoluter Neuling bin. Dass noch viel Lernbedarf besteht, weiß ich selbst. Ich wollte auch nie eine Komplettlösung, ich habe nur einige Schritte nicht nachvollziehen können, inzwischen habe ich es aber verstanden.


----------

