# Berechnung zwei Komplexen Zahlen



## Guest (13. Sep 2008)

Also es soll eine Java Programm sein das folgende Schritte hat.

1.Konstruktor für komplexe Zahlen.
2.Es soll eine Methode zur Berechnung des Betrages einer komplexen Zahl-
3. Eine Methode der zugehörigen konjugiert komplexen Zahl.
4.Methode zur Berechnung der Differenz zwei komplexer zahlen.
5.Methode main, die folgende Aufgaben realisiert.
                Es sollen 2 komplexe Zahlen von der Tastatur eingelesen werden.
                Es soll berechnet und ausgegeben werden dii Differenz von Z=z1-z2.
                Es soll der Betrag z berechnet udn ausgegeben werden.
                Es soll die konjugiert komplexe Zahl berechnet und ausgegeben werden.

Also das hier ist mein Programm ich weiß nicht was da nich tgenau stimmt

könntet ihr mit paar Hinweise geben???????????

Wäre danbar




```
import java.io.*;
import java.math.*;
public class KomplexeZahl
{
	double z1;/*Komplexe Zahl 1*/
	double z2;/*Komplexe Zahl 2*/
	double Re1;/*Erster Realteil*/
	double Re2;/*2 Real Teil*/
	double Im1;/*1 Imaginärteil*/
	double Im2;/*2 Imaginär Teil*/
	double Betrag;/*Betrag einer Komplexen Zahl*/
	double KonjugiertK;/*Konjugiert komplex einer komplexen Zahl*/
	double Differenz;/*Differenz einer Komplexen Zahl*/
	double Betrag;/*Betrag einer komplexen Zahl*/
	double i=-1;
	/*ersterKonstruktor*/
	KomplexeZahl(double x1, double y1)
	{
		Re1=x1;
		Im1=y1;
	}
	/*Ende des 1Konstruktor*/
	System.out.println("Geben sie die Werte für z1 ein");
	System.out.println("Gebe sie den Realteil Re1 bitte ein:");
	x1=IO1.eindouble();/*1 Realteil wird von der Tastatur eingelesen*/	
	System.out.println("Geben si edne Imaginärteil 1 ein");/*Geben sie bitte nun den 1 Imaginärteil ein*/
	y1=IO1.eindouble();/*Einlesen einer Imaginären Zahl*/
	z1=x1+y1*i;
	System.out.println("Ihre erste kompl. Gleichung lautet:"+z1);
	/*2 Konstruktor*/	
	KomplexeZahl(double x2; double y2)
	{
		Re2=x2;
		Im2=y2;
	}
	/*Ende des 2 Konstruktors*/
	System.out.println("Geben sie die wErte für z2 ein");
	System.out.println("Gebe sie den Realteil Re2 bitte ein:");
	x2=IO1.eindouble();/*1 Realteil wird von der Tastatur eingelesen*/	
	System.out.println();/*Geben sie bitte nun den 2 Imaginärteil ein*/
	y2=IO1.eindouble();/*Einlesen einer Imaginären Zahl*/
	System.out.println("Ihre erste kompl. Gleichung lautet:"+z2);	
	System.out.rintln("Jetzt werden die Komplexen Zahlen addiert");
	/*Methode zum Addieren komplexer Zahlen*/
	
	
	
}
```

Das Programm ist nciht vollständig.

ich möchte auch keine komplete Lösung ich will nur hinweise haben


----------



## Ark (13. Sep 2008)

```
z1=x1+y1*i;
```
Als ich zufällig diese Zeile Code las, fehlten mir die Worte. :shock: :shock: :shock:

Aber glücklicherweise scheint es sich nur um eine Hausaufgabe zu handeln. 

Ark

PS: i ist hier völlig falsch definiert.


----------



## Gast (13. Sep 2008)

aber der Konstruktor ist richtig oder?

War es sinnvoll hier mit double zu initialisieren???????


----------



## Ark (13. Sep 2008)

Ich nehme mal stark an, dass sich der Compiler über ungefähr jede Zeile beschwert hat. System.out.println() usw. sind Anweisungen, und Anweisungen kommen nur in Methodenrümpfen, zum Initialisieren von Instanzvariablen oder in static-Blöcken vor, aber niemals direkt in Klassen (wie es hier gemacht wurde).

