# Rechnen mit komplexen Zahlen



## F34RL355 (11. Nov 2009)

Hallo !

Ich hab versucht eine Klasse Complex zu erstellen, mit einer Methode die mir 2 komplexe Zahlen addiert. Damit es ein bisschen schwieriger wird, hab ich Realteil und Imaginärteil mit dem Modifier final belegt.


```
class Complex{  
  
  final int real;
  final int imag;
  
  Complex(int r, int i){
    real = r;
    imag = i;
    
  }  
  
  public Complex add(Complex c){     
    Complex d = new Complex(this.real+c.real , this.imag+c.imag);
    return d;
  }
  
  public String toString(){
  return d.real + "" + d.imag;
  
  }
}
```

Das Problem ist, dass der Compiler d.real + d.imag nicht findet. Ich versteh aber nicht, warum er die Variablen nicht findet. Hoffe mir kann hier jemand weiterhelfen oder mir wenigstens einen Tipp geben, steh im Moment ein bissl an


----------



## AmunRa (11. Nov 2009)

Weil es in der toString() methode die Variable d nicht gibt. Lass das d einfach weg und dann funktioniert alles


----------



## Michael... (11. Nov 2009)

F34RL355 hat gesagt.:


> Das Problem ist, dass der Compiler d.real + d.imag nicht findet.


Was willst Du hier auch mit d? Der Code muss hier this.real bzw. real lauten.


----------



## Der Müde Joe (11. Nov 2009)

Du arbeitets nicht auf dem Object d sondern auf diesem (this) Objekt. also this.real oder gar nix geht auch (also einfach real)


----------



## F34RL355 (11. Nov 2009)

Erstmal danke für eure Antworten, klingt logisch ^^

Wie aber gebe ich dann dass Ergebnis(die Komplexe Zahl d) aus ?


----------



## Michael... (11. Nov 2009)

Die bekommst Du ja als Ergebnis des Methodenaufrufs add() zurück

```
Complex a = new Complex(1, 1);
Complex b = new Complex(1, 1);
Complex x = a.add(b);
System.out.println(x);
```


----------



## Der Müde Joe (11. Nov 2009)

>Wie aber gebe ich dann dass Ergebnis(die Komplexe Zahl d) aus ? 

Wenn du genau hinschaust, wird du feststellen, dass es gar kein d gibt.


```
class Complex{  
  
  final int real;
  final int imag;
  
  Complex(int r, int i){
    real = r;
    imag = i;
  }  
  
  public Complex add(Complex c){     
    return new Complex(this.real+c.real , this.imag+c.imag);
  }
  
  public String toString(){
  return this.real + "" + this.imag;
  }
}
// z.B
Complex d = new Complex(1,2);
Complex added = d.add(new Complex(2,3));
System.out.println(added);
```


----------



## F34RL355 (11. Nov 2009)

Vielen Dank - Kenn mich aus - Funktioniert - Super =)


----------



## Landei (11. Nov 2009)

Übrigens: real und imag final zu machen ist eine gute Idee. Ob man sie noch private macht und Getter-Methoden einfügt, ist eher eine Geschmacks- (oder Glaubens-?)sache.


----------



## Leroy42 (11. Nov 2009)

Landei hat gesagt.:


> Übrigens: real und imag final zu machen ist eine gute Idee. Ob man sie noch private macht und Getter-Methoden einfügt, ist eher eine Geschmacks- (oder Glaubens-?)sache.



Vor allem bei private-Variablen setter-Methoden einzufügen ist weder eine
Geschmacks- noch eiine Glaubensache.


----------



## F34RL355 (11. Nov 2009)

Eine Frage hätt ich jetzt doch noch, wie ist es wenn ich mehrer Zahlen miteinander addieren will. Ich hab schon eine Lösung gefunden aber die geht irgendwie am Sinn der Sache vorbei, weil ich die Methode add nicht verwend.

Also konkretes Beispiel:

Eingabe: 1 2 + 2 3 + 3 4 + 4 5 + 5 6 
Ausgabe: 15 20


----------



## Der Müde Joe (11. Nov 2009)

```
Complex a = new Complex(1,2);
Complex result = a.add(new Complex(1,1)).add(new Complex(2,2)).add(/*....*/);
```


----------



## F34RL355 (11. Nov 2009)

Der Müde Joe hat gesagt.:


> ```
> Complex a = new Complex(1,2);
> Complex result = a.add(new Complex(1,1)).add(new Complex(2,2)).add(/*....*/);
> ```



da muss ich aber wissen wieviele komplexe Zahlen eingelesen werden, oder ?

Außerdem will ichs dann noch erweitern mit Subtraktion, Multiplikation & Division


----------



## Der Müde Joe (11. Nov 2009)

```
Complex c = new Complex(1,1);
for(/*... bli bla blub */) {
 c = c.add(new Complex(1,1));
}
```


----------



## F34RL355 (11. Nov 2009)

Der Müde Joe hat gesagt.:


