|
策略模式（Strategy Pattern）中体现了两个非常基本的面向对象设计的基本原则：封装变化的概念；编程中使用接口，而不是对接口实现。策略模式的定义如下：
定义一组算法，将每个算法都封装起来，并且使它们之间可以互换。策略模式使这些算法在客户端调用它们的时候能够互不影响地变化。
策略模式使开发人员能够开发出由许多可替换的部分组成的软件，并且各个部分之间是弱连接的关系。弱连接的特性使软件具有更强的可扩展性，易于维护；更重要的是，它大大提高了软件的可重用性。
为了说明策略模式，我们将首先讨论一下在Swing中是如何利用策略模式来绘制组件边界的，然后讨论在Swing中使用策略模式带来的好处，最后讨论如何在软件中实现策略模式。
Swing边框
对所有的Swing组件，例如按钮、列表单等，都还可以绘制边框。在Swing中提供了各种边框类型，例如bevel、etched、line、titled等。Swing组件的边框是通过JComponent类来绘制的，该类是所有Swing组件的基类，实现了所有Swing组件公共的功能。在JComponent中有一个paintBorder()方法，该方法为组件绘制边框。Swing的开发人员可以象下面的例子中所示那样来绘制边框：
// 一段实现paintBorder（）方法代码
protected void paintBorder(Graphics g) {
switch(getBorderType()) {
case LINE_BORDER: paintLineBorder(g);
break;
case ETCHED_BORDER: paintEtchedBorder(g);
break;
case TITLED_BORDER: paintTitledBorder(g);
break;
...
}
}
|
请注意上面的代码只是一种假设，事实上Swing的开发人员并没有这样实现paintBorder（）方法。在上面的代码中，在JComponent中绘制边框的代码被直接写入了paintBorder（）方法中，这意味着JComponent和绘制边框的功能被紧密地结合在了一起。很自然地大家会联想到如果需要实现一种新的边框类型，开发人员必须修改至少三处代码：首先增加一个常量，该常量代表新添加的边框的类型值；其次需要在Switch语句中增加一个case语句；最后开发人员需要实现paintXXXBorder（）方法，其中XXX代表新边框的名称。
很显然要扩展上面paintBorder()方法的功能是一件很困难的事情，不仅仅是因为开发人员需要增加一种新的边框类型，更麻烦的是开发人员很难修改JComponent类。JComponent类已经被编译到了Swing的开发工具中，如果开发人员想修改它的话，必须获得Swing的源代码，修改后重新编译Swing。同时在用户的计算机上与需要使用新编译的Swing API。另外所有的Swing组件都可以使用开发人员新添加的边框类型。有可能开发人员只希望新的边框被某些组件使用，但是现在开发人员无法对使用该边框的组件进行限制。
开发人员有更好的实现方法吗？答案就是策略模式。通过策略模式，可以将JComponent和实现绘制边框的代码分离开来，这样开发人员在增加或修改绘制边框的代码使就不需要修改JComponent的代码。通过应用策略模式，开发人员将变化的概念（在这个例子中是绘制边框）封装起来，然后通过一个Border接口，使程序能够重用绘制边框的功能。下面让我们来看JComponent是如何利用策略模式来实现绘制边框的功能的：
// Swing中paintBorder()方法的源代码
protected void paintBorder(Graphics g) {
Border border = getBorder();
if (border != null) {
border.paintBorder(this, g, 0, 0, getWidth(), getHeight());
}
}
|
上面的paintBorder()方法通过一个border对象绘制了组件的边框。这样border对象替代了前一个例子中的JComponent封装了边框绘制的功能。我们还应该注意到JComponent将一个对自己的引用传递给了Border.paintBorder（）方法，这是因为Border的实例必须知道它对应的组件的信息，这种方式通常被称为委托。通过这种方式，一个对象可以将功能委托给另一个对象来实现。
在JComponent类中引用了一个Border对象，通过JComponent.getBorder（）方法可以获得该Border对象。下面的代码演示了如何设定和获得Border对象：
...
private Border border;
...
public void setBorder(Border border) {
Border oldBorder = this.border;
this.border = border;
firePropertyChange("border", oldBorder, border);
if (border != oldBorder) {
if (border == null || oldBorder == null || !(border.getBorderInsets(this).
equals(oldBorder.getBorderInsets(this)))) {
revalidate();
}
repaint();
}
}
...
public Border getBorder() {
return border;
}
|
当开发人员通过JComponent.setBorder（）方法设定了一个组件的边框后，JComponent类发出一个属性更新事件。如果新的边框和以前的边框不同的话，setBorder（）方法就重新绘制边框。getBorder（）方法仅仅返回对Border对象的引用。图1显示了Border的类结构图：
图1 Border的类结构图
通过类结构图我们可以看到，JComponent类中保存了一个对Border对象的引用。由于Border是一个接口，Swing组件可以使用任何一个实现了Border接口的类。
现在我们已经知道了JComponent是如何利用策略模式来绘制组件的边框的。下面让我们通过实现一个新的边框类型来测试一下它的可扩展性。
实现一个新的边框类型
图2中是一个有三个JPanel对象的小程序，每个JPanel对象有各自不同的边框，每个边框对应一个HandleBorder实例。
图2 新的边框类型
// HandleBorder.java
import java.awt.*;
import javax.swing.*;
import javax.swing.border.*;
public class HandleBorder extends AbstractBorder {
protected Color lineColor;
protected int thick;
public HandleBorder() {
this(Color.black, 6);
}
public HandleBorder(Color lineColor, int thick) {
this.lineColor = lineColor;
this.thick = thick;
}
public void paintBorder(Component component,
Graphics g, int x, int y, int w, int h) {
Graphics copy = g.create();
if(copy != null) {
try {
copy.translate(x,y);
paintRectangle(component,copy,w,h);
paintHandles(component,copy,w,h);
}
finally {
copy.dispose();
}
}
}
public Insets getBorderInsets() {
return new Insets(thick,thick,thick,thick);
}
protected void paintRectangle(Component c, Graphics g,
int w, int h) {
g.setColor(lineColor);
g.drawRect(thick/2,thick/2,w-thick-1,h-thick-1);
}
protected void paintHandles(Component c, Graphics g,
int w, int h) {
g.setColor(lineColor);
g.fillRect(0,0,thick,thick);
g.fillRect(w-thick,0,thick,thick);
g.fillRect(0,h-thick,thick,thick);
g.fillRect(w-thick,h-thick,thick,thick);
g.fillRect(w/2-thick/2,0,thick,thick);
g.fillRect(0,h/2-thick/2,thick,thick);
g.fillRect(w/2-thick/2,h-thick,thick,thick);
g.fillRect(w-thick,h/2-thick/2,thick,thick);
}
}
|
HandleBorder类继承了javax.swing.border.AbstractBorder类并重写了paintBorder（）和getBorderInsets（）。HandleBorder是如何实现的其实并不重要，重要的是由于Swing使用了策略模型，开发人员能够很方便地增加新的边框类型。下面的代码显示了如何使用HandleBorder类。在这个例子中创建了三个JPanel对象，并对每个JPanel对象设定一个HandleBorder实例作为边框。
// Test.java
import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;
import java.awt.event.*;
public class Test extends JFrame {
public static void main(String[] args) {
JFrame frame = new Test();
frame.setBounds(100, 100, 500, 200);
frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame.show();
}
public Test() {
super("实现一个新的边框类型");
Container contentPane = getContentPane();
JPanel[] panels = { new JPanel(),
new JPanel(), new JPanel() };
Border[] borders = { new HandleBorder(),
new HandleBorder(Color.red, 8),
new HandleBorder(Color.blue, 10) };
contentPane.setLayout(
new FlowLayout(FlowLayout.CENTER,20,20));
for(int i=0; i < panels.length; ++i) {
panels[i].setPreferredSize(new Dimension(100,100));
panels[i].setBorder(borders[i]);
contentPane.add(panels[i]);
}
}
}
|
还记得在上面的例子中曾提到在有些情况下，对组件的引用会作为参数传递给Border.paintBorder（）方法。虽然上面的HandleBorder类没有保存对组件的引用，但是有些情况下Border接口的实现类会使用到对组件的引用并从中获得关于组件的信息。例如在EtchedBorder中，paintBorder（）方法通过对组件的引用获得它对应的组件的阴影和高光色：
// 下面的代码截取自javax.swing.border.EtchedBorder
public void paintBorder(Component component, Graphics g, int x, int y,
int width, int height) {
int w = width;
int h = height;
g.translate(x, y);
g.setColor(etchType == LOWERED? getShadowColor(component) :
getHighlightColor(component));
g.drawRect(0, 0, w-2, h-2);
g.setColor(etchType == LOWERED? getHighlightColor(component) :
getShadowColor(component));
g.drawLine(1, h-3, 1, 1);
g.drawLine(1, 1, w-3, 1);
g.drawLine(0, h-1, w-1, h-1);
g.drawLine(w-1, h-1, w-1, 0);
g.translate(-x, -y);
}
|
如何实现策略模型
通过以下步骤，开发人员可以很容易地在软件中实现策略模型：
1．对策略对象定义一个公共接口。
2．编写策略类，该类实现了上面的公共接口。
3．在使用策略对象的类中保存一个对策略对象的引用。
4．在使用策略对象的类中，实现对策略对象的set和get方法。
在Swing边框的例子中，公共接口是javax.swing.Border。策略类是LineBorder、EtchedBorder、HandleBorder等。而使用策略对象的类是JComponent。
|