In jeder anständigen Formelsammlung steht zwar nicht, wie groß i ist, wohl aber, wie groß i² ist, nämlich -1. Viel Spaß beim Versuch, so etwas wie die imaginäre Einheit in eine Rechenmaschine zu prügeln. 

Ark


----------



## Gast (13. Sep 2008)

achso danke


----------



## Guest (13. Sep 2008)

Also das Problem mit der imaginären Zahl hab eich soweit gelöst, aber ich verstehe dne Rest nicht

Das ist mien PRogramm


```
public class KomplexeZahl
{
	double z1;/*Komplexe Zahl 1*/
	double z2;/*Komplexe Zahl 2*/
	double Re1;/*Erster Realteil*/
	double Re2;/*2 Real Teil*/
	double Im1;/*1 Imaginärteil*/
	double Im2;/*2 Imaginär Teil*/
	double Betrag;/*Betrag einer Komplexen Zahl*/
	double KonjugiertK;/*Konjugiert komplex einer komplexen Zahl*/
	double Differenz;/*Differenz einer Komplexen Zahl*/
	double Betrag;/*Betrag einer komplexen Zahl*/
	double i;
	/*ersterKonstruktor*/
	KomplexeZahl(double x1, double y1)
	{
		Re1=x1;
		Im1=y1;
	}
	/*Ende des 1Konstruktor*/
	System.out.println("Geben sie die Werte für z1 ein");
	System.out.println("Gebe sie den Realteil Re1 bitte ein:");
	x1=IO1.eindouble();/*1 Realteil wird von der Tastatur eingelesen*/	
	System.out.println("Geben si edne Imaginärteil 1 ein");/*Geben sie bitte nun den 1 Imaginärteil ein*/
	y1=IO1.eindouble();/*Einlesen einer Imaginären Zahl*/
	z1=x1+y1*i;
	System.out.println("Ihre erste kompl. Gleichung lautet:"+z1);
	/*2 Konstruktor*/	
	KomplexeZahl(double x2; double y2)
	{
		Re2=x2;
		Im2=y2;
	}
	/*Ende des 2 Konstruktors*/
	System.out.println("Geben sie die wErte für z2 ein");
	System.out.println("Gebe sie den Realteil Re2 bitte ein:");
	x2=IO1.cxaus();/*1 Realteil wird von der Tastatur eingelesen*/	
	System.out.println();/*Geben sie bitte nun den 2 Imaginärteil ein*/
	y2=IO1.eindouble();/*Einlesen einer Imaginären Zahl*/
	System.out.println("Ihre erste kompl. Gleichung lautet:"+z2);	
	System.out.rintln("Jetzt werden die Komplexen Zahlen addiert");
	if(i*i)
	{
		i=-1;
	}	
	/*Methode zum Addieren komplexer Zahlen*/
	
	
	
}
```

Das sind die Fehler beim complieren

KomplexeZahl.java:21: <identifier> expected
System.out.println("Geben sie die Werte für z1 ein");
                          ^

C:\Users\Reza\Documents\KomplexeZahl.java:22: <identifier> expected
	System.out.println("Gebe sie den Realteil Re1 bitte ein:");
                          ^

C:\Users\Reza\Documents\KomplexeZahl.java:23: <identifier> expected
	x1=IO1.eindouble();/*1 Realteil wird von der Tastatur eingelesen*/	
          ^


C:\Users\Reza\Documents\KomplexeZahl.java:24: <identifier> expected
	System.out.println("Geben si edne Imaginärteil 1 ein");/*Geben sie bitte nun den 1 Imaginärteil ein*/
                          ^

C:\Users\Reza\Documents\KomplexeZahl.java:25: <identifier> expected
	y1=IO1.eindouble();/*Einlesen einer Imaginären Zahl*/
          ^


C:\Users\Reza\Documents\KomplexeZahl.java:26: <identifier> expected
	z1=x1+y1*i;
          ^


