PropertyValueFactory (JavaFX 19)
Description: declaration: module: javafx.controls, package: javafx.scene.control.cell, class: PropertyValueFactory

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.
  `final String`
  `getProperty()`
  Returns the property name provided in the constructor.

  ### Methods declared in class java.lang.Object

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

- ## Constructor Details

  - ### 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 Details

  - ### 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