# private Variable übergeben



## markus_cheers (23. Apr 2012)

Hey Leute!

Ich hab ne Frage. Ich hab ein Programm mit dem GUI Builder von netbeans gemacht. In diesem Programm habe ich einen Frame aus dem ein neuer Frame geöffnet wird. In dem neuen Frame wird über ein TextField z.B. Benutzername und Passwort eingegeben. Im Listener kann ich auf die Variable über 
	
	
	
	





```
jTextField_benutzernamen.getText();
```
 zugreifen. Die Variable ist privat ebenso wie die Methode: 


```
private void jButton_OkayActionPerformed(java.awt.event.ActionEvent evt) {
        // TODO add your handling code here:
        
      String eingabe = jTextField_benutzername.getText();
    
    }
```

Jetzt möchte ich diese Variable an den anderen Frame übergeben. Die Methode und die Variable sind aber private. Wie kann ich denn auf die Variable in dem anderen Frame zugreifen?

Vielen Dank schonmal!

Gruß Markus


----------



## Marcinek (23. Apr 2012)

An dem Event gibt es getSource() und das ist dein Button.


----------



## Volvagia (23. Apr 2012)

Entweder hohlst du sie dir per setter, oder du übergibst sie per Parameter, je nach dem von welchen Punkt der Vorgang startet.

btw. Variablenamen groß und camelCase.


----------



## markus_cheers (23. Apr 2012)

Könnt ihr mir vielleicht ein Beispiel schreiben, 
wie ich auf die Variable 
	
	
	
	





```
String benutzername = jTextField_benutzernamen.getText();
```
in dem anderen Frame zugreifen kann? Merci!


----------



## Volvagia (23. Apr 2012)

```
private void jButton_OkayActionPerformed(java.awt.event.ActionEvent evt) {
      String eingabe = jTextField_benutzername.getText();

      MyFrame2 mf2 = new MyFrame2();
      mf2.daWurdeImAnderenFrameEinButtonGedruecktAlsoTuWasMitDerEingabe(eingabe);
}
```

Was natürlich bedeuten würde, dass MyFrame2 ein (virtueller) Teil des momentanen Frames ist. Sonst wird die Sache komplizierter.


----------



## Marcinek (23. Apr 2012)

Viel zu kompliziert


```
private void jButton_OkayActionPerformed(java.awt.event.ActionEvent evt) {
      String eingabe = ((JButton)evt.getSource()).getText();
 
}
```

Schade, dass das nicht via Google zu finden ist.


----------



## markus_cheers (23. Apr 2012)

Sorry aber irgendwie verstehe ich es grad nicht wirklich!
Also ich habe zwei Java Klassen:

GUI.java
verbindung.java

In GUI.java (Frame) wird Verbindung.java (Frame) aufgerufen.
In Verbindung.java möchte ich über Textfelder Benutzernamen ect. eingeben.
Also wird über den jButtonOkay2 der Benutzername eingelesen ect.


```
private void jButton_Okay2ActionPerformed(java.awt.event.ActionEvent evt) {
        // TODO add your handling code here:
        
      String benutzernamen = jTextField_eingabe2.getText();
      
    }
```


In GUI.java möchte ich diese Variablen weiterverarbeiten also auf den Benutzernamen zugreifen können.


```
private void jButton_OkayActionPerformed(java.awt.event.ActionEvent evt) {
            // TODO add your handling code here:
    }
```

Was muss jetzt in GUI.java in den Listener privat void jButton_Okay.... rein, damit ich auf
die Variabele aus Verbindung.java zugreifen kann? Problem ist ja das der Listener private ist ebenso wie die Variable....

Gruß Markus


----------



## Marcinek (23. Apr 2012)

Ich habe gefailt ;D

Dachte du willst an den Button dran.

Ich glaube du kommst nicht drumherum einen eigenen Actionlistener zu schreiben und ihm die benötigten Infos zu geben.


----------



## markus_cheers (23. Apr 2012)

