在进行排序的时候，排序修饰者并没有改变它修饰的真实对象，而是通过了一个数组来保存列的位置。当其他对象向它请求特定行和列的数据的时候，它通过行的值作为数组的索引并返回数组中相应位置的值。通过这种方式，排序修饰者在不改变表结构的前题下将排序功能叠加到了表结构上。TableSortDecorator同时还实现了TableModelListener接口并将自己注册为一个监听者。当真实对象，也就是原有的表对象发出一个表更改的事件后，修饰者将在数组中重新对行的位置进行排列，相应的代码在tableChanged（）方法中。还需要注意的是TableSortDecorator有11个公有方法，其中9个方法会被传递给真实对象。
　　对排序修饰者的进一步改进
　　上面的排序修饰者可以给任何的表模型增加排序功能。但是TableSortDecorator类的代码重用性能并不是很好，这是因为它实现了两个不应该由它实现的功能：第一个功能是将方法调用传递给真实对象，这是由于其他的表模型修饰者也会使用完全相同的代码，由于该功能的普适性，它应该被移到类层次中较高的层次上；第二个是排序，在上面的例子中使用的是冒泡排序法，而排序的算法在类层次中是非常特殊的部分，因此需要被移到较低的层次上。图8展示了根据上面两点意见修改后的排序修饰者的类图。
　　图8 经过修改后的排序修饰者的类图
　　经过修改后TableSortDecorator被分解成三个部分：
　　· TableModelDecorator：实现了TableModel接口，将方法调用传递给真实对象。
　　· TableSortDecorator：继承了TableModelDecorator接口，增加了一个抽象方法sort（）。
　　· TableBubbleSortDecorator：继承了TableSortDecorator接口并实现了冒泡排序。
　　通过分解TableSortDecorator，我们可以重用将方法调用传递给真实对象的代码。将TableModelDecorator中的代码封装起来使我们很容易对表模型添加其它的修饰者，例如过滤修饰者（TableFilterDecorator，）。抽象类TableSortDecorator将sort（）方法的实现推迟到该类的子类中实现，因此可以在子类中实现不同的排序算法。下面是这些类的代码：
　　// TableModelDecorator.java
　　import javax.swing.table.TableModel;
　　import javax.swing.event.TableModelListener;
　　// TableModelDecorator继承了TableModelListener。
　　// 当表模型发生变化的时候，会调用tableChanged()方法。
　　// 该方法在抽象类中没有实现，而是在继承该类的子类中实现。
　　public abstract class TableModelDecorator
　　implements TableModel, TableModelListener {
　　public TableModelDecorator(TableModel model) {
　　this.realModel = model;
　　realModel.addTableModelListener(this);
　　}： [NextPage]

　　// 下面的九个方法定义在TableModel接口中。
　　public void addTableModelListener(TableModelListener l) {
　　realModel.addTableModelListener(l);
　　}
　　public Class getColumnClass(int columnIndex) {
　　return realModel.getColumnClass(columnIndex);
　　}
　　public int getColumnCount() {
　　return realModel.getColumnCount();
　　}
　　public String getColumnName(int columnIndex) {
　　return realModel.getColumnName(columnIndex);
　　}
　　public int getRowCount() {
　　return realModel.getRowCount();
　　}
　　public Object getValueAt(int rowIndex, int columnIndex) {
　　return realModel.getValueAt(rowIndex, columnIndex);
　　}
　　public boolean isCellEditable(int rowIndex, int columnIndex) {
　　return realModel.isCellEditable(rowIndex, columnIndex);
　　}
　　public void removeTableModelListener(TableModelListener l) {
　　realModel.removeTableModelListener(l);
　　}
　　public void setValueAt(Object aValue,
　　int rowIndex, int columnIndex) {
　　realModel.setValueAt(aValue, rowIndex, columnIndex);
　　}
　　// getRealModel方法被子类用来引用真实对象。
　　protected TableModel getRealModel() {
　　return realModel;
　　}
　　private TableModel realModel; // 真实对象
　　}
　　注意到TableModelDecorator的构造函数仅仅实现了传递方法调用的功能。
　　// TableSortDecorator.java
　　import javax.swing.table.TableModel;
　　public abstract class TableSortDecorator extends
　　TableModelDecorator {
　　// 实现TableSortDecorator接口的类必须实现sort（）方法。除此之外，
　　// 还需要实现TableModelDecorator中的tableChanged（）方法。
　　abstract public void sort(int column);
　　public TableSortDecorator(TableModel realModel) {
　　super(realModel);
　　}
　　}
　　// TableBubbleSortDecorator.java
　　import javax.swing.table.TableModel;
　　import javax.swing.event.TableModelEvent;
　　public class TableBubbleSortDecorator extends TableSortDecorator {
　　// 该类的构造函数需要一个TableModel的实例作为参数。
　　// 该类为表模型增加了排序功能。
　　public TableBubbleSortDecorator(TableModel model) {
　　super(model);
　　allocate();
　　}
　　// tableChanged（）方法是被定义在TableModelListener接口中的。
　　// TableModelDecorator继承了TableModelListener接口。
　　public void tableChanged(TableModelEvent e) {
　　allocate();
　　}
　　// 两个TableModel中的方法被重载。
　　public Object getValueAt(int row, int column) {
　　return getRealModel().getValueAt(indexes[row], column);
　　}
　　public void setValueAt(Object aValue, int row, int column) {
　　getRealModel().setValueAt(aValue, indexes[row], column);
　　}： [NextPage]

　　// 简单的冒泡排序
　　public void sort(int column) {
　　int rowCount = getRowCount();
　　for(int i=0; i < rowCount; i++) {
　　for(int j = i+1; j < rowCount; j++) {
　　if(compare(indexes[i], indexes[j], column) < 0) {
　　swap(i,j);
　　}
　　}
　　}
　　}
　　private void swap(int i, int j) {
　　int tmp = indexes[i];
　　indexes[i] = indexes[j];
　　indexes[j] = tmp;
　　}
　　private int compare(int i, int j, int column) {
　　TableModel realModel = getRealModel();
　　Object io = realModel.getValueAt(i,column);
　　Object jo = realModel.getValueAt(j,column);
　　int c = jo.toString().compareTo(io.toString());
　　return (c < 0) ? -1 : ((c > 0) ? 1 : 0);
　　}
　　private void allocate() {
　　indexes = new int[getRowCount()];
　　for(int i=0; i < indexes.length; ++i) {
　　indexes[i] = i;
　　}
　　}
　　private int indexes[];
　　}
　　修饰模型的应用范围
　　在Java中，开发人员可以通过继承向对象中添加功能。基类可以实现公共功能，子类实现特殊的功能。例如在上面的例子中，开发人员可以实现SortModel和FilterModel类来替代排序和过滤修饰者。但是修饰模型比继承更加灵活，这是因为修饰者和被修饰者之间的关系可以在运行时被改变，而子类和基类之间的关系在编译时就被固定下来。
　　通常在下面的情况下会使用到修饰模型：
　　· 如果开发人员需要将不同的简单功能在运行时组合在一起。如果通过继承的方法将对功能不同的组合方法生成大量的子类，而使用修饰模式可以减少代码量。
　　· 如果开发人员在运行时需要透明地向某个对象添加功能。透明在这里指需要增加功能的对象不能够被修改。
　　· 如果开发人员需要限制使用一个对象的公共方法。当程序调用被限制的方法时，修饰者可以根据实际情况决定传递方法调用还是抛出异常。