Java Begivenhed Lytteren til at opdage en variabel ændre

Jeg kan ikke synes at finde et svar hvor som helst på mit spørgsmål. Er der nogen begivenhed lytteren, der kan detektere en ændring af en boolesk eller anden variabel, og derefter handle på det. Eller er det muligt at oprette en tilpasset hændelse lytteren til at opdage dette?

Bemærk, at jeg ikke kan synes at finde en løsning på dette hvor som helst, og jeg fandt denne hjemmeside, der forklarer, hvordan du opretter brugerdefinerede begivenheder

OriginalForfatteren CoderTheTyler | 2011-11-23

7 svar

  1. 7

    Ligesom du brug for at oprette en begivenhed lytteren, vil du også nødt til at oprette tilfælde firer — da der ikke er noget automatisk, der vil gøre dette for dig. Jeg har givet prøve kode, der viser dig, hvordan til at gennemføre sådan en firer.

    Denne test gennemførelse ikke er perfekt. Den indeholder kun en måde at tilføje lyttere. Du ønsker måske at inkludere en måde at fjerne lyttere, der er ikke længere interesseret i at modtage begivenheder. Bemærk også, at denne klasse ikke thread-safe.

    import java.util.List;
    import java.util.ArrayList;
    import java.util.EventListener;
    import java.util.EventObject;
    import java.awt.EventQueue; 
    
    /**
     * This class uses the EventQueue to process its events, but you should only 
     * really do this if the changes you make have an impact on part of a GUI 
     * eg. adding a button to a JFrame.
     *
     * Otherwise, you should create your own event dispatch thread that can handle
     * change events
     */
    public class BooleanChangeTest implements BooleanChangeDispatcher {
    
        public static void main(String[] args) {
    
            BooleanChangeListener listener = new BooleanChangeListener() {
                @Override
                public void stateChanged(BooleanChangeEvent event) {
                    System.out.println("Detected change to: "
                        + event.getDispatcher().getFlag()
                        + " -- event: " + event);
                }
            };
    
            BooleanChangeTest test = new BooleanChangeTest(false);
            test.addBooleanChangeListener(listener);
    
            test.setFlag(false); //no change, no event dispatch
            test.setFlag(true); //changed to true -- event dispatched
    
        }
    
        private boolean flag;
        private List<BooleanChangeListener> listeners;
    
        public BooleanChangeTest(boolean initialFlagState) {
            flag = initialFlagState;
            listeners = new ArrayList<BooleanChangeListener>();
        }
    
        @Override   
        public void addBooleanChangeListener(BooleanChangeListener listener) {
            listeners.add(listener);
        }
    
        @Override
        public void setFlag(boolean flag) {
            if (this.flag != flag) {
                this.flag = flag;
                dispatchEvent();
            }
        }
    
        @Override
        public boolean getFlag() {
            return flag;
        }
    
        private void dispatchEvent() {
            final BooleanChangeEvent event = new BooleanChangeEvent(this);
            for (BooleanChangeListener l : listeners) {
                dispatchRunnableOnEventQueue(l, event);
            }
        }
    
        private void dispatchRunnableOnEventQueue(
                    final BooleanChangeListener listener, 
                    final BooleanChangeEvent event) {
    
            EventQueue.invokeLater(new Runnable() {
                @Override
                public void run() {
                    listener.stateChanged(event);
                }
            });
        }
    
    }
    
    interface BooleanChangeDispatcher {
    
        public void addBooleanChangeListener(BooleanChangeListener listener);
        public boolean getFlag();
        public void setFlag(boolean flag);
    
    }
    
    /**
     * Listener interface for classes interested in knowing about a boolean
     * flag change.
     */
    interface BooleanChangeListener extends EventListener {
    
        public void stateChanged(BooleanChangeEvent event);
    
    }
    
    /** 
     * This class lets the listener know when the change occured and what 
     * object was changed.
     */
    class BooleanChangeEvent extends EventObject {
    
        private final BooleanChangeDispatcher dispatcher;
    
        public BooleanChangeEvent(BooleanChangeDispatcher dispatcher) {
            super(dispatcher);
            this.dispatcher = dispatcher;
        }
    
        //type safe way to get source (as opposed to getSource of EventObject
        public BooleanChangeDispatcher getDispatcher() {
            return dispatcher;
        }
    }
    Tak det virkede perfekt! Nu bare at lære alt om det og justere det til at arbejde med hvad jeg ønsker at gøre. Tak.

    OriginalForfatteren Dunes

  2. 7

    Bruge PropertyChangeSupport. Du vil ikke nødt til at gennemføre så meget, og det er i tråd sikker.

    public class MyClassWithText {
        protected PropertyChangeSupport propertyChangeSupport;
        private String text;
    
        public MyClassWithText () {
            propertyChangeSupport = new PropertyChangeSupport(this);
        }
    
        public void setText(String text) {
            String oldText = this.text;
            this.text = text;
            propertyChangeSupport.firePropertyChange("MyTextProperty",oldText, text);
        }
    
        public void addPropertyChangeListener(PropertyChangeListener listener) {
            propertyChangeSupport.addPropertyChangeListener(listener);
        }
    }
    
    public class MyTextListener implements PropertyChangeListener {
        @Override
        public void propertyChange(PropertyChangeEvent event) {
            if (event.getPropertyName().equals("MyTextProperty")) {
                System.out.println(event.getNewValue().toString());
            }
        }
    }
    
    public class MyTextTest {
        public static void main(String[] args) {
            MyClassWithText interestingText = new MyClassWithText();
            MyTextListener listener = new MyTextListener();
            interestingText.addPropertyChangeListener(listener);
            interestingText.setText("FRIST!");
            interestingText.setText("it's more like when you take a car, and you...");
        }
    }

    OriginalForfatteren johnjamesmiller

  3. 3

    du kan også prøve at gennemføre en Observatør.

    Først oprette observerbare objekt:

    import java.util.Observable;
    
    public class StringObservable extends Observable {
     private String name;
    
    
     public StringObservable(String name) {
      this.name = name;
     }
    
     public String getName() {
      return name;
     }
    
    
     public void setName(String name) {
      this.name = name;
      setChanged();
      notifyObservers(name);
     }
    
    }

    Så observatør:

    import java.util.Observable;
    import java.util.Observer;
    
    public class NameObserver implements Observer {
     private String name;
    
     public NameObserver() {
      name = null;
     }
    
     public void update(Observable obj, Object arg) {
      if (arg instanceof String) {
       name = (String) arg;
       System.out.println("NameObserver: Name changed to " + name);
      } else {
       System.out.println("NameObserver: Some other change to subject!");
      }
     }
    }

    Og i din primære (eller andre steder):

    public class TestObservers {
     public static void main(String args[]) {
    
      //Create the Subject and Observers.
      StringObservable s = new StringObservable("Test");
      NameObserver nameObs = new NameObserver();
    
      //Add the Observer
      s.addObserver(nameObs);
    
    
      //Make changes to the Subject.
      s.setName("Test1");
      s.setName("Test2");
     }
    }

    For det meste findes her

    Heads op: Java.util.observerbare ser nu ud til at være forældet.

    OriginalForfatteren Pontios

  4. 1

    Den booleske, du angiver skal have lov til at gøre, kun gennem en setter metode som:

    public void setFlag(boolean flag){
        //Method code goes here
    }

    Nu i sæt nu, metode, kan du beslutte, baseret på, hvad værdi kommer i, hvad begivenheden behov for at blive fyret. Jeg forklarer på en enkel måde uden at indføre komplekse vilkår, så du kan forstå, bedre, så kodestykke ville se ud:

    public void setFlag(boolean flag){
    
        //if flag is TRUE do something
        //If flag is FALSE then do something 
    
        //And finally do what you needed to do with flag
    }

    Stille spørgsmål, hvis du har brug for mere info

    Gør dette hele tiden opdage og fornemme det øjeblik, hvor det ændres? Eller er det bare køre igennem en gang?
    Der ville arbejde for, når som helst boolean er ændret via setter.

    OriginalForfatteren Vishal Biyani

  5. 0

    du oprette en lytter når du ønsker at lytte til i/O-ændringer. for det meste på grafik.
    svaret på dit spørgsmål er at holde staten kørende program, og derefter kontrollere, om variabler ændrer sig fra den stat, inde i uendelig løkke af dit program.

    Du mener ligesom at skabe en timer eller en løkke til at opdage, når denne ændring sker? Det er, hvad jeg forsøger at undgå at gøre, fordi når alt for mange kører samtidig, kan det medføre forsinkelse i større programmer.
    well..det afhænger af dit design. derudover kan du altid bruge tråde, men så bør du tage sig af synkronisering af genstande, da du ellers vil få en samtidig ændring undtagelse

    OriginalForfatteren

  6. 0

    Du kan bruge AOP for, at der måske AspectJ? Se et par eksempler her (hvis du bruger Eclipse, så ved hjælp af AspectJ er virkelig simpelt, og med deres plugin).

    For dig, ville du have et pointcut ligner den, der anvendes i SampleAspect, men en, der kun vil blive brugt, når nogen gør et nyt SÆT til en boolesk variabel (dette betyder ikke, at værdien har ændret sig, blot at nogen har lagt en værdi til variablen).

    OriginalForfatteren rnunes

Skriv et svar

Din e-mailadresse vil ikke blive publiceret. Krævede felter er markeret med *