Also funktioniert es nur wenn der ActionListener public ist und die Variable für das Textfeld public static ist? Ist das nicht blöd wenn ich z.B Benutzernamen und Passwort abfrage und die jeweils public sind?

verbindung.java


```
public void actionPerformed( ActionEvent e ) {

String benutzername = jTextField_benutzername.getText();

}
```

GUI.java


```
private void jButtonOkay2ActionPerformed(java.awt.event.ActionEvent evt) { 

String benuterzname = verbindung.jTextField_benutzername.getText();

}
```


----------



## Marcinek (23. Apr 2012)

Die modifiers haben damit nix zu tun.

Implementiere einen eigenen ActionListener.


----------



## markus_cheers (21. Mai 2012)

Also ich hab jetzt eine Lösung für mein Problem und vielleicht findet es ja auch jemand anderes interessant! 

1.Listener der das Textfeld mit dem Benutzernamen auswertet:

private void jButton_okay_pkActionPerformed(java.awt.event.ActionEvent evt) {
String user = jTextField_benutzername.getText();
}

2.Methode die den String user an die Methode setuser in der Datei DAO übergibt:

GUI.DAO.setuser(user);

3.Methode setuser im Detail:

public class DAO {

static String user;

public static String setuser(String u) {

    DAO.user = u;
    return u;
}

}

Jetzt kann man über "DAO.user" auf die Variable zugreifen.
Ich hoffe das war verständlich....


----------



## Gast2 (21. Mai 2012)

> private void jButton_okay_pkActionPerformed(java.awt.event.ActionEvent evt) {
> String user = jTextField_benutzername.getText();
> }


Der Code macht aber rein garnichts. Es wird ne lokale Variable angelegt, die "sofort" wieder gelöscht wird. Oder wo steht der Aufruf 
	
	
	
	





```
GUI.DAO.setuser(user):
```
?


----------



## Vancold (21. Mai 2012)

Hey!

Ich habe dir mal ein kleines Beispiel geschrieben.
Ist ziemlich simpel. bin jetzt nur drauf eingeangen wie du unter zwei Frames kommunizierst.
Ich hab einfach 1 Frame daraus gemacht.

2 Wären auch möglich. Falls du das brauchst kann ich das Beispiel ja nochmal überarbeiten!

PS: Der JOptionPane ist immer mittig das kann man nicht umstellen zumindest ist mir nichts bekannt was nicht zu umständlich wäre.



Das Frame. Hier passiert alles. (main Methode ist auch gleich dabei)


