L'accès variable statique à partir d'une autre classe

Je vous suggère d'utiliser un écouteur d'une sorte ou d'une autre pour permettre le Jeu d'objets d'écouter et de répondre aux changements dans l'état de l'objet graphique. Il y a plusieurs façons de le faire, mais l'un des plus élégant et le plus utile que j'ai trouvé est d'utiliser Swing est innée PropertyChangeSupport pour vous permettre d'utiliser PropertyChangeListeners. Tous les composants Swing vous permettra d'ajouter un PropertyChangeListener. Et donc, je vous suggère de le faire, que vous avez le Jeu en ajouter un à votre WampusGUI classe (qui doivent être capitalisés) objet:

public Game(WampusGUI w) {
  gui = w;

  gui.addPropertyChangeListener(new PropertyChangeListener() {
     //....
  }

Cela permettra Jeu pour écouter les changements dans l'interface graphique de l'état.

Vous devrez alors vous voulez faire de la gui userCommand Chaîne "lié à la propriété", ce qui signifie lui donnant une méthode de définition qui va déclencher le changement de propriété d'un soutien informer tous les auditeurs de changement. Je voudrais faire cela de la sorte:

public class WampusGUI extends JFrame {
   public static final String USER_COMMAND = "user command";
   //....

   private void setUserCommand(String userCommand) {
      String oldValue = this.userCommand;
      String newValue = userCommand;
      this.userCommand = userCommand;
      firePropertyChange(USER_COMMAND, oldValue, newValue);
   } 

Alors vous ne changer cette Chaîne de valeur par l'intermédiaire de cette méthode de définition:

private void enterButtonActionPerformed(java.awt.event.ActionEvent evt) {
  setUserCommand(commandText.getText());
}

Le Jeu du changement de propriété d'auditeur serait alors de répondre de la sorte:

  gui.addPropertyChangeListener(new PropertyChangeListener() {

     @Override
     public void propertyChange(PropertyChangeEvent pcEvt) {

        //is the property being changed the one we're interested in?
        if (WampusGUI.USER_COMMAND.equals(pcEvt.getPropertyName())) {

           //get user command:
           String userCommand = pcEvt.getNewValue().toString();

           //then we can do with it what we want
           play(userCommand);

        }

     }
  });

L'une des beautés de cette technique est que l'on classe, le GUI, ne pas avoir connaissance de l'observateur de la classe (le Jeu). Un petit exécutable exemple de cela est de la sorte:

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import javax.swing.*;
public class WampusGUI extends JFrame {
public static final String USER_COMMAND = "user command";
private String userCommand;
private JTextArea displayTextArea = new JTextArea(10, 30);
private JTextField commandText = new JTextField(10);
public WampusGUI() {
initComponents();
}
private void setUserCommand(String userCommand) {
String oldValue = this.userCommand;
String newValue = userCommand;
this.userCommand = userCommand;
firePropertyChange(USER_COMMAND, oldValue, newValue);
}
private void initComponents() {
displayTextArea.setEditable(false);
displayTextArea.setFocusable(false);
JButton enterButton = new JButton("Enter Command");
enterButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent evt) {
enterButtonActionPerformed(evt);
}
});
JPanel commandPanel = new JPanel(); 
commandPanel.add(commandText);
commandPanel.add(Box.createHorizontalStrut(15));
commandPanel.add(enterButton);
JPanel mainPanel = new JPanel();
mainPanel.setLayout(new BorderLayout());
mainPanel.add(new JScrollPane(displayTextArea));
mainPanel.add(commandPanel, BorderLayout.SOUTH);
add(mainPanel);
}
public void setTextArea(String text) {
displayTextArea.append(text);
}
private void enterButtonActionPerformed(java.awt.event.ActionEvent evt) {
setUserCommand(commandText.getText());
}
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
WampusGUI w = new WampusGUI();
w.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
w.pack();
w.setLocationRelativeTo(null);
w.setVisible(true);
Game g = new Game(w);
g.play();
}
});
}
}
class Game {
private WampusGUI gui;
public Game(WampusGUI w) {
gui = w;
gui.addPropertyChangeListener(new PropertyChangeListener() {
@Override
public void propertyChange(PropertyChangeEvent pcEvt) {
//is the property being changed the one we're interested in?
if (WampusGUI.USER_COMMAND.equals(pcEvt.getPropertyName())) {
//get user command:
String userCommand = pcEvt.getNewValue().toString();
//then we can do with it what we want
play(userCommand);
}
}
});
}
public void play() {
gui.setTextArea("Welcome!\n");
gui.setTextArea("Please enjoy the game!\n");
}
public void play(String userCommand) {
//here we can do what we want with the String. For instance we can display it in the gui:
gui.setTextArea("User entered: " + userCommand + "\n");
}
}

OriginalL'auteur Hovercraft Full Of Eels

Je suis d'accord avec Jon Skeet que ce n'est pas une bonne solution...

Mais si tu veux une solution sale à ur problème, alors vous pouvez essayer ceci:

public class wampusGUI extends javax.swing.JFrame
{
private static wampusGUI myInstance;
public wampusGUI( )
{
myInstance = this;
initComponents();
}
public static void getUserCommand()
{
if(myInstance!=null)
{
return myInstance.commandText.getText();
}
else
{
return null;
}
}
......
......
}

dans l'autre classe d'utilisation:

public void play()
{
.....
//String s = userCommand; //here value should come should
String s = wampusGUI.getUserCommand();
.....
}

Ce genre de code est-il dans certains de nos anciens projets... et je déteste cela.

OriginalL'auteur PC.