C:\Users\Reza\Documents\KomplexeZahl.java:27: <identifier> expected
	System.out.println("Ihre erste kompl. Gleichung lautet:"+z1);
                          ^


C:\Users\Reza\Documents\KomplexeZahl.java:29: ')' expected
	KomplexeZahl(double x2; double y2)
                              ^

C:\Users\Reza\Documents\KomplexeZahl.java:29: ';' expected
	KomplexeZahl(double x2; double y2)
                                         ^


C:\Users\Reza\Documents\KomplexeZahl.java:36: <identifier> expected
	System.out.println("Gebe sie den Realteil Re2 bitte ein:");
                          ^


C:\Users\Reza\Documents\KomplexeZahl.java:37: <identifier> expected
	x2=IO1.eindouble();/*1 Realteil wird von der Tastatur eingelesen*/	
          ^


C:\Users\Reza\Documents\KomplexeZahl.java:37: <identifier> expected
	x2=IO1.cxaus();/*1 Realteil wird von der Tastatur eingelesen*/	
          ^


----------



## Guest (13. Sep 2008)

[üü


----------



## Gast (13. Sep 2008)

Werde morgen weiter machen heute wird es ncihts mehr mit Programme schreiben.

DANKE


----------



## diggaa1984 (13. Sep 2008)

hm das problem ist primär nicht der mathematische sachverhalt sondern "was weisst du über java alles" ... wie  mein Vorredner schon schrieb, Anweisungen stehen nicht einfach so in der Klasse und die Nutzung deiner Konstruktoren lässt auf gravierende Mängel in deinem Java-Wissen schliessen. Habt ihr da vorher nix behandelt, wo man nachschauen kann?

mal als Grundgerüst:

```
public class KomplexeZahl {
 
    //Werte welche die Komplexe Zahl beschreiben (Klassenvariable)
    double re;
    double im;

    /*Konstruktor der Klasse (da reicht einer für Millionen von versch. Zahlen ^^)
     *und wo er steht sagt nix darüber aus wann ein Objekt (quasi Zahl) erstellt wird
     */
    public KomplexeZahl(double re, double im) {
        this.re = re;
        this.im = im;
    }//Ende

    //Methode zur Berechnug des Betrages der komplexen Zahl
    public double berechneBetrag() {
        double ergebnis;
        
        //Betrag der komplexen Zahl errechnen und in ergebnis speichern

        return ergebnis;
    }//Ende

    //Methode, welche komplexe Zahl konjugiert
    public void konjugiere() {
        //re und im entsprechen anpassen
    }//Ende

    //Methode zur Berechnug der Differenz 2er komplexer Zahlen
    public KomplexeZahl berechneDifferenz(KomplexeZahl z) {
        KomplexeZahl ergebnis;
        
        //Differenz berechnen und in ergebnis speichern

        return ergebnis;
    }//Ende


    /*Diese Methode wird als ALLERERSTES ausgeführt beim Programmstart
     *diese Methode muss genau diese Signatur haben, nix daran aendern
     */
    public static void main(String[] args) {
        KomplexeZahl z1;
        KomplexeZahl z2;

        /*hier Eingaben abfragen, wenn komplett diese dann zur definition von z1 und z2 nutzen
           Beispiel: Eingaben waren 5 für real und 2 für imaginär:  z1 = new KomplexeZahl(5,2);
           damit ist deine komplexe Zahl z1 existent und nutzbar und mit Leben gefüllt
           Aufrufe der obigen Methoden zB. wie folgt:  double betrag = z1.berechneBetrag();
           alles andere is nun dir überlassen */

    }//main
}
```

Ähm da ich kein schimmer von komplexen Zahlen hab und nur fix mal gegoogelt habe was in etwa verlangt wird, gebe ich keine Garantie auf die Rückgabewerte der obigen Methoden, wenn statt double zB doch ne komplexe Zahl ensteht, dass musst du allein wissen. Aber mit der Klasse wie sie steht, hast ein solides Grundgerüst um die eigentliche Funktionalität einzubauen.

Dennoch denke ich das dir zuviel Wissen fehlt, da die Fehler doch schon massiv waren. Für weitere Fragen wieso da nun was steht, wenns geht ein Javabuch suchen.

Achja und wenn kleine Fehler in der obigen Klasse vorhanden sind, die jetzt nur in dem Gerüst liegen, dann sry, hab das grad nur so ohne Prüfung hingeschrieben.


----------



## Ark (13. Sep 2008)

@diggaa1984: Die konjugiert komplexe Zahl zu einer gegebenen komplexen Zahl erhält man, indem man einfach das Vorzeichen des Imaginärteils umdreht, also

```
public KomplexeZahl konjugiere(KomplexeZahl z) {
    return new KomplexeZahl(z.re, -z.im);
}
```
Und das mit der imaginären Einheit i ... sie sollte wirklich nur imaginär bleiben.  Mit double werden rationale Annäherungen an _reelle_ Zahlen dargestellt; mit i kann ein Rechner also nichts anfangen.

```
double i*i = -1;
```
i² = -1 ... das wäre zwar korrekt, aber der Compiler wird sich weigern, das durchgehen zu lassen. 

Ark


----------



## diggaa1984 (13. Sep 2008)

ja n bissel wollen wir dem Thread-Ersteller auch noch lassen oder  .. das mit dem vorzeichen hat ich auch ergoogled, aber wollt ja nich alle arbeit abnehmen


```
double i*i = -1
```
welcher compiler lässt denn sowas durchgehen


----------



## 0x7F800000 (13. Sep 2008)

Das kann doch nicht wahr sein, schon seit zwei wochen postest du ohne unterbrechungen diese sinnfreien Codefetzen einer nicht existierenden Programmiersprache :autsch:  :bloed: , *wie wär's, wenn du dir endlich mal ein Buch besorgst, und dir irgendetwas über Java-Grundlagen durchliest?*


----------



## diggaa1984 (13. Sep 2008)

also ich kann *Gast* und *Gast* nich auseinanderhalten   

joke ... weiss nich wie lange hier schon derartiges rumschwirrt, war für mich der erste beitrag den ich so sah ^^


----------



## 0x7F800000 (14. Sep 2008)

diggaa1984 hat gesagt.:
			
		

> also ich kann *Gast* und *Gast* nich auseinanderhalten


diesen Gast erkennst du äußerst leicht an folgenden Merkmalen:
1) verwendung von elendst langen Variablenlisten, wo kaum irgendwelche sinnvollen Variablen vorkommen
2) konsequenter verzicht auf implementierung von irgendwelchen methoden die nicht "main" heissen [diese Konstruktoren sind ein neues Phänomen]
3) verwendung von so grossartigen klassenamen wie "IO1", methodennamen wie "einint" und "eindouble", allgemein großzügige Verwendung von Buchstabenkombinationen, die an Wörter der deutschen Sprache erinnern, verwendung von ä ü ö im Quellcode und für die Ausgabe auf der Konsole (was dann entsprechend gruselig aussieht)
4) blockkomentare für eine zeile
5) tsatautr kelmmt, bchusatbendehrerrrrrrrrrr in jedre zewiteeeeeeeeeeeeeeeee zelie !!!!!!!!!!!!!!!!!!!!!!!!!!!
(zumindest der letzte Punkt ist in der letzten zeit aber etwas besser geworden)


