Chaîne de caractères ou variable de type Entier Auditeur en java?

Tout d'abord, je suis assez nouveau à java et je suis juste regarder pour obtenir le coup de la façon dont les classes statiques peuvent assurer l'interface avec les non-classes statiques et comment obtenir une classe statique pour mettre à jour une zone de texte.

Je continue la recherche de l'information, mais je ne peut pas trouver quoi que ce soit. J'ai besoin d'une variable à l'écoute. voici quelque chose comme ce que je suis en train de faire:

public class Class1{

public static int X;
public static void Process(){
   for (true){
        X = X + 1;
    }
}

Puis j'ai une autre classe où je veux lier une variable à une zone de texte

Public class Class2{
  ****** On Class1.X.changeValue { Form.jLabel1.setText(Class1.X) }
}

J'espère avoir été clair sur ce que je suis en train de faire. Je suis en train de lier une étiquette à une variable.

OriginalL'auteur Adam Outler | 2010-07-18

  1. 2

    En Java il n'y a pas de langue propre façon d'avoir des auditeurs sur les variables. Ce que vous devez faire est lorsque vos modifications du code de la variable, puis également de mettre à jour le JLabel.

    Vous pouvez avoir les auditeurs sur les boutons et autres widgets et ils peuvent mettre à jour les JLabel.

    Une façon de mettre en œuvre ce est comme suit. Savez-vous à propos des getters et setters ? Ils sont des méthodes qui ne l'obtention et définition des variables d'instance. 

    private int x;

public int getX()
{
    return x;
}

public void setX(int anX)
{
    x = anX;
    updateLabel("This is x:" + anX)
}

public void process()
{
    while(true)
    {
        int anX = getX();
        setX(anX + 1);
    }
}

    Vous devriez vraiment essayer de minimiser l'utilisation de la statique, autant que possible, Ils ont tendance à encourager les "Variables Globales"

    Mon processus jusqu'à présent, ont exigé traitement statique. J'ai défini 200 variables statiques et 15 classes statiques qui il n'existe qu'une seule instance de. Plusieurs instances vis les choses. En gros, une série de communications de l'application. J'apprécie l'aide.
    Outler j'ai écrit de Série de logiciels de communications, sans que beaucoup de variables statiques. Il semble que vous êtes juste de l'écriture du code de procédure, Cela va être difficile lorsque votre programme est grande. OO principes sont un excellent moyen d'encapsuler et de cacher des informations à partir d'autres parties du programme.
    Plus probable que vous travailliez avec les mêmes informations. Ma demande est la collecte de données qui est utilisée pour le fonctionnement de plusieurs systèmes. TR / min, le calendrier, les températures, les débits, les niveaux de saturation, chacun est séparé variable statique et uniquement les informations les plus actuelles est important.

    OriginalL'auteur Romain Hippeau

  2. 3

    vous pouvez utiliser Modèle de Conception observateur

    OriginalL'auteur wizztjh

  3. 1

    De Java lui-même ne prend pas en charge la liaison comme une fonctionnalité du langage.

    JavaFX n', et il s'interface avec le code Java de façon très harmonieuse, bien sûr.

    OriginalL'auteur erickson

  4. 1

    Vous devriez donner à votre classe un nom propre (pas Class1), de sorte que votre intention n'est pas claire. Peut-être que vous voulez avoir un compteur?:

    package so3274211;

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

public class Counter {
  private int value = 0;
  private final List<Listener> listeners = new CopyOnWriteArrayList<Listener>();

  private void fireAfterValueChanged() {
    for (Listener listener : listeners) {
      listener.afterValueChanged(this);
    }
  }

  public int getValue() {
    return value;
  }

  public void increment() {
    value++;
    fireAfterValueChanged();
  }

  public void addListener(Listener listener) {
    listeners.add(listener);
  }

  public void removeListener(Listener listener) {
    listeners.remove(listener);
  }

  public interface Listener {
    void afterValueChanged(Counter counter);
  }

}

    Ordinaire de code Java vous ne pouvez pas écouter une variable directement. Mais si vous mettez cette variable dans un objet simple avec la modification appropriée des méthodes (increase() dans ce cas), vous pouvez appeler les auditeurs de cette méthode.

    À l'appel d'un auditeur vous avez en quelque sorte de l'enregistrer. C'est généralement mis en œuvre avec un simple List<Listener>, et l'interface est composé des deux méthodes addListener(Listener) et removeListener(Listener). Vous pouvez trouver ce modèle partout dans AWT et Swing.

    J'ai défini le Listener interface à l'intérieur de la Counter classe parce que cette interface n'a pas beaucoup de valeur en dehors de la classe, et je ne voulais pas l'appeler CounterListener. De cette façon, il y a moins de .java fichiers qui volent autour.

    À l'aide de ce compteur dans un programme peut ressembler à ceci:

    package so3274211;

public class Main {

  public static void main(String[] args) {
    Counter c = new Counter();
    c.increment();
    c.addListener(new Counter.Listener() {
      @Override
      public void afterValueChanged(Counter counter) {
        System.out.println(counter.getValue());
      }
    });
    c.increment();
  }

}

    J'ai d'abord créé un comptoir, puis ajout d'un écouteur. L'expression new Counter.Listener() { ... } est une classe anonyme définition, qui apparaît aussi souvent dans Java programmation GUI.

    Donc, si vous êtes sérieux au sujet de la programmation GUI vous avez besoin d'apprendre ces concepts et les techniques de mise en œuvre (de l'encapsulation d'une variable dans une classe, en ajoutant le code d'écouteur, de la définition d'un auditeur, l'appel de l'auditeur du code qui modifie la variable) de toute façon.

    wow.. c'est beaucoup trop d'informations pour moi de processus. Je ne peux pas voir la forêt à travers les arbres. J'ai eu un problème simple et j'ai écrit un exemple très simple pour montrer le problème simple.
    Outler - Malheureusement, c'est plutôt une approche classique pour la liaison en Java. Souvent, au lieu de déclarer votre propre écouteur de type, et de la rédaction de votre propre composant, vous serez à l'aide de pré-types définis par le JDK. Mais ils travaillent essentiellement de cette manière. J'allais écrire quelque chose de semblable dans ma réponse, mais je n'ai pas l'énergie. C'est pourquoi j'ai recommandé un JavaFX de l'INTERFACE utilisateur, lorsqu'une liaison est essentiellement ce que vous avez écrit dans votre question.

    OriginalL'auteur Roland Illig