Module javafx.controls
Package javafx.scene.control.cell

## Class PropertyValueFactory<S,​T>

- java.lang.Object
- - javafx.scene.control.cell.PropertyValueFactory<S,​T>

- Type Parameters:
    `S` - The type of the class contained within the TableView.items list.
    `T` - The type of the class contained within the TableColumn cells.
  All Implemented Interfaces:
    `Callback<TableColumn.CellDataFeatures<S,​T>,​ObservableValue<T>>`

      public class PropertyValueFactory<S,​T>
      extends Object
      implements Callback<TableColumn.CellDataFeatures<S,​T>,​ObservableValue<T>>

  A convenience implementation of the Callback interface, designed specifically for use within the `TableColumn` `cell value factory`. An example of how to use this class is:

       TableColumn<Person,String> firstNameCol = new TableColumn<Person,String>("First Name");
       firstNameCol.setCellValueFactory(new PropertyValueFactory<Person,String>("firstName"));

  In this example, `Person` is the class type of the `TableView` `items` list. The class `Person` must be declared public. `PropertyValueFactory` uses the constructor argument, `"firstName"`, to assume that `Person` has a public method `firstNameProperty` with no formal parameters and a return type of `ObservableValue<String>`.

  If such a method exists, then it is invoked, and additionally assumed to return an instance of `Property<String>`. The return value is used to populate the `TableCell`. In addition, the `TableView` adds an observer to the return value, such that any changes fired will be observed by the `TableView`, resulting in the cell immediately updating.

  If no such method exists, then `PropertyValueFactory` assumes that `Person` has a public method `getFirstName` or `isFirstName` with no formal parameters and a return type of `String`. If such a method exists, then it is invoked, and its return value is wrapped in a `ReadOnlyObjectWrapper` and returned to the `TableCell`. In this situation, the `TableCell` will not be able to observe changes to the property, unlike in the first approach above.

  For reference (and as noted in the TableColumn `TableColumn.cellValueFactoryProperty()` cell value factory} documentation), the long form of the code above would be the following:

       TableColumn<Person,String> firstNameCol = new TableColumn<Person,String>("First Name");
       firstNameCol.setCellValueFactory(new Callback<CellDataFeatures<Person, String>, ObservableValue<String>>() {
           public ObservableValue<String> call(CellDataFeatures<Person, String> p) {
               // p.getValue() returns the Person instance for a particular TableView row
               return p.getValue().firstNameProperty();
           }
        });
       }

  Deploying an Application as a Module

  If the referenced class is in a named module, then it must be reflectively accessible to the `javafx.base` module. A class is reflectively accessible if the module `opens` the containing package to at least the `javafx.base` module. Otherwise the `call(TableColumn.CellDataFeatures)` method will log a warning and return `null`.

  For example, if the `Person` class is in the `com.foo` package in the `foo.app` module, the `module-info.java` might look like this:

      module foo.app {
          opens com.foo to javafx.base;
      }

  Alternatively, a class is reflectively accessible if the module `exports` the containing package unconditionally.

  Since:
    JavaFX 2.0
  See Also:
    `TableColumn`, `TableView`, `TableCell`, `TreeItemPropertyValueFactory`, `MapValueFactory`

- - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `PropertyValueFactory​(String property)` | Creates a default PropertyValueFactory to extract the value from a given TableView row item reflectively, using the given property name.

  - ### Method Summary

    Modifier and Type | Method | Description
    --- | --- | ---
    `ObservableValue<T>` | `call​(TableColumn.CellDataFeatures<S,​T> param)` | The `call` method is called when required, and is given a single argument of type P, with a requirement that an object of type R is returned.
    `String` | `getProperty()` | Returns the property name provided in the constructor.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### PropertyValueFactory

          public PropertyValueFactory​(String property)

      Creates a default PropertyValueFactory to extract the value from a given TableView row item reflectively, using the given property name.
      Parameters:
        `property` - The name of the property with which to attempt to reflectively extract a corresponding value for in a given object.

  - ### Method Detail

    - #### call

          public ObservableValue<T> call​(TableColumn.CellDataFeatures<S,​T> param)

      The `call` method is called when required, and is given a single argument of type P, with a requirement that an object of type R is returned.
      Specified by:
        `call` in interface `Callback<S,​T>`
      Parameters:
        `param` - The single argument upon which the returned value should be determined.
      Returns:
        An object of type R that may be determined based on the provided parameter value.

    - #### getProperty

          public final String getProperty()

      Returns the property name provided in the constructor.
      Returns:
        the property name provided in the constructor