----------



## Gast (14. Sep 2008)

@All

Danke

nur für was steht den this??????????


----------



## Gast (14. Sep 2008)

this ist eine referenzvariable, die auf das aktuelle objekt zeigt 

und was ist nun eine referenzvariable ?


----------



## Gast (14. Sep 2008)

oh meine sarkastische frage hoert sich so an als waer ich der "Gast threadstarter" ..


----------



## Gast (15. Sep 2008)

danke


----------



## diggaa1984 (15. Sep 2008)

is hier einer schizo?


----------



## Guest (15. Sep 2008)

Nein, wie komst du denn darauf?????????


----------



## Guest (15. Sep 2008)

ich bin's jedenfalls.
Mit wen hab ich eben geredet?


----------



## Landei (15. Sep 2008)

Was für ein Gewese, meldet euch doch einfach an!


----------



## Gast (15. Sep 2008)

Mein Arzt sagt, ich darf mich nirgendwo anmelden!


----------



## Leroy42 (15. Sep 2008)

Da lob' ich mir doch mal _deinen Arzt_!

Und das ganz ohne ihn überhaupt zu kennen!


----------



## Guest (16. Sep 2008)

diggaa1984 hat gesagt.:
			
		

> hm das problem ist primär nicht der mathematische sachverhalt sondern "was weisst du über java alles" ... wie  mein Vorredner schon schrieb, Anweisungen stehen nicht einfach so in der Klasse und die Nutzung deiner Konstruktoren lässt auf gravierende Mängel in deinem Java-Wissen schliessen. Habt ihr da vorher nix behandelt, wo man nachschauen kann?
> 
> mal als Grundgerüst:
> 
> ...