```
//Swing
import javax.swing.JFrame;
import javax.swing.JPanel;

/**
 * Das Frame in dem das Ganze Programm läuft
 * Das soll eigentlich nur dazu dienen um den Wechsel der Panels zu demonstrieren
 * und wie ich die Übergabe der Werte gestalte.
 *
 * @version 2012-05-21
 * @author Rene Polak
 */
public class MainFrame extends JFrame {
    
    
    //Attribute
    private String user,password;
    private JPanel inputPanel,mainPanel,currentPanel;
    
    //Konstanten zur Steuerung des Panelaustausches.
    public static final int MAIN_PANEL  = 0;
    public static final int INPUT_PANEL = 1;
    
    //Konstante zum schließen des Frames
    public static final int CLOSE_PANEL = 2;
    
    
    public MainFrame() {
        
        //Panel deklarieren und initialisieren.
        this.mainPanel    = new MainPanel();
        this.inputPanel   = new InputPanel();
        this.currentPanel = this.mainPanel; 
        
        //Benutzer Attribute deklarieren und initialisieren.
        this.user     = "";
        this.password = "";
        
        //Derzeitiges Panel hinzufügen und noch das Frame konfigurieren damit es schick aussieht :)
        this.add(this.currentPanel);
        this.pack();
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setTitle("Abfrage Frame");
        this.setSize(300,300);
        this.setResizable(false);
        this.setVisible(true);
        
        
        
    }
    
    
    //*******************************************//
    //**********// Getter und Setter //**********//
    //*******************************************//
    
    public void setUsername(String user) {       
        this.user = user;      
    }
    
    public void setPassword(String password) {       
        this.password = password;        
    }
    
    public String getUsername() { 
        return this.user;
    }
    
    public String getPassword() {
        return this.password;
    }
   
    
    //*******************************************//
    //************// Frame Methods //************//
    //*******************************************//
    
    /**
     * Diese Methode wechselt das derzeitige Panel mit dem angegeben Panel aus. *
     * 
     * (Wird durch die Konstanten bestimmt!) 
     * 
     * @param panelValue    Integer; Wert der einer der beiden Konstanten entspricht. (1 = InputPanel , 0 = MainPanel)
     */
    public void changePanel(int panelValue) {
        
        switch(panelValue) {
            
            case MainFrame.MAIN_PANEL:
                                
                this.remove(this.currentPanel);
                this.add(this.mainPanel);
                this.currentPanel = this.mainPanel;
                this.repaint();
                this.setVisible(true);
                
                break;
                
            case MainFrame.INPUT_PANEL:
            
                this.remove(this.currentPanel);
                this.add(this.inputPanel);
                this.currentPanel = this.inputPanel;
                this.repaint();
                this.setVisible(true);
                
                break;
                
            case MainFrame.CLOSE_PANEL:
                
                this.remove(this.currentPanel);
                this.setVisible(false);
                this.dispose();
            
        }
        
    }
    
    /**
     * ToString Methode des Frames.
     * 
     * Gibt den User und das Passwort zurück.
     * Wenn keine Eingabe gelieft wurde gibt es einfach null zurück.
     * 
     * @return      String; Usernamen und Passwort in einem String
     */
    @Override
    public String toString() {
        if( !(this.user.equals("") ) && !( this.password.equals("") ) ) {
            return "Username: " + this.user + "\n" + "Passwort:  " + this.password;
        } else {
            return null;
        }
    }
    
    
    //*******************************************//
    //*************// Start Point //*************//
    //*******************************************//
    
    /**
     * hier wird brav gestartet =)
     * 
     * @param args      String[]; Wer braucht den keine Argumente =)?
     */
    public static void main(String... args) {
        new MainFrame();
    }
    
}
```


Das eigentliche Hauptpanel. In diesem kannst du arbeiten was auch immer. Im Beispiel kann es nur das InputPanel aufrufen und eine Ausgabe machen und sich schließen.


