# Ausgeben der Eingabewerte einer Methode



## Gabbiadini (28. Dez 2004)

Hallo zusammen,
wie ihr gleich seht, bin ich noch blutiger Java-Anfänger. Ich zerbreche mir seit drei Stunden den Kopf, und komme einfach nicht weiter...im Internet und in meinem Java-Buch hab ich keinen funktionierenden Ansatz gefunden.

Ich habe die Aufgabenstellung, in einer separaten Methode double-Werte einzulesen, und diese in der main() Methode auszugeben bzw. in anderen Methoden weiter zu verarbeiten. Allerdings scheitere ich schon an der Ausgabe in main() ???:L 

Meine Methode zum Einlesen sieht derzeit folgendermaßen aus:

```
class EIN
{
	static double[] messein ()		
	{
		double eingabe[];
		int i=1, abbruch=0;		
		eingabe=new double[8];		
		do
		{
			System.out.print("Bitte geben Sie einen Messwert ein: ");		
			eingabe[i]=IO1.eindouble();
			i=i++;
			System.out.print("Bitte eine 1 eingeben, wenn weitere Berechnung erwuenscht: ");		 
			abbruch=IO1.einint();
			return eingabe;	
		}
		while (abbruch==1);		
	}		
}
```
*IO1 ist eine Methode zum Einlesen von Integer und Double-Werten, die ich vorgeben bekommen habe.


Wie hole ich mir jetzt die einzelnen Werte in die main() Methode hinüber, so daß nach Eingabe aller Werte diese nochmal ALLE ausgegeben werden? Bzw, daß ich sie weiterverarbeiten kann (Durchschnitt, etc)?

Wäre super, falls mich jemand auf den richtigen Ansatz bringen kann!

Thomas


----------



## Oskar (28. Dez 2004)

Hiho,

deine Methode wird bei jedem (sprich insbesondere beim ersten) Durchlauf der Schleife zurück in die aufrufende Methode springen. Das return sitzt an der "falschen" Stelle.

Wenn du das gesamte Array zurückgegeben haben willst sollte es wie folgt lauten:



```
class EIN
{
   static double[] messein ()      
   {
      double eingabe[];
      int i=1, abbruch=0;      
      eingabe=new double[8];      
      do
      {
          //...
      }
      while (abbruch==1);
      return eingabe;     
   }      
}
```

Jetzt gibt die Methode alle eingegebenen Werte zurück. Diese kannst du in der main-Methode in ein entsprechendes double Array verpacken.

So far... hope that helps.
Oskar


----------



## Gabbiadini (28. Dez 2004)

Danke für die Antwort - so hatte ich es zuerst auch schonmal gehabt.
Habe es jetzt wieder so wie von dir vorgeschlagen, aber ich bekomme es dennoch nicht hin. Ich weiß einfach nicht, wie ich die einzelnen Werte in der main() Methode ansprechen kann. Woher soll die main() Methode wissen, wieviele Werte sie ausgeben soll? Hier mal zwei von meinen zahlreichen Versuchen:



```
class programm16
{
	public static void main (String args[])	
	{
		double wert[];
		wert=new double[8];		
		wert=EIN.messein();		
		System.out.print(wert);
	}
}
```
...erzeugt folgende Ausgabe (egal welche und wieviele Werte ich eingebe): *[D@14fe5c*


```
class programm16
{
	public static void main (String args[])	
	{
		double wert[];
		int i=1;
		wert=new double[8];		
		wert=EIN.messein();		
		System.out.print(wert[i]);
	}
}
```
...wenn ich's so mache (daß es so nicht richtig sein kann, ist mir klar) wird immer nur der letzte der eingegebenen Werte ausgegeben.


Irgendwie werde ich das Gefühl nicht los, daß ich gewaltig ein Brett vor den Kopf habe :bahnhof:


----------



## SebiB90 (28. Dez 2004)

mach es mal so

```
class programm16 
{ 
   public static void main (String args[])    
   { 
      double []wert = EIN.messein();       
      for(int i = 0; i < wert.length; i++) {
        System.out.print(wert[i]); 
      }
   } 
}
```
ich bin jetzt nicht sicher ob das wert.length oder wert.length() heißt  
musst du ausprobieren


----------



## L-ectron-X (28. Dez 2004)

SebiB90, so wie Du es geschrieben hast, ist es richtig.
length ist eine Variable, keine Methode.


----------



## SebiB90 (28. Dez 2004)

war mir nicht mehr sicher was es war
irgendwo gibt es aber auch length() nur wo weiß ich nich mehr


----------



## L-ectron-X (28. Dez 2004)

Die Klasse String hat z.B. eine solche Methode, um die Länge (Anzahl der Zeichen eines Strings) ermitteln zu können.

```
String str = "Beispiel";
int i = str.length();
```


----------



## Gabbiadini (28. Dez 2004)

Die Idee hört sich sehr gut an 

Leider scheint's aber immer noch ein Problem zu geben - die Ausgabe damit erzeugt folgendes (damit's hier deutlicher wird mit println):