danke,aber bekomme beim Compilieren diese Fehler

KomplexeZahl.java:21: variable ergebnis might not have been initialized
        return ergebnis;
               ^


KomplexeZahl.java:35: variable ergebnis might not have been initialized
        return ergebnis;
               ^


----------



## Gast (16. Sep 2008)

musst die lokalen variablen mit 0 respektive null initialisieren


----------



## diggaa1984 (16. Sep 2008)

ja gut, kannst sie mit 0 initialisieren, bei der komplexen Zahl in der Differenz kannst eben erst ergebnis erzeugen, wenn du die Werte für re und im errechnet hast .. schiebst den kommentar also einfach über die deklaration von ergebnis und berechnest dort erst nötige Werte, welche du dem Konstruktor zum erstellen von ergebnis übergibst.


----------



## Gast (16. Sep 2008)

Ich verstehe nicht was ich genau ändern soll ????


----------



## diggaa1984 (16. Sep 2008)

```
//Methode zur Berechnug des Betrages der komplexen Zahl 
    public double berechneBetrag() { 
        double ergebnis = 0; 
        
        //Betrag der komplexen Zahl errechnen und in ergebnis speichern 

        return ergebnis; 
    }//Ende 

    //Methode zur Berechnug der Differenz 2er komplexer Zahlen 
    public KomplexeZahl berechneDifferenz(KomplexeZahl z) { 
        KomplexeZahl ergebnis = null; 

        //lokale Variablen zum berechnen erstellen
        //Differenz berechnen
        //ergebnis = new KomplexeZahl(lokaleVariable1,lokaleVariable2);

        return ergebnis; 
    }//Ende
```
so in etwa


----------



## Gast (17. Sep 2008)

danke


----------



## Landei (17. Sep 2008)

Aufgabe ist gelöst?

Na dann kann ich ja zu Vergleichszwecken meinen Mini-Rechner posten (ich hoffe, die Operationen sind richtig implementiert):


