JavaBean的属性（Simple、Indexed、Bound、Constrained）

JavaBean 的属性与 Java 程序中所指的属性，或者说与所有面向对象的程序设计语言中对象的属性是一个概念，在程序中的具体体现就是类中的变量。在 JavaBean 设计中，按照不同的作用可以将属性分为四类：Simple、Indexed、Bound、Constrained 属性。

Simple属性

一个简单属性表示一个伴随有一对 get/set 方法（C 语言中的过程或函数，在 Java 程序中称为“方法”）的变量。属性名与和该属性相关的 get/set 方法名对应。例如：如果有 setX 和 getX 方法，则暗指有一个名为 X 的属性；如果有一个方法名为 isX，则通常暗指 X 是一个布尔属性（即 X 的值为 true 或 false）。

【例1】使用 Simple 属性的代码如下。

Canvas 类的源程序如下：

1. package example4-3;
2. import java.awt.Color;
3. public class Canvas
4. {
5. public void setBackground(Color df){}
6. public void setForeground(Color df){}
7. }

alden 类的源程序如下：

1. package example4-3-1;
2. import java.awt.Color;
3. public class alden extends Canvas
4. {
5. String ourString="Hello"; //属性名为ourString，类型为字符串
6. public alden()
7. {
8. //alden1()是alden1的构造函数，与C++中构造函数的意义相同
9. setBackground(Color.red);
10. setForeground(Color.blue);
11. }
12. //"set"属性
13. public void setString(String newString)
14. {
15. ourString=newString;
16. }
17. //"get"属性
18. public String getString()
19. {
20. return ourString;
21. }
22. }

Indexed属性

一个 Indexed 属性表示一个数组值。使用与该属性对应的 set/get 方法可以取得数组中的数值。该属性也可一次设置或取得整个数组的值。

【例2】使用 Indexed 属性的代码如下：

1. package example4-4;
2. import java.awt.Color;
3. public class alden2 extends Canvas
4. {
5. int[] dataSet={1,2,3,4,5,6}; //dataSet是一个indexed属性
6. public alden2()
7. {
8. setBackground(Color.red);
9. setForeground(Color.blue);
10. }
11. //设置整个数组
12. public void setDataSet(int[] x)
13. {
14. dataSet=x;
15. }
16. //设置数组中的单个元素值
17. public void setDataSet(int index,int x)
18. {
19. dataSet[index]=x;
20. }
21. //取得整个数组值
22. public int[] getDataSet()
23. {
24. return dataSet;
25. }
26. //取得数组中的指定元素值
27. public int getDataSet(int x)
28. {
29. return dataSet[x];
30. }
31. }

Bound属性

Bound 属性是指当该种属性的值发生变化时，要通知其他的对象。每次属性值改变时，这种属性就引发一个 PropertyCliange 事件（在 Java 程序中，事件也是一个对象）。事件中封装了属性名、属性的原值、属性变化后的新值。这种事件传递到其他的 bean，至于接收事件的 bean 应做什么动作由其自己定义。

当 PushButton 的 background 属性与 Dialog 的 background 属性绑定时，若 PushButton 的 background 属性发生变化，则 Dialog 的 background 属性也发生同样的变化。

【例3】使用 Bound 属性的代码如下：

