# Eine Variable an eine Methode mit Array übergeben



## riaat (4. Aug 2006)

Hallo,
ich habe ein Problem bezüglich des Übergebens einer Variable in eine Methode "add()" die sich in einer Klasse "VectorMatrix"befindet.
Die Methode  public static double[] add(double[] a, double[] b){...

                                  }
soll die beiden Variablen a und b von einem Objekt vom Typ VectorMatrix testen, a und b sollen dabei die Länge der Arrays darstellen.
Wie kann ich hier den Arrays Werte zuweisen?


```
VectorMatrix vector = new VectorMatrix();
          vector.add(????)
```

Danke schon mal im voraus...[/i]


----------



## SlaterB (4. Aug 2006)

a und b sind selber Arrays oder Längen von Arrays?


wie arbeitet man mit einem Array?

double[] a = new double[100];
a[3] = 15.5;


was ist eigentlich deine Frage?


----------



## Guest (4. Aug 2006)

riaat hat gesagt.:
			
		

> Hallo,
> ich habe ein Problem bezüglich des Übergebens einer Variable in eine Methode "add()" die sich in einer Klasse "VectorMatrix"befindet.



So, das ist der Teil den ich noch verstehe.



			
				riaat hat gesagt.:
			
		

> Die Methode
> 
> ```
> public static double[] add(double[] a, double[] b){...
> ...



Die Methode soll was genau testen? Meinst du mit a und b die Parameter dieser *statischen* (kommen wir gleich noch zu) Methode? Oder hat dein Objekt vom Typ VectorMatrix auch zwei Variablen, die a und b heißen?



			
				riaat hat gesagt.:
			
		

> , a und b sollen dabei die Länge der Arrays darstellen.




```
double[] a; // <- a ist hier ein Array vom Typ double
int length = a.length; // <- length enthält jetzt die Länge vom Array a

a = new double[10]; // <- Array das 10 double Werte aufnehmen kann
length = a.length; // <- jetzt würde in length 10 stehen
```



			
				riaat hat gesagt.:
			
		

> Wie kann ich hier den Arrays Werte zuweisen?
> 
> 
> ```
> ...



Von welchen Arrays sprichst du denn hier? 
Nebenbei hast du add als statische Methode deklariert, da brauchst du gar keine Instanz von VectorMatrix anlegen, die arbeiten eh alle mit der gleichen Methode. Ich weiß nur nicht ob du das echt möchtest!


----------



## riaat (4. Aug 2006)

Ok, ich versuch noch mal meine Situation darzustellen:

Ich habe zwei Klassen. Die 1. heißt VectorMatrix und beinhaltet eine Methode 
	
	
	
	





```
public static double[]  add(double[] a, double[] b) { die hier etwas ausführt...}
```

Jetzt möchte ich aber eine 2. Klasse als Anwendung schreiben, die diese Methode testet, indem sie 2 konstante Werte a und b (Array-Längen) an add() übergibt und das Ergebnis durch die Anwendung ausgegeben wird. 
Wie muss nun das Objekt aussehen, damit dies gelingt? Mein Ansatz war: 
	
	
	
	





```
VectorMatrix vector = new VectorMatrix();
vector.add([12],[34]);
```



Ich hoffe etwas Klarheit in die Sachen gebracht zu haben...


----------



## SamHotte (4. Aug 2006)

So geht das nicht. Wenn die Methode add(..) wie oben deklariert ist, muss man halt zwei double-Arrays übergeben, bspw. so:

```
double[] bla = new double[12];
for (int i=0; i<12; i++)
    bla[i] = i;
double[] blubb = new double[34];
for (int i=0; i<34; i++)
    blubb[i] = 100-i;
vector.add(bla, blubb);
```


----------



## Gast (4. Aug 2006)

Ich glaube du solltest dir dringend noch mal ein paar Grundlagen durchlesen. Sorry, aber ist so!
Also um es noch mal deutlich zu sagen:

```
double a = 1.2384742; // ist ein double
double[] b; // ist ein Feld von double, hier noch nicht initialisiert
double[] c = new double[10]; // ist ein Feld, dass 10 double enthält

c[0] = a; // geht, jetzt steht in dem Feld c an der ersten Stelle der Wert von a

a = c[0]; // geht auch, völlig analog

a = c; // geht überhaupt nicht, null
c = a; // "
```

