Von einer anderen Klasse auf JTextField zugreifen

[specialize]

Grüß euch,

Die Überschrift gibts zwar schon, allerdings ging es im Thema dann doch um was anderes.
Meine Frage ist nun, wie ich den Inhalt eines JTextfields als String in eine andere Klasse bekomme. ???:L

 

[Andi_CH]

Da gibts sicher 1001 Möglichkeiten

Zwei davon:

entweder die andere Klasse hat eine Referenz auf das JTextField (nicht mein Favorit)

oder

die Klasse die das TextField hält hat eine get-Funktion welche den String liefert (und vielleicht auch eine set-funktion um den zu setzen ...)

 

[specialize]

ok habs so gelöst:
Klasse 1

	public String getdef(){
		String s_trade_def = new String(tf_def.getText());		
		return s_trade_def;		
	}

Klasse 2

private String def = new Klasse1().getdef();

 

[Final_Striker]

	public String getdef(){
		String s_trade_def = new String(tf_def.getText());		
		return s_trade_def;		
	}

kannst du auch direkt als

	public String getdef(){	
		return tf_def.getText();		
	}

schreiben.

In Java benutzt man übsigens die CamelCase Notation.
Also nicht s_trade_def sondern sTradeDef. ;-)

 

[specialize]

In Java benutzt man übsigens die CamelCase Notation.
Also nicht s_trade_def sondern sTradeDef. ;-)[/QUOTE]

Ok danke :)

Ich hab gerade gemerkt es funktioniert doch nicht so wie ich will.

Durch das 
[code=Java]
new Klasse1

wird die Klasse ja neu instanziert und hat somit die initialisierten parameter anstatt die aktuellen.

Konkret:

Ich Starte Klasse 1, ich ändere den Text des JTextField, Klasse 1 startet Klasse 2 , Klasse 2 bekommt den Inhalt vom Klasse 1' JTextField.

???:L

 

[Camino]

Du könntest Klasse2 eine Referenz von Klasse1 mit übergeben, und dann in Klasse1 eine get-Methode schreiben, mit der du dann aus Klasse2 heraus den Wert vom Textfeld auslesen kannst.

 

[GUI-Programmer]

Mein Tipp: Arbeite grundsätzlich nach dem Model-View-Controller Prinzip, dann bekommst du erst garnicht solche Probleme, da nur die View und Controller etwas an einem grafischen Komponenten (wie hier JTextField) ändern können können. Und die Konstruktoren sind eindeutig:
Model:

public Model() {...}

View:

public class View extends JPanel {
    private Model model;
    private Controller controller;
    
    // Weitere grafische Attribute (=Komponenten) stehen hier:
    // Wichtig: sie dürfen nicht private sein, dan ansonsten der Controller
    // keinen Zugriff auf sie hat --> er wäre nutzlos!
    protected Zeichnung zeichnung;
    protected JButton button;
    //...
    
    // Konstruktor
    public View(Model m) {
        this.model = m;
        controller = new Controller(this, model);
        
        button = new JButton();
        //...
        // Einstellen der Grafik
        //...
    }
}

Controller:

public class Controller implements ActionListener /*, weitere Listener*/{
    // Attribute
    private Model model;
    private View view;
    //...
    
    // Konstruktor
    public Controller(View v, Model m) {
        this.view = v;
        this.model = m;
        //...
    }
    
    // Methoden
    public void actionPerformed(ActionEvent evt) {
        if(evt.getSource().equals(view.button)) {
            //..
        }
    }
}

Ausführbare Klasse, also JFrame, JApplet oder JWindow...:

public class Application extends JFrame {
    // Attribut(e)
    private View view;
    
    
    // Konstruktor
    public Application() {
        view = new View(new Model());
        
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        setTitle("Model View Controller - Applikation");
        setContentPane(view);
        setVisible(true);
        pack();
    }
    
    
    // Methode(n)
    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                new Application();
            }
        });
    }
}

 

[bERt0r]

Wenn eine Klasse gewisse Informationen (wie z.b der Inhalt eines Textfelds) zur Instanzierung eines Objekts benötigt, empfiehlt es sich diese Information als Parameter an den Konstruktor zu übergeben.
Von Klasse 1 kannst du schließlich bequem auf das Textfeld zugreifen und da Klasse 2 anscheinend an dem Textfeld nichts mehr ändert hast du dadurch eine saubere Trennung der beiden Klassen.

 

