Facade(外观)模式

/*
 * Copyright (c) 2001, 2005. Steven J. Metsker.
 * 
 * Steve Metsker makes no representations or warranties about
 * the fitness of this software for any particular purpose, 
 * including the implied warranty of merchantability.
 *
 * Please use this software as you wish with the sole
 * restriction that you may not claim that you wrote it.
 */

import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JPanel;
/**
 * This class displays pair of functions in a panel. The functions
 * are x and y functions, parameterized by time. As the panel plots,
 * time goes 0 to 1.
 */
public class PlotPanel extends JPanel {
    private int points;

    private int[] xPoints;
    private int[] yPoints;

    private Function xFunction;
    private Function yFunction;

    /**
     * Create a plot calculated from the provided x and y functions.
     * These functions must be functions of time; time goes 0 to 1
     * as the panel plots.
     */
    public PlotPanel(int nPoint, Function xFunc, Function yFunc) {
        points = nPoint;
        xPoints = new int[points];
        yPoints = new int[points];
        xFunction = xFunc;
        yFunction = yFunc;
        setBackground(Color.WHITE);
    }

    protected void paintComponent(Graphics graphics) {
        double w = getWidth() - 1;
        double h = getHeight() - 1;
      
        for (int i = 0; i < points; i++) {
            double t = ((double) i) / (points - 1);
            xPoints[i] = (int) (xFunction.f(t) * w);
            yPoints[i] = (int) (h * (1 - yFunction.f(t)));
        }

        graphics.drawPolyline(xPoints, yPoints, points);
    }
}

/*
 * Copyright (c) 2001, 2005. Steven J. Metsker.
 * 
 * Steve Metsker makes no representations or warranties about
 * the fitness of this software for any particular purpose, 
 * including the implied warranty of merchantability.
 *
 * Please use this software as you wish with the sole
 * restriction that you may not claim that you wrote it.
 */

import java.awt.Dimension;

import javax.swing.JFrame;

public class ShowFlight {
    /** Show the flight path of a nonexploding aerial shell.
     */
    public static void main(String[] args) {
        PlotPanel p = new PlotPanel(101, new T(), new ShowFlight().new YFunction());
        p.setPreferredSize(new Dimension(300, 200));
        
        JFrame frame = new JFrame("Flight Path for Shell Duds");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
        frame.getContentPane().add(UI.NORMAL.createTitledPanel("Flight Path", p));
        
        frame.pack();
        frame.setVisible(true);
    }

    private class YFunction extends Function {
        public YFunction() {
            super(new Function[] {});
        }

        public double f(double t) {
            // y is 0 at t = 0, 1; y is 1 at t = .5
            return 4 * t * (1 - t);
        }
    }
}

public abstract class Function {
    protected Function[] sources;

    /**
     * Construct a function that decorates the provided source function.
     * 
     * @param f
     *            the source function that this function wraps
     */
    public Function(Function f) {
        this(new Function[] { f });
    }

    /**
     * Construct a function that decorates the provided source functions.
     * 
     * @param sources
     *            the source functions that this function wraps
     */
    public Function(Function[] sources) {
        this.sources = sources;
    }

    /**
     * The function that subclasses must implement -- see the subclases for
     * examples.
     * 
     * @param t
     *            normalized time, a value between 0 and 1
     * @return a function value
     */
    public abstract double f(double t);

    /**
     * @return a textual representation of this function.
     */
    public String toString() {
        String name = this.getClass().toString();
        StringBuffer buf = new StringBuffer(name);
        if (sources.length > 0) {
            buf.append('(');
            for (int i = 0; i < sources.length; i++) {
                if (i > 0)
                    buf.append(", ");
                buf.append(sources[i]);
            }
            buf.append(')');
        }
        return buf.toString();
    }
}

public class T extends Function {
    /**
     * Construct the identity function that returns the value of t.
     */
    public T() {
        super(new Function[] {});
    }

    /**
     * @return the current value of t.
     * @param t
     *            time
     */
    public double f(double t) {
        return t;
    }
}

import java.awt.*;

import javax.swing.*;
import javax.swing.border.BevelBorder;
import javax.swing.border.TitledBorder;

/**
 * User interface utilities.
 */

public class UI {
	protected Font font = new Font("Book Antiqua", Font.PLAIN, 18);

	public static final int STANDARD_PAD = 10;

	public static final UI NORMAL = new UI();

	/**
	 * @return a standard font that subclasses can override
	 */
	public Font getFont() {
		return font;
	}

	/**
	 * @return a standard padding amount that subclasses can override
	 */
	public int getPad() {
		return STANDARD_PAD;
	}

    /**
     * @return a standard button
     */
    public JButton createButton() {
        JButton button = new JButton();
        button.setSize(128, 128);
        button.setFont(getFont());
        button.setVerticalTextPosition(SwingConstants.BOTTOM);
        button.setHorizontalTextPosition(SwingConstants.CENTER);
        return button;
    }

    /**
	 * @return a standard OK! (or affirmation) button
	 */
	public JButton createButtonOk() {
		JButton button = createButton();
		button.setIcon(getIcon("images/rocket-large.gif"));
		button.setText("Ok!");
		return button;
	}

	/**
	 * @return a standard Cancel! (or negation) button
	 */
	public JButton createButtonCancel() {
		JButton button = createButton();
		button.setIcon(getIcon("images/rocket-large-down.gif"));
		button.setText("Cancel!");
		return button;
	}

	/**
	 * @return a panel with a standard amount of padding around any controls
	 */
	public JPanel createPaddedPanel() {
		JPanel panel = new JPanel();
		panel.setBorder(
            BorderFactory.createEmptyBorder(getPad(), getPad(), getPad(), getPad()));
		return panel;
	}

	/**
	 * @return a panel with a standard amount of padding around any particular
	 *         control
	 * @param c
	 *            the control
	 */
	public JPanel createPaddedPanel(Component c) {
		JPanel panel = createPaddedPanel();
		panel.add(c);
		return panel;
	}
    
    public static Icon getIcon(String imageName) {
        return new ImageIcon(imageName);
    }

    public JList createList(Object[] contents) {
        JList result = new JList(contents);
        result.setFont(getFont()); 
        result.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
        return result;
    }
    
    /**
     * @return a titled border with the given title.
     */
    public TitledBorder createTitledBorder(String title) {
        TitledBorder border = BorderFactory.createTitledBorder(
            BorderFactory.createBevelBorder(BevelBorder.RAISED), 
            title,
            TitledBorder.LEFT, 
            TitledBorder.TOP);
        border.setTitleColor(Color.black);
        border.setTitleFont(getFont());
        return border;
    }
    
    /**
     * @return a new panel that wraps a titled border around a given panel.
     */
    public JPanel createTitledPanel(String title, JPanel in) {
        JPanel out = new JPanel();
        out.add(in);
        out.setBorder(createTitledBorder(title));
        return out;
    }
}

通常，我们应该把子系统中的类重构为一个个目的明确的类。这样做可以使代码更加容易维护，但这样也会让子系统用户不知从何处开始。为了便于子系统用户的使用，我们可以在子系统中顺带提供一些示例类或者外观类。

Facade(外观)模式

原文：http://blog.csdn.net/lindonglian/article/details/46292489