Und wenn deine Methode statisch ist, dann solltest du nochmal gucken, was genau statische Methoden machen:


```
VectorMatrix.add(...); // so sollte der statische Aufruf aussehen, kein new nötig da statisch! (ich glaube immer noch, dass du das gar nicht willst)
```


----------



## riaat (4. Aug 2006)

In der Tat bin ich dabei mir Java inklusive Grundlagen anzueignen. Hierbei stößt man naturgemäß auf Probleme im Zusammenhang mit Aufgabenstellungen.
Höchst wahrscheinlich fehlt mir die richtige Formulierung für ein relativ kleines Problem.
Deshalb ganz simpel gesagt:
Ich möchte eine kleine Anwendung schreiben, mit der ich einige Fälle testen kann, indem ich hierfür die Methode add() aus dem folgenden Programm benutze:

```
public class VectorMatrix {

/** Addition zweier Vektoren. 

 *  Die beiden double-Arrays a und b werden 
 *  elementweise addiert und das Ergebnis als neues
 *  Array geliefert.

 *  Fehlende Elemente des kürzeren oder fehlenden 
 *  Arrays werden als 0.0 angesehen.

 *  Ausnahmen werden nicht ausgelöst. Es wird auf  
 *  jeden Fall ein Ergebnisarray - gegegenenfalls  
 *  eins der Länge 0 - zurückgeliefert. 
 *  @param a Summand
 *  @param b Summand
 *  @return Die Summe
 */  
  public static double[] add(double[]a, double[]b){
     int la = a != null ? a.length : 0;
     int lb = b != null ? b.length : 0;
     if (la == 0 && lb == 0) 
        return a != null ? a : b != null ? b 
                         : new double[0];
     // ab hier hat mindestens eines der Arrays 
     //  mindestens ein Element.

     double[] ret;
     if (lb > la) { // Referenzen tauschen
        ret = a;
        a   = b;    
        b   = ret;
        lb  = la;
     } // Referenzen tauschen
     ret = (double[])a.clone();
     for (int i = 0; i < lb; ++i)
        ret[i] += b[i];
     return ret;  
  } // add(double[], double[]) 

} // class VectorMatrix
```


----------



## Gast (4. Aug 2006)

Oh, hast du mal C Programmiert? Sorry, nur so mein Stereotypes Denken!
Schön dass du jetzt auch dein Problem schilderst. Damit verstehe ich wieder was du machen möchtest!
Du solltest den ? : Operator meiden. Er ist natürlich erlaubt, er macht Code aber nicht wirklich lesbarer. Schöner ist immer ein if ... else ...
Zudem sollte man auch möglichst elementare Schritte durchführen. Der Compiler ändert intern eh jede Menge, du solltest immer nur für lesbaren Code sorgen (-> besserer Code in jeder Hinsicht, weniger Fehler, Robuster, Wartbarer,...)

Die Signatur deiner Methode ist schon mal gar nicht falsch. 
Was du intern machten musst ist auch recht einfach. Als erstes prüfst du ob beide Arrays existieren (!= null) dann schaust du ob sie gleich lang sind. Ist dies nicht der Fall, würde ich eher zur Exception greifen. Ein return null zeigt auch besser, das etwas nicht geklappt hat. Ein leeres Array wirkt (auf mich) so als ob alles geklappt hat (beide Arrays a und b waren halt nur leer).


```
public static double[] add(double[] a, double[] b) {
  // prüfen ob beide Arrays vorhanden sind
  if (a == null || b == null) {
    return null; 
  }
  
  // prüfen ob beide Arrays gleich lang sind
  if (a.length != b.length) {
    return null;
  }

  // hier landet man nur, wenn es zwei gleich lange Arrays gibt!
  
  // anlegen des neuen Arrays
  // statt a.length kann auch die gleiche Länge b.length genommen werden
  double result[] = new double[a.length];
  
  // alle Elemente paarweise addieren
  for (int i = 0; i < res.length; i++) {
    result[i] = a[i] + b[i];
  }

  // rückgabe 
  return result;
```

Das ist alles


----------

