property的概念
一个property 通常是外部不可见的，在该类之外，我们只能通过get/set这些接口方法实现对其读与修改，我们对其实现细节(setter/getter)不关心也并不需要知道。但是通常我们（view)对它是否改变，从什么值改变成什么值十分关心（view)
the kinds of feature in property of java fx
- 对于 fx 的property 都是可观察的(observable) 实现了observable 和observableValue接口
observable接口
public interface observable {
void addListener(InvalidationListener listener);
void removeListener(InvalidationListener listener);
}
observalue接口
public abstract interface ObservableValue<T> extends Observable
{
public abstract void addListener(ChangeListener<? super T> paramChangeListener);
public abstract void removeListener(ChangeListener<? super T> paramChangeListener);
public abstract T getValue();
}
它们监听失效(invalid) 和 变化(change) 事件
-
Property 可以分为只读的以及可读写的。
每个Property 类一般提供 : get()/set() and getValue()/setValue 针对primitive type(Read only property don't provide the set interface.) getValue/SetValue 针对装箱类型
read-write property is easy to understand, you can read-write it in internal or outside.
- 对于只读属性的认识. (read-only for outside and read-write internally)
一个ReadOnlyXXXWrapper 类 包裹了两个类型，一个是只读的，一个是可读写的.
ReadOnlyIntegerWrapper idWrapper = new ReadOnlyIntegerWrapper(100);
ReadOnlyIntegerProperty id = idWrapper.getReadOnlyProperty();
System.out.println("idWrapper:" + idWrapper.get());
System.out.println("id:" + id.get());
// Change the value
idWrapper.set(101);
System.out.println("idWrapper:" + idWrapper.get());
System.out.println("id:" + id.get());
A Book Class 同时拥有只读属性和可读写属性的一个实体类
对于可读写属性抽象类型为XXXProperty, 实现类型通常SimpleXXXProperty.对于只读属性抽象类型通常是ReadOnlyXXXProeprty, 实现类型是ReadOnlyXXXWrapper.
public class Book {
private final StringProperty title = new SimpleStringProperty(this,"title", "Unknown");
private final DoubleProperty price = new SimpleDoubleProperty(this,"price", 0.0);
private final ReadOnlyStringWrapper ISBN = new ReadOnlyStringWrapper(this,"ISBN", "Unknown");
public Book() {}
public Book(String title, double price, String ISBN) {
this.title.set(title);
this.price.set(price);
this.ISBN.set(ISBN);
}
public final String getTitle() {
return title.get();
}
public final void setTitle(String title) {
this.title.set(title);
}
public final StringProperty titleProperty() {
return title;
}
public final double getprice() {
return price.get();
}
public final void setPrice(double price) {
this.price.set(price);
}
public final DoubleProperty priceProperty() {
return price;
}
public final String getISBN() {
return ISBN.get();
}
public final ReadOnlyStringProperty ISBNProperty() {
return ISBN.getReadOnlyProperty();
}
} ```
***
## Lazily Instantiating Property Objects （充分优化内存，使用懒加载）
只有当需要item的weightProperty被需要的时候(weightProperty（）被调用)初始化property.
``` java
public class Item {
private DoubleProperty weight;
private double _weight = 150;
public double getWeight() {
return (weight == null) ? _weight : weight.get();
}
public void setWeight(double newWeight) {
if (weight == null) {
_weight = newWeight;
} else {
weight.set(newWeight);
}
}
public DoubleProperty weightProperty() {
if (weight == null) {
weight = new SimpleDoubleProperty(this, "weight", _weight);
}
return weight;
}
}
Tips:
使用懒加载或者饥饿加载主要试情况而定， 一个拥有少量属性的类，并且基本你必定会用到属性，那么可以考虑饥饿加载，如果是封装的对象开销过大或者一个类里面封装了许多属性，只有少数会使用到时候可以考虑懒加载来优化内存。
Property Class Hierarchy
Paste_Image.png
最好将 property 的getter/setter 声明为final
public class Book2 {
private final StringProperty title = new SimpleStringProperty(this,
"title", "Unknown");
public final StringProperty titleProperty() {
return title;
}
public final String getTitle() {
return title.get();
}
public final void setTitle(String title) {
this.title.set(title);
}
}
解析property 接口的方法
- bind(建立单向绑定)
与一个来自于继承泛型T链的实现了observableValue接口的对象（一般为property）相绑定
void bind(ObservableValue<? extends T> observable);
- bindBidrectional(建立双向绑定)
必须与同一类型建立双向绑定
void bindBidirectional(Property<T> other);
对property 对象添加Invalidation(失效)事件监听
main {
IntegerProperty counter = new SimpleIntegerProperty(100);
couter.set(100) // 会出发一个invalid事件
couter.set(101) // 不会触发，因为该属性已经失效
int value = couter.get() //使属性回复有效
couter.set(101) // 会再出发一个Invalid事件
// Add an invalidation listener to the counter property
counter.addListener(InvalidationTest::invalidated);
}
public static void invalidated(Observable prop) {
System.out.println("Counter is invalid.");
}
对property 对象添加change(值改变)事件监听
main {
IntegerProperty counter = new SimpleIntegerProperty(100);
// Add a change listener to the counter property
counter.set(101); // 产生changeEvent
counter.set(102); //产生changeEvent
counter.set(102); //不产生changeEvent
counter.addListener(ChangeTest::changed);
}
public static void changed(ObservableValue<? extends Number> prop,Number oldValue,Number newValue) {
System.out.print("Counter changed: ");
System.out.println("Old = " + oldValue + ", new = "+ newValue);
}
使用WeakListener来避免内存泄漏
应该在对某个property添加listener. 这样这些property中就有listener的强引用，这样这些listener就很难被回收。还有一种情况就是匿名的changlistener实现，会有外部的
对象的引用，如果外部对象包括比较占内存的view,就很容易出现这个问题。
ChangeListener<Number> cListener = create a change listener...
WeakChangeListener<Number> wListener = new WeakChangeListener(cListener);
// Add a weak change listener, assuming that counter is a property
counter.addListener(wListener);
......
cListener = null;//不需要改listener的时候