```
package rummage.math.complex;

public class Complex {
  
  public static final Complex ZERO = new Complex(0);
  public static final Complex ONEO = new Complex(1);
  public static final Complex I = new Complex(0,1);
  
  private final double real;
  private final double imag;
  
  public Complex(double real, double imag) {
    this.real = real;
    this.imag = imag;
  }
  
  public Complex(double real) {
    this(real, 0);
  }
  
  public Complex add(Complex that) {
    return new Complex(this.real + that.real, this.imag + that.imag);
  }
  
  public Complex subtract(Complex that) {
    return new Complex(this.real - that.real, this.imag - that.imag);
  }

  public Complex mult(Complex that) {
    return new Complex(this.real * that.real - this.imag * that.imag, 
                       this.real * that.imag + this.imag * that.real);
  }
  
  public Complex div(Complex that) {
    double q = that.real * that.real + that.imag + that.imag;
    return new Complex((this.real * that.real + this.imag * that.imag) / q,
                       (this.imag * that.real - this.real * that.imag) / q);
  }
  
  public double getReal() {
    return real;
  }
  
  public double getImag() {
    return imag;
  }

}

package rummage.math.complex;

import javax.swing.JFrame;
import javax.swing.JPanel;
import java.awt.GridLayout;
import javax.swing.JTextField;
import static java.awt.BorderLayout.*;
import javax.swing.JButton;
import static rummage.math.complex.Calculator.Operation.*;
import javax.swing.AbstractAction;
import java.awt.event.ActionEvent;
import javax.swing.JOptionPane;

public class Calculator {
  
  enum Operation{ ADD, SUBTRACT, MULT, DIV };
  
  private JFrame frame = new JFrame("Complex Calculator");
  private JTextField realField = new JTextField("0");
  private JTextField imagField = new JTextField("0");
  private Complex result = Complex.ZERO;
  private Operation operation = ADD;
  
  public Calculator() {
    JPanel north = new JPanel(new GridLayout(1,2));
    north.add(realField);
    north.add(imagField);
    frame.getContentPane().add(north, NORTH);
    JPanel center = new JPanel(new GridLayout(2,3));
    center.add(new JButton(new OperationAction("+", ADD)));
    center.add(new JButton(new OperationAction("-", SUBTRACT)));
    center.add(new JButton(new ClearAction()));
    center.add(new JButton(new OperationAction("*", MULT)));
    center.add(new JButton(new OperationAction(":", DIV)));
    center.add(new JButton(new EvalAction()));
    frame.getContentPane().add(center);
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.setSize(300,100);
    frame.setVisible(true);
  }
  
  private class OperationAction extends AbstractAction {
    
      private final  Operation op;
      
      OperationAction(String name, Operation op) {
        super(name);
        this.op = op;
      }
    
     public void actionPerformed(ActionEvent e) {
        Complex other = read();
        if (other == null) {
          return;
        }
        switch(operation) {
         case ADD : result = result.add(other); break;         
         case SUBTRACT : result = result.subtract(other); break;           
         case MULT : result = result.mult(other); break;           
         case DIV : result = result.div(other); break;           
        }
        operation = op;
        display();
      }
  }
  
  private class ClearAction extends AbstractAction {
    
     ClearAction() {
       super("CE");
     }
    
     public void actionPerformed(ActionEvent e) {
       operation = ADD;
       result = Complex.ZERO;
       display();
     }
  }
  
  private class EvalAction extends AbstractAction {
    
    EvalAction() {
      super("=");
    }
    
    public void actionPerformed(ActionEvent e) {
      Complex other = read();
      if (other == null) {
        return;
      }
      switch(operation) {
       case ADD : result = result.add(other); break;         
       case SUBTRACT : result = result.subtract(other); break;           
       case MULT : result = result.mult(other); break;           
       case DIV : result = result.div(other); break;           
      }
      display();
    }
  }
  
  public Complex read() {
    try {
      double real = realField.getText().trim().equals("") ? 0 : Double.parseDouble(realField.getText());
      double imag = imagField.getText().trim().equals("") ? 0 : Double.parseDouble(imagField.getText());
      return new Complex(real, imag);
    } catch (NumberFormatException ex) {
      JOptionPane.showMessageDialog(frame, "Please enter valid numbers!", "Error", JOptionPane.ERROR_MESSAGE);
      return null;
    }
  }
  
  private void display() {
    realField.setText("" + result.getReal());
    imagField.setText("" + result.getImag());
  }
  
  public static void main(String... args) {
    new Calculator();
  }
}
```


----------



## Guest (17. Sep 2008)

diggaa1984 hat gesagt.:
			
		

> ```
> //Methode zur Berechnug des Betrages der komplexen Zahl
> public double berechneBetrag() {
> double ergebnis = 0;
> ...



bekomme aber diese Fehler

KomplexeZahl.java:35: variable ergebnis might not have been initialized


----------



## Gast (17. Sep 2008)

@landei danke,aber ich verstehe nicht was die hälft ein deinem Programm zu bedeuten hat???


----------



## diggaa1984 (17. Sep 2008)

zeich ma dein code wie du ihn momentan hast bitte


----------



## Landei (18. Sep 2008)

@gast: Das sind *zwei* Klassen, du brauchst eine Datei Complex.java und eine Datei Calculator.java. Oh, und nicht vergessen, die package Deklarationen entsprechend anzupassen (oder löschen). Starten musst du die Calculator-Klasse.


----------

