S
- The type of the class contained within the TableView.items list.T
- The type of the class contained within the TableColumn cells.public class PropertyValueFactory<S,T>
extends java.lang.Object
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.
TableColumn
,
TableView
,
TableCell
,
TreeItemPropertyValueFactory
,
MapValueFactory
Modifier and Type | Field and Description |
---|---|
private java.lang.Class<?> |
columnClass |
private java.lang.String |
previousProperty |
private java.lang.String |
property |
private <any> |
propertyRef |
Constructor and Description |
---|
PropertyValueFactory(java.lang.String property)
Creates a default PropertyValueFactory to extract the value from a given
TableView row item reflectively, using the given property name.
|
Modifier and Type | Method and Description |
---|---|
<any> |
call(<any> param) |
private <any> |
getCellDataReflectively(S rowData) |
java.lang.String |
getProperty()
Returns the property name provided in the constructor.
|
private final java.lang.String property
private java.lang.Class<?> columnClass
private java.lang.String previousProperty
private <any> propertyRef
public PropertyValueFactory(java.lang.String property)
property
- The name of the property with which to attempt to
reflectively extract a corresponding value for in a given object.public <any> call(<any> param)
public final java.lang.String getProperty()
private <any> getCellDataReflectively(S rowData)