```
...
Bitte geben Sie einen Messwert ein: 7
Bitte eine 1 eingeben, wenn weitere Berechnung erwuenscht: 1
Bitte geben Sie einen Messwert ein: 4
Bitte eine 1 eingeben, wenn weitere Berechnung erwuenscht: 1
Bitte geben Sie einen Messwert ein: 3
Bitte eine 1 eingeben, wenn weitere Berechnung erwuenscht: 0

Ausgabe:
0.0
3.0
0.0
0.0
0.0
0.0
0.0
0.0
```
Der letzte Eingabewert steht stehts an der Stelle wo die 3 steht - die anderen werden nicht angezeigt. Liefert meine Methode evtl. nur einen einzigen double-Wert?


----------



## SebiB90 (28. Dez 2004)

kannst du mal den ganzen code posten?


----------



## L-ectron-X (28. Dez 2004)

Ich habs ein wenig umgebaut. Den ganzen static Kram rausgehauen, eben so das IO-Tools-Zeug.
Du hast die Größe des double-Arrays begrenzt, daher gibts nun auch einen Test auf die Array-Dimensionen.
Wenn das Array voll ist, wird die Eingabe abgebrochen und das Array zurückgegeben.

```
import java.io.*;

public class EIN
{
   public double[] messein ()
   {
      double[] eingabe = new double[8];
      int i = 0;
      String abbruch = null; 
      BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
      do
      {
         try {
            System.out.print("Bitte geben Sie einen Messwert ein: ");
            eingabe[i] = Double.parseDouble(br.readLine());
            i++; //hier lag der Fehler, entw. so oder i = i + 1; !!!
            System.out.print("Ist eine weitere Berechnung erwuenscht?  (j/n) ");
            abbruch = br.readLine();
         }
         catch(IOException e) {
            System.out.println("Fehler bei Eingabe");
         }
      }
      while (abbruch.equals("j") && i < eingabe.length);
      if(i == eingabe.length)
         System.out.println("Array voll! Keine weitere Eingabe moeglich!");
      
      return eingabe;
   }
}
```


```
public class Programm16 {
   public static void main (String args[]) {
      EIN ein = new EIN();
      double wert[] = ein.messein();
      for(int i = 0; i < wert.length; i++)
         System.out.println(wert[i]);
   }
}
```


----------



## Gabbiadini (29. Dez 2004)

Wow, vielen Dank. Das wäre echt nicht nötig gewesen!
Wenn ich's so benutze, bin ich allerdings nicht wirklich in der Lage zu erklären, wie es funktioniert :wink: 

Danke auch für den Hinweis auf meinen Fehler mit "*i++*", doch ein ziemlich peinlicher Fehler  

Daraufhin habe ich jedenfalls noch etwas probiert, und die Sache jetzt auch mit zusätzlicher Abfrage soweit am Laufen. Da gibt's sicher noch Verbesserungspotential, aber so ist's zumindest glaubwürdig, daß das Programm von mir stammt   


```
class EIN
{
	static double[] messein ()		
	{
		double eingabe[];
		int i=1, anzahl=-1;		
		while (anzahl<1)
		{ 	System.out.print("Bitte geben Sie die Anzahl Ihrer Messwerte ein (mindestens 1): ");		 
			anzahl=IO1.einint();
			System.out.println();
		}		
		eingabe=new double[anzahl];		
		do
		{
		System.out.print("Bitte geben Sie den "+i+". Messwert ein: ");		
		eingabe[i-1]=IO1.eindouble();			
		i++;
		}
		while (i<=anzahl);
		System.out.println();
		return eingabe;		
	}		
}
```



```
class programm16
{
   public static void main (String args[])
   {
      double wert[] = EIN.messein();
      for(int i=0; i<wert.length; i++)
      System.out.println(wert[i]);
   }
}
```

Jetzt kann ich mich also an die komplizierteren Teile des Programms begeben 8)