> ```
> Complex c = new Complex(1,1);
> for(/*... bli bla blub */) {
> c = c.add(new Complex(1,1));
> ...



Aber ich kann doch c nur 1mal setzen ...


----------



## Der Müde Joe (11. Nov 2009)

>Aber ich kann doch c nur 1mal setzen 

Nö.Ausser c wäre final. Einfach c auf die neue Referenz setzten (Welche in add durch new zurückgegeben wird). Macht die String Klasse nicht anderes bei allen Methoden (Verändert nicht den String sondern gibt einen neuen zurück)


----------



## F34RL355 (11. Nov 2009)

c ist doch aber final ...


```
class Complex{  
  
  final int real;
  final int imag;
```


----------



## Der Müde Joe (11. Nov 2009)

>c ist doch aber final ...

Nö. Lediglich die Attribute darin. Das hindert dich aber nicht daran, ein neues Complex Objekt zu erstellen mit neuen Werten. Lediglich die Werte des erstellten Objektes sind nicht veränderbar.


----------



## F34RL355 (11. Nov 2009)

Also müsst das so funktioniern ?

```
Complex c = new Complex(1,1);
while(reader.hasNextInt()){
int r = reader.NextInt();
int i = reader.NextInt();
c = c.add(new Complex(r,i));
}
```


----------



## Der Müde Joe (11. Nov 2009)

>Also müsst das so funktioniern ?

Ja. Das tut es. Kannst es ja testen mit einem System.out.println nach jeden durchlauf.

EDIT:
Aber das nicht:
while(reader.hasNextInt()){
int r = reader.NextInt();
int i = reader.NextInt();

--> du prüfst auf nextInt --> ja hat einen --> liest dann aber zwei

Was auch immer der Reader sein mag? Scanner?


----------



## F34RL355 (11. Nov 2009)

Also irgendas funzt ned.
Eingabe: 1 2 + 1 2 
Ausgabe: 1 2 

```
import java.util.Scanner;

class Calculator{
   
   public static void main (String [] args){
      Scanner reader = new Scanner(System.in);
      
      Complex x = new Complex(0,0);
      double	i = 0;
      double r = 0;
      String operator = "0"; // "+", "-" oder "*"      
      boolean ok = false; // Zum Überprüfen ob die Eingaben korrekt sind
      
      if(reader.hasNextDouble()){
         r = reader.nextDouble();
         if(reader.hasNextDouble()){
            i = reader.nextDouble();
            ok = true;
         }
         else{ 
            ok = false;
            System.out.println(x);
         }
      }
      else{ 
         ok = false;
         System.out.println(x);
      }
      Complex y = new Complex(r,i);
      while(reader.hasNextDouble()){
         double a = reader.nextDouble();
         double b = reader.nextDouble();
         y = y.add(new Complex(a,b));
      }                  
      
      if(ok) // Wenn Eingabe korrekt
         System.out.println(y);
      else
         System.out.println("FALSCHE EINGABE");
      
   }
}
```


----------



## Der Müde Joe (11. Nov 2009)

```
import java.util.Scanner;


public class Complex {
	
	final int real;
	final int img;
	
	public Complex(int real, int img) {
		this.real = real;
		this.img = img;
	}
	
	public Complex add(Complex c) {
		return new Complex(this.real + c.real, this.img + c.img);
	}

	public String toString() {return real +" " + img;}
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		Complex c = new Complex(1, 1);
		
		while(true) {
			System.out.println("real:");
			int real = scanner.nextInt();
			System.out.println("img:");
			int img = scanner.nextInt();
			c = c.add(new Complex(real, img));
			System.out.println("result = " + c);
		}
		
	}

}
```


----------



## F34RL355 (11. Nov 2009)

ja klar, mit dem "+" kann ja das in der Form nicht funktionieren ^^ *Vielen Dank !*


```
y = y.add(new Complex(a,b));
```

Nur dass ich das jetzt auch richtig verstanden hab. Diese Zeile bewirkt nicht, dass die Werte von y geändert werden, sondern dass ein neues Objekt geschaffen wird, und y auf dieses zeigt. (Die Fachausdrücke kann ich noch nicht so ganz, wie man vll. merkt )


----------



## Der Müde Joe (12. Nov 2009)

>Diese Zeile bewirkt nicht, dass die Werte von y geändert werden, sondern dass ein neues Objekt geschaffen wird, und y auf dieses zeigt.

Ja. Aber das Objekt ist nicht etwa das, was in der Schleife drin ist. sondern dasjenige, welches in der add Methode erstellt wird! In der add Methode wird ein neues Objekt Complex erstellt (new) und dieses wird zurückgegeben (eigentlich ja nur die Referenz darauf). Nun wird das neue Objekt auf die Variable y gelegt (durch "y = hier kommt new Comlex zurück" ). Das neue Complex Objekt zeigt nun auf y (y hat die Referenz auf das neue Objekt).
Um noch einen Schritt weiter zu gehen. Was passiert mit den anderen Objekten, die erstellt wurden? Niemand zeigt mehr auf diese Objekte (y hat das neue Objekt der add Methode und das vom y.add (hier) aufruf ist nach der Methode auch uninterressant). Der Garbage Collector schlägt früher oder später zu und bereinigt diese Objekte und gibt den Speicher wieder frei.


----------