1. public class alden3 extends Canvas
2. {
3. String ourString="Hello";
4. //ourString是一个bound属性
5. private PropertyChangeSupport changes=new PropertyChangeSupport(this);
6. /*Java是纯面向对象的语言，如果要使用某种方法则必须指明是要使用哪个对象的方法，在下面的程序中要进行点火事件的操作，这种操作所使用的方法是在PropertyChangeSupport类中的。所以上面声明并实例化了一个changes对象，在下面将使用changes的firePropertyChange方法来点火ourString的属性改变事件。*/
7. public void setString(string newString)
8. {
9. String oldString=ourString;
10. ourString=newString;
11. //ourString的属性值已发生变化，于是接着点火属性改变事件
12. changes.firePropertyChange("ourString",oldString,newString);
13. }
14. public String getString()
15. {
16. return ourString;
17. }
18. /*以下代码是为开发工具所使用的。 我们不能预知 alden3 将与哪些其它的 Beans 组合成为一个应用，无法预知若 alden3 的 ourString 属性发生变化时有哪些其它的组件与此变化有关，因而 alden3 这个 Beans 要预留出一些接口给开发工具，把其它的 JavaBeans 对象与 alden3 挂接。*/
19. public void addPropertyChangeListener(PropertyChangeLisener l)
20. {
21. changes.addPropertyChangeListener(l);
22. }
23. public void removePropertyChangeListener(PropertyChangeListener l)
24. {
25. changes.removePropertyChangeListener(l);
26. }

通过上面的代码，开发工具调用 changes 的 addPropertyChangeListener 方法，把其他 JavaBean 注册入 ourString 属性的监听者队列 1 中，1 是一个 Vector 数组，可存储任何 Java 对象。

开发工具也可使用 changes 的 removePropertyChangeListener 方法，从 1 中注销指定的对象，使 alden3 的 ourString 属性的改变不再与这个对象有关。当然，当程序员手写代码编制程序时，也可直接调用这两个方法，把其他 Java 对象与 alden3 挂接。

Constrained属性

JavaBean 的 Constrained 属性，是指当这个属性的值要发生变化时，与这个属性已建立了某种连接的其他 Java 对象可否决属性值的改变。constrained 属性的监听者通过拋出 PropertyVetoException 来阻止该属性值的改变。

【例5】下面程序中的 Constrained 属性是 PricelnCents。

1. public class JellyBeans extends Canvas
2. {
3. private PropertyChangeSupport changes=new PropertyChangeSupport(this);
4. private VetoableChangeSupport Vetos=new VetoableChangeSupport(this);
5. //与前述changes相同，可使用VetoableChangeSupport对象的实例Vetos中的方法，在特定条件下来阻止PriceInCents值的改变。
6. public void setPriceInCents(int newPriceInCents) throws PropertyVetoException
7. {
8. //方法名中throws PropertyVetoException的作用是当有其它Java对象否决PriceInCents的改变时，要抛出例外。
9. //先保存原来的属性值
10. int oldPriceInCents=ourPriceInCents;
11. //点火属性改变否决事件
12. vetos.fireVetoableChange("priceInCents",new Integer(OldPriceInCents),new Integer(newPriceInCents));
13. /*若有其它对象否决 priceInCents 的改变，则程序抛出例外，不再继续执行下面的两条语句，方法结束。若无其它对象否决 priceInCents 的改变，则在下面的代码中把 ourPriceIncents 赋予新值，并点火属性改变事件*/
14. ourPriceInCents=newPriceInCents;
15. changes.firePropertyChange("priceInCents",new Integer(oldPriceInCents),new Integer(newPriceInCents));
16. }
17. /*与前述 changes 相同，也要为 PriceInCents 属性预留接口，使其它对象可注册入 PriceInCents 否决改变监听者队列中，或把该对象从中注销*/
18. public void addVetoableChangeListener(VetoableChangeListener l)
19. {
20. vetos.addVetoableChangeListener(l);
21. }
22. public void removeVetoableChangeListener(VetoableChangeListener l)
23. {
24. vetos.removeVetoableChangeListener(l);
25. }
26. }

从上面的例子可以看到，一个 Constrained 属性有两种监听者：属性变化监听者和否决属性改变的监听者。否决属性改变的监听者在自己的对象代码中有相应的控制语句，在监听到有 Constrained 属性要发生变化时，在控制语句中判断是否应否决这个属性值的改变。

总之，某个 bean 的 Constrained 属性值可否改变取决于其他的 bean 或者 Java 对象是否允许这种改变。允许与否的条件由其他的 bean 或 Java 对象在自己的类中进行定义。