Danke an alle für die Hilfe, alleine säße ich vermutlich immer noch verzweifelt vorm Rechner :toll:


----------



## Gabbiadini (4. Jan 2005)

Habe dazu jetzt doch noch eine weitere Frage.

Ich habe mir das ganze jetzt so vorgestellt, daß ich den Benutzer zuerst alle Werte eingeben lasse, und anschließend verschiedene Sachen mit diesen Werten anstelle (Sortieren, Mittelwert, etc.).

Dafür habe ich für das Sortieren, den Mittelwert, etc jeweils wieder eine eigene Methode programmiert, die ich aus main() aufrufe. Das Einbinden klappt auch wunderbar - allerdings mit einem Problem: Es werden nicht die bereits eingegebenen Werte übernommen, sondern der Benutzer wird bei jeder einzelnen "Untermethode" wieder zu einer neuen Eingabe aufgefordert.

Was mache ich falsch? Mein Java-Buch ist für diese Geschichte nicht all zu hilfreich :cry:


Hier mal etwas Quellcode, der Übersichtlichkeit halber nur von der Eingabemethode und der "Mittelwert"-Methode

Eingabemethode

```
class EINGABE
{
	static double[] messein()		
	{
		double eingabe[];
		int i=1, anzahl;		
		do
		{ 	System.out.print("Bitte geben Sie die Anzahl Ihrer Messwerte ein (mindestens 1): ");		 
			anzahl=IO1.einint();
			System.out.println();
		}
		while (anzahl<1);			
		eingabe=new double[anzahl];		
		do
		{		
		System.out.print("Bitte geben Sie den "+i+". Messwert ein: ");		
		eingabe[i-1]=IO1.eindouble();			
		i++;
		}
		while (i<=anzahl);
		return eingabe;
	}		
}
```


Mittelwert - mwert() :

```
class MITTELWERT
{
   static double mwert()
   {
      double addition=0, mittel=0;
      double wert[] = EINGABE.messein();
      for(int i=0; i<wert.length; i++)
      {
      addition=addition+wert[i];
      }
      mittel=addition/wert.length;
	  return mittel;
   }		
}
```


Aus der main() Methode:
Zunächst rufe ich die Eingabemethode auf:

```
EINGABE.messein();
```

Dann die Ergebnisse der mwert() Methode (was auch so klappt, aber wie gesagt vorher wieder eine Neueingabe fordert):

```
System.out.println("Das arithmetische Mittel betraegt: "+MITTELWERT.mwert());
```


Ich hoffe ich blamiere mich nicht all zu sehr, wenn ich mir so die anderen Anfängerfragen ansehe.
Wäre trotzdem super, wenn mir wieder jemand auf die Sprünge helfen könnte!


----------



## Beni (5. Jan 2005)

Betrachten wir mal diese Methode:

```
class MITTELWERT
{
   static double mwert()
   {
      double addition=0, mittel=0;
      double wert[] = EINGABE.messein();  // << hier forderst du den Benutzer auf, Eingaben zu machen
      for(int i=0; i<wert.length; i++)
      {
      addition=addition+wert[i];
      }
      mittel=addition/wert.length;
     return mittel;
   }      
}
```


Und jetzt versuch mal sowas:

```
public static void main( String[] args ){
  double[] wert = EINGAGE.messein();
  MITTELWERT.mwert( wert );
  SUMME.summe( wert );  // << nach demselbem Schema
}
```


```
class MITTELWERT
{
   static double mwert( double[] wert )
   {
      double addition=0, mittel=0;
      for(int i=0; i<wert.length; i++)
      {
      addition=addition+wert[i];
      }
      mittel=addition/wert.length;
     return mittel;
   }      
}
```
Dann wird "EINGABE.messein" nur einmal aufgerufen, und somit muss der Benutzer nur einmal seine Eingaben machen.


----------



## Gabbiadini (5. Jan 2005)

Hab die Methode also komplett an der falschen Stelle aufgerufen...vielen Dank, jetzt habe ich es genau so, wie ich es haben wollte 

Allmählich komme ich doch langsam dahinter...mit der Betonung auf langsam :autsch:


----------



## sliwalker (5. Jan 2005)

Hoi,

ja, die Methode hast Du an der falschen Stelle aufgerufen.
So wie Du es gemacht hast, legst Du in Mittelwert nochmal ein neues Array an.
Das ist dann aber in der Klasse Summe nicht bekannt.

Deshalb musst Du es in main anlegen und allen Methoden mit übergeben.

greetz
SLi


----------

