# Von einer anderen Klasse auf JTextField zugreifen



## specialize (19. Aug 2011)

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 (19. Aug 2011)

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 (19. Aug 2011)

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 (19. Aug 2011)

```
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 (19. Aug 2011)

Final_Striker hat gesagt.:


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


----------



## Camino (19. Aug 2011)

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 (21. Aug 2011)

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 (21. Aug 2011)

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 (22. Aug 2011)

bERt0r hat gesagt.:


> 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 (22. Aug 2011)

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



bERt0r hat gesagt.:


> 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.



bERt0r hat gesagt.:


> 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 (22. Aug 2011)

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 (22. Aug 2011)

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 (22. Aug 2011)

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 (22. Aug 2011)

Andi_CH hat gesagt.:


> 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


----------