```
// AWT
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

//Swing
import javax.swing.*;

/**
 * Das InputPanel
 * 
 * @version 2012-05-21
 * @author  Rene Poalk
 */
class MainPanel extends JPanel {
    
    
    //Attribute
    private JButton openInput,printUserData;
    private ButtonListener buttonCheck;
    private JPanel groupPanel;
    private JLabel header;
    

    public MainPanel() {
        
        //LayoutManager wird gesetzt; Listener und GruppierPanel werden erstellt.
        this.setLayout(new FlowLayout(FlowLayout.CENTER));
        this.buttonCheck = new ButtonListener();
        this.groupPanel  = new JPanel(new GridLayout(3,1,50,50));
        
        //Buttons erstellen und Listener hinzufügen
        this.openInput = new JButton("Abfrage öffnen");
        this.openInput.addActionListener(this.buttonCheck);        
        this.printUserData = new JButton("Userdaten ausgeben");
        this.printUserData.addActionListener(this.buttonCheck);
        
        //Label intialisieren und Font setzen
        this.header = new JLabel("Abfrage Frame");
        this.header.setFont(new Font("Arial",30,20));
        this.header.setHorizontalAlignment(JLabel.CENTER);
        
        //Buttons dem GruppierungsPanel hinzufügen
        this.groupPanel.add(this.header);
        this.groupPanel.add(this.openInput);
        this.groupPanel.add(this.printUserData);
        
        this.add(this.groupPanel);
     
    }
    
    
    /**
     * ButtonListener.
     * 
     * Überprüft ob an den Buttons ein Event statt gefunden hat (ein Input; d.h jemand darauf geklickt hat)
     * Wenn ja wird je nach dem was gedrückt wurde entschieden was passiert:
     * 
     * openInput:
     * Das Panel wird gewechselt zum InputPanel.
     * 
     * printUserData:
     * Ein kleines Fenster geht auf das die UserDaten ausgibt und das Programm dann schließt
     */
    private class ButtonListener implements ActionListener {

        @Override
        public void actionPerformed(ActionEvent e) {
            
            if(e.getSource() == openInput) { //Ist das event der Button openInput?
                
                if( !( (MainFrame) SwingUtilities.getRoot(openInput) ).getUsername().equals("") && !( (MainFrame) SwingUtilities.getRoot(openInput) ).getPassword().equals("")) {
                    
                    //Speichert sich das Ergebnis der ConifrmDialog
                    int out = JOptionPane.showConfirmDialog(null,"Wollen Sie Ihre Daten neu eingeben?", "Sind Sie sich sicher?",JOptionPane.YES_NO_OPTION);
                    
                    if(out == JOptionPane.OK_OPTION) { // Wenn ok gedrückt wurde soll das Panel geändert werden
                        ( (MainFrame) SwingUtilities.getRoot(openInput) ).changePanel(MainFrame.INPUT_PANEL); //ändert das Panel zum InputPanel
                    } else { // Ansonsten sag ok und tu nix :P
                        JOptionPane.showMessageDialog(null,"Wie Sie wollen","Wie Sie wollen",JOptionPane.INFORMATION_MESSAGE); 
                    }
                    
                } else {
                
                    ( (MainFrame) SwingUtilities.getRoot(openInput) ).changePanel(MainFrame.INPUT_PANEL); //ändert das Panel zum InputPanel
                    
                }
                
            } else { // Wenn nein dann wirds printUserData sein; Dann holen wir uns den Inhalt vom MainFrame
          
                String out = ( (MainFrame) SwingUtilities.getRoot(printUserData) ).toString();
                
                if( !(out == null) ) { //Ist der null? wenn nein dann gibt ihn aus und beenden das Programm                 
                    
                    JOptionPane.showMessageDialog(null,out);
                    ( (MainFrame) SwingUtilities.getRoot(printUserData) ).changePanel(MainFrame.CLOSE_PANEL);
                    
                } else { //Ansonsten teile dem User mit das er keine Eingabe gemacht hat.
                    
                    JOptionPane.showMessageDialog(null,"Keine Eingabe wurde geliefert","Achtung!",JOptionPane.ERROR_MESSAGE);
                    
                } // Else von !(out == null)                               
                
            } // (e.getSource() == openInput)
            
        } // Ende der Methode actionPerformed()
        
    } // Ende der privaten Klasse ButtonListener
    
} // Ende von MainPanel

/*
 * Normalerweise gruppiere ich das if auf 3 Zeilen. 
 * Wenn es aber mehrere Else für die Ifs gibt, 
 * lasse ich mehr Abstand für die Ifs und Zeilen zur besseren Lesbarkeit!
 */
```



Das InputPanel. Wie der name impliziert wird hier der Input generiert (durch den User).



