CODEWITHSUNDEEP
javajavafx
WaffleMan0310
WaffleMan0310

Reputation: 75

Why use JavaFX properties?

Pardon my question if it may seem stupid but I'm curious. I am making a program in Java of which will have a GUI, and am curious about the whole idea of properties. Why use them when we can just add data to a class? For example:

class myButton extends Button {

   private boolean booleanProperty = false;

   myButton(args...) {
      // Do something with the property
   }

   public void setProperty(boolean value) {
      this.booleanProperty = value;
   }

   public boolean getProperty() {
      return this.booleanProperty;
   }
}

Seems to work just fine for storing additional information on the custom implementation of the button. But what about:

class myButton extends Button {

   private SimpleBooleanProperty booleanProperty = new SimpleBooleanProperty(false);

   myButton(args...) {
      // Do something with the property
   }

   public void setProperty(boolean value) {
      this.booleanProperty.set(value);
   }

   public boolean getProperty() {
      return this.booleanProperty.get();
   }
}

The only real difference, I am seeing (correct me if I'm wrong) is that that you can attach listeners to the property values, but I feel as if there has to be more than just that. Ideas?

Upvotes: 4

Views: 4081

Answers (5)

fabian
fabian

Reputation: 82461

In this case you don't have a benefit, since you do not allow access to the property object itself. Usually this is done.

This allows you to add listeners to the property and be notified, when it changes.

Bindings are using this possibility to keep values the same and properties as well as the Bindings class provide methods for simple conversions of properties.

BooleanProperty booleanProperty = new SimpleBooleanProperty();
booleanProperty.addListener(new ChangeListener<Boolean>() {

    @Override
    public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue, Boolean newValue) {
        System.out.println("property changed form "+oldValue +" to "+newValue);
    }
});
booleanProperty.set(true);
booleanProperty.set(true);
booleanProperty.set(false);
booleanProperty.set(false);
booleanProperty.set(false);
booleanProperty.set(true);
booleanProperty.set(false);
booleanProperty.set(true);
booleanProperty.set(false);

Furthermore it allows you to pass an object representing the property. E.g. code that has to write/read booleanProperty does not need information about the myButton to write/read the property; you can just pass the property.

TableView is an example of a class that makes use of propertys. The columns used with TableView get a property from the items in the TableView and TableView registers a listener to that property. This allows it to change the values displayed in the cells even if the changes are triggered somewhere else in the code. Also for editable cells the properties of the items can be automatically modified.

Upvotes: 3

Lealo
Lealo

Reputation: 321

Imagine programming a robot that would take care of resturant customers. How would it respond to customers or any other tasks that would have to be taken care of without using something like property listeners.

The benefit of using property listeners is that you can make your program become Concurrent. If there are no customers coming the next 1 hour your otherwise Sequentially made program would stand and do nothing for the next hour. Maybe switching the word Concurent with flexible in this example would be better, but you should look up Concurent programming and Sequence programming. Those properties allow you to customly make your program concurent.

You should also know that the gui you are using are already use built-in (event listening) features which build on the same principle.

Now what if you made that robot - instead of handing 1 customer at a time - respond depending upon what had to be done instead. Ask customers what the food tasted like (if customers have eaten), take new order(if called upon - by ANYBODY), take dishes(When any customer has paid and there is dish on a table), handle payment(When called upon by anybody). And ofcours handling a new customer arriving at the resturant.

The concurrently made program will handle any task needed by any customer. The sequencly made robot would only handle one customer at a time. Maybe it only then also has to be limited to greeting customers and placing them on seats to be anyhow useful. (You cannot have 1 robot for each customer).

Some people think it is easier to program sequencially can also be said. This is beacuse it can be difficult to keep track of subtasks that has to be done in a particular order. For instance that robot should not look for dishes when there haven´t arrived any customers. And what happens if it receives a payment call - while carrying dish? So it´s hard to prioritize and sort out the different tasks. However when succesfully doing it you program becomes so much more effective. It will be able to mutli task vs just solo-tasking.

And yes the sole purpose of properties is indeed that you can add listeners to them.

Upvotes: 0

Jhonny007
Jhonny007

Reputation: 1798

They really are useful in a lot of ways I even started them using in non UI related stuff. But look at this example: You habe an undomanager class

public class UndoManager {
    BooleanProperty canUndo = ...;
    BooleanProperty canRedo = ...;

    ...
}

And you have 3 places from where you can invoke undo/redo.

MenuButton menuUndo;
Button toolbarUndo;
MenuButton contextMenuUndo;

You basically only beed to do this:

menuUndo.disabledProperty().bind(undoManager.undoProperty()):
toolbarUndo.disabledProperty().bind(undoManager.undoProperty());
contextMenuUndo.disabledProperty().bind(undoManager.undoProperty());

and you dont ever have to worry about it again. If you add a new place where an undo can happen you just have to bind it too.

Upvotes: 3

Kiskae
Kiskae

Reputation: 25573

The power of JavaFX's properties is that they can be bound in ways that will automatically update the UI when a change occurs.

As an example consider an element you want to hide if a textField contains no value:

TextField tf = ...
Node container = ...
container.visibleProperty.bind(tf.textProperty.isNotEmpty());

Now as you change the text in tf, you will see container switching whether its visible based on the presence of text.

Upvotes: 8

Sam Orozco
Sam Orozco

Reputation: 1258

The use of a javafx property for a pre-made object to hold an arbitrary value for later use. So you can set values to a text field or some other object that doesn't directly effect the shown value

Upvotes: 0

Related Questions