✔ Auf Ereignisse einer anderen Klasse zugreifen

[ByeBye 224935]

Hallo

dies ist mein erster Post.

Ich habe ein Problem:
Ich habe eine Klasse MainFrame und in ihr wird ein Objekt SaveFrame erstellt.
Nun will ich eine methode in MainFrame starten, wenn in SaveFrame auf einen Button gedrückt wird (dieser Button Schließt das Fenster).

Ich habe wahrscheinlich nur ein Brett vorm Kopf.

Danke schonmal.

Niklas

 

[MiMi]

Such mal nach dem Actionlistener. Der wird dir weiterhelfen, den kannst du mit dem Button verbinden und dort dann deine andere Methode mit aufrufen

Hier ein gutes Beispiel
http://java.sun.com/docs/books/tutorial/uiswing/events/actionlistener.html

Now, when the user clicks the Button b, the button fires an action event which invokes the action listener's actionPerformed method. Each time the user presses the button, numClicks variable is appended and the message is displayed in the text field.

So kannst du es genauso mit deinem Programm machen, wenn auf dem Knopf gedrueckt wird, rufst du halt die Methode in deiner MainFrame an

 

[dto]

überladen der Methode

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
//hier der Rückruf dies bedeutet natürlich das SaveFrame eine Referenz auf
//MainFrame besitzen muss
//und der Button muss über einen ActionListener verfügen
}

des weiteren kannst du dich mal mit der Schnittstelle Observer/Observable beschäftigen

 

[MiMi]

@killerkirsche
Wie dontschew sagte, das SaveFrame eine Referenz nach Mainfraim haben muss, und das ist ja kein Problem, du kannst ja das Mainframe einfach dem SaveFrame mitgeben wenn du es erstellst. Ich weiss net wo das dien Problem liegt. Ich habe nie gesagt das du die methode in die andere Klasse verschieben sollst.

 

[MiMi]

Genau wie wenn du net methode was mitgibst.

Klasse B... 
... 
KlasseA a = new KlasseA (this);

Dann hast du in der jetztigen Klasse nen neues Object der Klasse KlasseA gemacht und hast die jetztige Klasse mitgegeben.
Dies kanns tdu dann im Konstruktor der Klasse KlasseA verwenden mittels

private KlasseB b;
KlasseA (KlasseB b) {
    this.b = b;
}

 

[MiMi]

Poste einfach mal den entsprechenden code und sag wo dein Problem dabei ist

 

[MiMi]

WEnn du anfaenger bist, wieso hast du dann einen riesen code? Nungut

also du musst in diesem Teil

  public MainFrame(){
    SF = new SaveFrame();
    der Konstruktor, der von meiner main Methode aufgerufen wird
  }

In das new SaveFrame das aktuelle object also dei MainFrame mittel "this" mitgeben
Also genau anders rum, als du es gemacht hast, du machst ja nun in der SaveFrame ein MainFrame Object, abe rdu willst ja in der MainFrame ein Saveframe object machen

Und variablen Namen schreibt man klein ^^

 

[pipip]

killerkirsche:
ich glaube du hast im prinzip das gleiche problem wie ich es vor kurzem hatte:
--> http://www.tutorials.de/forum/swing...omposite-auf-anderes-composite-zugreifen.html

 

[RPR]

Darf ich als Ausbildner, der jungen (Berufs-)Leuten OO-Programmierung beibringt den Tipp gebe, das Buch "Java als erste Programmiersprache" (ISBN 978-8351-0147-0) zu besorgen. Da sind solche Sachen glasklar erklärt.
Das Verständnis der Referenzen ist wohl etwas vom wichtigsten bei OO. Wenn das nicht sitz - so meine Erfahrung mit den Lernenden - geht's nie gut aus.

Auf Wunsch kann ich zu diesem Problem eine kleine Übung abgeben.

 

[RPR]

Das mit der static Deklaration ist aber nicht wirklich die Lösung!
Damit ist die ganez OO-Welt ausser Kraft gesetzt. Die lebt nämlich von Referenzen.

Ich versuchs mal in Kürze:
Wenn du jemanden neu kennlernst, gibt er dir vielleicht seine Visitenkarte. Das ist die Referenz, anhand der du mit dem Objekt dann Kontakt aufnehmen kannst (z.B. steht da die Telefonnummer).
Genau gleich verhält es sich bei OO.
Du erzeugst ein Objekt und erhälst so seine Referenz. Dies kannst du dann andern Objekten weitergeben, gerade so wie die Visitenkarte.
Der Aufruf einer Methdeo erfolgt ja immer über
referenz.Methode().

Hier ein kleiens Beispiel, das hilft dir vielleicht weiter:

public class BSP
{
	// Hier werden 2 Klassen instanziert. Es werden...
	// ...die Objekte aObj und bObj erzeugt.
	// bObj erhält dabei als Parameter die Referenz auf aObj.
	// Danach wird eine Methode bei bObj aufgerufen.
	// Merke: OO ist sehr "anständig". Es wird immer zuerst...
	// ...die Referenz genannt, mit der kommuniziert wird, und...
	// ...dann durch . getrennt die Methode.
	public static void main(String[] args){
		ClassA aObj = new ClassA();
		ClassB bObj = new ClassB(aObj);
		bObj.exec();
	}
};

// Nun folgen die beiden Klassen ClassA und ClassB. Dieses dürfen...
// ..nicht public deklariert werden, da schon BSP public ist.
class ClassA
{
	// Attribute sollten generell private (oder protected) sein, da...
	// ...dies der Regel des Data-Hiding bei OO entspricht.
	private int val;

	// Konstruktor
	ClassA(){
		// hier folgen alle Initialisierungen
		val = 5; // als Beispiel
	}

	void aMethode(){
		System.out.println("Wert von val = "+val);
	}
};

class ClassB
{
	// Hier muss eine Referenz auf ClassA bekannt sein. Nur so...
	// ...kann ein Objekt der Klasse ClassB auf ein Objekt der...
	// ...Klasse ClassA zugreifen.
	private ClassA aRef;

	// Konstruktor mit Parameterübergabe
	ClassB(ClassA ref){
		aRef = ref;
	}

	// Nun folgt eine Methode die aus main aufgerufen wird.
	// Sie leitet den Aufruf (Proxy) an ein Objekt der ...
	// ...Klasse ClassA weiter.
	void exec(){
		aRef.aMethode();
	}
};