```
//AWT
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

//Swing
import javax.swing.*;

/**
 * Abfragepanel.
 * 
 * Hier wird der Username und das Passwort abgefragt, überpürft und dem HauptFrame übergeben. 
 * 
 * @version 2012-05-21
 * @author Rene Polak
 */
public class InputPanel extends JPanel {

    
   //Attribute
    private ButtonListener buttonCheck;
    private JButton send;
    private JLabel header; 
    private JPanel groupPanel;
    private JTextField user,password;  
    
    
    /**
     * Konstruktor
     */
    public InputPanel() {
        
        //LayoutManager setzen
        this.setLayout(new FlowLayout(FlowLayout.CENTER));
        
        //JLabel erstellen
        this.header = new JLabel("Userdaten Input");
        this.header.setFont(new Font("Arial",30,20));
        this.header.setHorizontalAlignment(JLabel.CENTER);
        
        //ButtonListener initialisieren und das GruppierungsPanel erstellen (GridLayout)
        this.buttonCheck = new ButtonListener();
        this.groupPanel  = new JPanel(new GridLayout(4,1,30,30));
        
        //Eingabefelder erstellen; Sie brauchen keinen Listener
        this.user     = new JTextField("");
        this.password = new JTextField("");
        
        //Button erstellen und Listener hinzufügen
        this.send = new JButton("Senden");
        this.send.addActionListener(this.buttonCheck);
        
        //GruppierungsPanel befüllen und zum Objektpanel hinzufügen
        this.groupPanel.add(this.header);
        this.groupPanel.add(this.user);
        this.groupPanel.add(this.password);
        this.groupPanel.add(this.send);
        
        this.add(this.groupPanel);        
        
    }
    
    
    /**
     * Private Listenerklasse für den Button.
     * Reagiert darauf wenn der Button gedrückt wird und schickt die Daten an das Main-Frame-Obejkt
     */
    private class ButtonListener implements ActionListener {
        
        /**
         * Override;    Die Methode überprüft ob die Inhalte der Textfelder nicht leer sind.
         *              Wenn das zutrifft werden die Daten dem Main-Frame-Objekt übergeben durch SetterMethoden
         *              und das Panel, welches gerade im Frame ist, wird ausgetauscht. (Durch changePanel)
         * 
         * @param e     ActionEvent; das Event das auftritt, wenn der User auf den Button senden drückt.
         */
        @Override
        public void actionPerformed(ActionEvent e) {
        
            if( !( user.getText().equals("") ) && !( password.getText().equals("") ) ) {
                
                ( (MainFrame) SwingUtilities.getRoot(send) ).setUsername(user.getText());          //Setter für den Usernamen
                ( (MainFrame) SwingUtilities.getRoot(send) ).setPassword(password.getText());      //Setter für das Passwort               
                ( (MainFrame) SwingUtilities.getRoot(send) ).changePanel(MainFrame.MAIN_PANEL);    //Diese Methode ändert das Panel. (Wird durch Konstanten gesteuert)
                
                //Inputs zurück setzen
                user.setText("");
                password.setText("");
                
            } else {
                JOptionPane.showMessageDialog(null,"Geben Sie bitte Userdaten ein!","Achtung",JOptionPane.ERROR_MESSAGE); //Fehlerfesnter öffnen
            }
            
            /*
             * Warum caste ich hier? 
             * 
             * Der Grund ist einfach. Um auf die Methode zugreifen zu können brauche ich ein MainFrame.
             * Die Methode liefert mir aber nur ein Component-Objekt. Das hat nicht die Funktionen die ich dazu brauche.
             * Da ich ja weiß das es in meinem MainFrame steckt caste ich und habe gleich die Funktionalität die ich brauche ;)
             */
        
        }
       
    }
    
}
```


Wenn du das ganze zum laufen bringen willst haust einfach ins defaultpackage deines Projekts und probiers. Ist nur sehr allgemein.

Aber das Beispiel mach genau das was du willst.

Wenn ich das jetzt missverstanden hab und du willst unbedingt ein Frame haben lässt sich das auch machen 


Lg

Rene


PS: Es ist auch möglich statt dem int Wert einfach, das dass Objekt wenn es .changePanel() aufruft gleich eine Referenz durch this mitgibt.

Dann müsste man den Code nur bisschen anpassen (rausnehmen der Konstanten; man bräuchte kein switch und kann einfach den currentPanel removen und den übergebenen hinzufügen)

Wenn man will das sich das Programm schließt übergibt man null bzw. schreibt eine Methode die das Programm schließt.

Habs nur so gemacht weil ichs so gern habe uns es auch recht einfach ist. (Ich mag Konstanten einfach gerne )


----------

