Hallo Leute,

ich hab folgende Aufgabe bekommen:

Fenster A ruft Fenster B auf.

Stellen Sie die beiden folgenden Fälle der Kommunikation zwischen diesen beiden Fenstern vor:

Fall A): Der Anwender gibt Daten in ein Textfeld des Fensters A ein. Beim Klick auf

einen Button des Fensters A sollen diese Daten irgendwo im Fenster B erscheinen.

Fall : Der Anwender gibt Daten in ein Textfeld des Fensters B ein. Beim Klick auf

einen Button des Fensters B sollen diese Daten irgendwo im Fensters A

erscheinen.

Könnte mir vlt. jemand helfen...also vlt n Stichwort geben. Ich häng grad total und weiß nich wo ich da anfangen bzw. suchen soll.

vielen Dank im voraus

Innerhalb einer Anwendung sollte das gar kein Problem sein. Mit einer Sprache die Objektorientierung versteht könnte das wie folgt zu lösen sein:

FensterB.Textfeld.Text=FensterA.Textfeld.Text

Sobald eine Textänderung in FensterA erfolgt wird diese an FensterB weitergegeben.

Diese Zuweisung kann man natürlich einem ButtomClick Ereignis zuordnen...

Gruss Pluto

ok danke, so einfach hatte ich das auch überlegt, aber da das ein referatsthema ist, dachte ich, dass es da evtl. ne spezielle sache gibt die ich nicht kenne^^

danke

PS: wenn noch jemand ne andere idee hat...dann immer her damit

In bezug auf Java ist das garnicht soo einfach, wenn man nicht mit statischen Variablen der Fenster umgehen möchte.

Denn wie können sich zwei Fenster gegenseitig referenzieren, ohne static Referenz des Partners?

Wenn static, dann eventuell mit Singleton-Pattern.

Wenn nicht, dann eventuell mit einem Container oder mit Callback-Funktionen (Ereignissen)...

Naja, eine bidirektionale Referenz ohne static Geschwurbel ist kein Voodoo:

A a = new A();

B b = new B();

a.setB(;

b.setA(a);

[/code]

Hallo,

hast du es nun hinbekommen? Ich hing vor ner Weile an einem ähnlichen Problem, konnte es aber auch nur über static Referenzen lösen.

Hier mein Vorschlag

(ich habs eben frei Hand neu gemacht - möglich, dass es kürzer und eleganter geht, aber es tut, was du möchtest)

import javax.swing.JFrame;


public class Window

extends JFrame

{

	public Window()

	{

		setSize(300,350);

		setLocation(250,250);

		setLayout(null);

		repaint();

	}

}

import java.awt.Insets;

import javax.swing.JButton;

import javax.swing.JTextField;


public class FirstWindow 

extends Window

{

	public static JTextField textField;


	public FirstWindow()

	{

		super();

		setTitle("FirstWindow");

		addComponents();

	}


	private void addComponents()

	{

		JButton copyButton = new JButton("In das andere Fenster kopieren");

		copyButton.setBounds(50,100,200,30);

		copyButton.setMargin(new Insets(0,0,0,0));

		copyButton.addActionListener(WindowSwitch.getWindowSwitch());

		copyButton.setActionCommand("firstWindow.copy");

		add(copyButton);


		JButton closeButton = new JButton("Beenden");

		closeButton.setBounds(50,250,130,30);

		closeButton.addActionListener(WindowSwitch.getWindowSwitch());

		closeButton.setActionCommand("Close");

		add(closeButton);


		textField = new JTextField();

		textField.setBounds(50, 150, 200,30);

		add(textField);

	}

}

import java.awt.Insets;

import javax.swing.JButton;

import javax.swing.JTextField;


public class SecondWindow 

extends Window

{

	public static JTextField textField;


	public SecondWindow()

	{

		super();

		setTitle("SecondWindow");

		addComponents();

	}


	private void addComponents()

	{

		JButton copyButton = new JButton("In das andere Fenster kopieren");

		copyButton.setBounds(50,100,200,30);

		copyButton.setMargin(new Insets(0,0,0,0));

		copyButton.addActionListener(WindowSwitch.getWindowSwitch());

		copyButton.setActionCommand("secondWindow.copy");

		add(copyButton);


		JButton closeButton = new JButton("Beenden");

		closeButton.setBounds(50,250,130,30);

		closeButton.addActionListener(WindowSwitch.getWindowSwitch());

		closeButton.setActionCommand("Close");

		add(closeButton);


		textField = new JTextField();

		textField.setBounds(50, 150, 200,30);

		add(textField);

	}

}

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;


public class WindowSwitch 

implements ActionListener 

{

	private static WindowSwitch windowSwitch;

	public static WindowSwitch getWindowSwitch()

	{

		return windowSwitch;

	}


	public WindowSwitch()

	{

		windowSwitch = this;

	}


	public void createWindows()

	{

		FirstWindow firstWindow = new FirstWindow();

		firstWindow.setLocation(100,100);

		firstWindow.setVisible(true);


		SecondWindow secondWindow = new SecondWindow();

		secondWindow.setLocation(200,200);

		secondWindow.setVisible(true);

	}


	public void actionPerformed(ActionEvent evt) 

	{

		if(evt.getActionCommand().equals("firstWindow.copy"))

		{

			SecondWindow.textField.setText(FirstWindow.textField.getText());

			FirstWindow.textField.setText("");

		}

		if(evt.getActionCommand().equals("secondWindow.copy"))

		{

			FirstWindow.textField.setText(SecondWindow.textField.getText());

			SecondWindow.textField.setText("");

		}

		if(evt.getActionCommand().equals("Close"))

		{

			System.exit(0);

		}

	}

}

public class MainClass 

{

	public static void main (String []args)

	{

		new WindowSwitch();

		WindowSwitch.getWindowSwitch().createWindows();

	}

}

Was spricht denn dagegen, das ganz einfach so zu machen wie kingofbrain das gesagt hat? Ohne irgendwelche static Referenzen, sondern einfach mit den Mechanismen die OOP bietet.

Du hast in jeder Klasse ein Klassenattribut was eine Referenz auf genau die andere Klasse aufnehmen kann. Dann hast du in jeder Klasse ebenso eine Set-Methode die dieses Attribut befüllen kann.

Und wenn bei dir im Programm beide Klassen erstellt werden, weist du denen gleich gegenseitig die andere Klasse zu. Dann können sie intern auf die jeweils andere Klasse über deren öffentliche Methoden zugreifen.

Ansonsten könnte ich mir auch vorstellen, ne eigene Klasse zu schreiben, an der siche die Klassen registrieren und diese Klasse dann die Kommunikation zwischen den anderen Klassen steuert.