[specialize]

Wenn eine Klasse gewisse Informationen (wie z.b der Inhalt eines Textfelds) zur Instanzierung eines Objekts benötigt, empfiehlt es sich diese Information als Parameter an den Konstruktor zu übergeben.
Von Klasse 1 kannst du schließlich bequem auf das Textfeld zugreifen und da Klasse 2 anscheinend an dem Textfeld nichts mehr ändert hast du dadurch eine saubere Trennung der beiden Klassen.

Bitte führe das noch weiter mittels javacode aus 🙂

[Java]
public class Klasse1 {

JTextField tfEins;

public Klasse1(){

tfEins = new JTextField();

}
[/code]

 

[Andi_CH]

Zuerst drücke ich mal meine Verwunderung aus - wie "startet" man eine Klasse :bahnhof:

Wenn eine Klasse gewisse Informationen (wie z.b den Inhalt eines Textfelds) zur Instanzierung eines Objekts benötigt, empfiehlt es sich diese Information als Parameter an den Konstruktor zu übergeben.

Du willst den Text dem Konstruktor übergeben :bahnhof: - na ja, genau so beschreibst du es.

Von Klasse 1 kannst du schließlich bequem auf das Textfeld zugreifen und da Klasse 2 anscheinend an dem Textfeld nichts mehr ändert hast du dadurch eine saubere Trennung der beiden Klassen.

Das würde ich NIEMALS so machen - wehe wenn da mal ein anderes Feld verwendet wird -> das braucht eine get Funktion für den Wert.

Klasse 1, die das Textfeld hat, bietet eine get-Funktion an mit welcher der String gelesen werden kann.

mehr braucht es wirklich nicht.

import javax.swing.JTextField;

public class Klasse1 {
	
	private JTextField tfEins;
	
	public Klasse1() {
		tfEins = new JTextField();
		// ......
	}
	
	public String getTfEins() {
		return tfEins.getText();
	}	
}

Edit: Falls ich die TO falsch verstanden habe, erkläre mir bitte warum du vom GUI aus in einer andere Klasse schreiben muss und dies andere Klasse nicht wie üblich den Wert holt

 

[Andi_CH]

Eine mögliche Variante:

public interface MyInterface {
	public String getTfEins();
}

public class Klasse2 {
	MyInterface gui;

	public Klasse2 (MyInterface ifToGui) {
		gui = ifToGui;
	}
	
	public void doSomething() {
		String gelesenerWert = gui.getTfEins();
		System.out.println("Text vom Gui = " + gelesenerWert);
	}
}

public class Klasse1 implements MyInterface {

	private JTextField tfEins;
	private Klasse2 k2;

	public Klasse1() {
		tfEins = new JTextField();
		tfEins.setText("Initialwert");
		// ......
		 k2 = new Klasse2(this);
	}

	@Override
	public String getTfEins() {
		return tfEins.getText();
	}

	private void simulateValuechange() {
		k2.doSomething();
	}

	public static void main(String... args) {
		Klasse1 k1 = new Klasse1();
		// das simuliert nur den Trigger den der Eventhandler auslösen würde
		k1.simulateValuechange();
	}
}

 

[specialize]

Poste mir bitte noch Klasse 2 dazu Andi

public class Klasse2{

private String sEins = new Klasse1().getTfEins();

}

Funktioniert nicht, weil er ja die Klasse neu erstellt.

€: Ok schon geschehen, Danke! 🙂

 

[specialize]

Da Klasse 2 ein JUnit Testcase ist und dieser nur public null konstruktoren erlaubt hab ich mich dazu entschlossen den String mittels einer zusätzlichen datei (writer/reader) zu übermitteln.

Trotzdem Danke für eure Hilfe! Leute mit ähnlichen Herausforderungen wird hier geholfen 🙂

 

[Camino]

Eine mögliche Variante:
...

Hallo,

ich hab da nochmal kurz ne Frage dazu: ist es eigentlich grundsätzlich besser (oder bessere Programmierung), wenn ich das so mit einem Interface mache, oder kommt es aufs gleiche raus, wenn ich eine Referenz auf die Klasse übergebe, und dann in der anderen Klasse darüber die get-Methode aufrufe? Gibt es da Vor- und Nachteile oder ist es egal?

Gruss
Camino