Step By Step(Java 2D图形篇<一>)

    本篇将主要为您介绍Java的2D图形编程技术，然而在示例代码中还将会涉及一些简单的Swing知识，我们会尽可能的将2D中的方法进行归类和抽取，以便使您的关注点始终保持在Java2D上。该篇还会和本系列中其他篇章的风格保持一致，只是介绍必要的关键概念，更多的技术点是通过已经良好分类的有代表性的示例代码来为您展示和说明。
    1.    形状绘制：
    在Java 2D中提供了下面几个基本形状：
    1)    Line2D
    2)    Rectangle2D
    3)    RoundRectangle2D
    4)    Ellipse2D
    5)    Arc2D
    6)    QuadCurve2D
    7)    CubicCurve2D
    8)    GeneralPath
    上面列出的对象均实现了Shape接口，因此可以作为Graphics2D类的draw方法的参数来绘制不同的图形。在实际的应用中，我们都是通过构造他们的内部类(均继承自对应的外部类)并返回该外部类的方式获取一个形状对象的实例，如:
    Rectangle2D floatRect = new Rectangle2D.Float(1F,10F,2.5F,2.5F);
    Rectangle2D doubleRect = new Rectangle2D.Double(1,10,2.5,2.5);
    1)    绘制Line2D和Rectangle2D：
    这两个形状是所有形状中最为基本也最容易理解的两个形状，那么我们就从这里下手小试牛刀。

    public class MyTest extends JPanel {
        public static void main(String args[]) {
            JFrame f = new JFrame("Rectangle And Line");
            f.setSize(360, 300);
            f.add(new MyTest());
            f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            f.setLocationRelativeTo(null);
            f.setVisible(true);
        }
        public MyTest() {
            setBackground(Color.white);
            setForeground(Color.white);
        }
        //在Swing中，所有的自绘操作都是通过重载各个组件的paint和paintComponent方法
        //来实现的，如果组件部分被遮盖或整个被隐藏，在重新bringToFront的时候，repaint
        //方法会被Swing的EDT(Event Dispatching Thread)调用，从而导致该方法被调用。
        @Override
        public void paintComponent(Graphics g) {
            super.paintComponent(g);
            paintRectangle(g);
            paintLine(g);
        }
        //绘制一条直线
        private void paintLine(Graphics g) {
            Graphics2D g2 = (Graphics2D) g;
            g2.setPaint(Color.gray);
            int x = 100;
            int y = 75;
            g2.draw(new Line2D.Double(x, y, 250, 195));
        }
        //绘制一个矩形边框，填充一个矩形
        private void paintRectangle(Graphics g) {
            Graphics2D g2d = (Graphics2D) g;
            g2d.setColor(new Color(212, 212, 212));
            g2d.draw(new Rectangle2D.Float(10, 15, 90, 60));
            g2d.setColor(new Color(31, 21, 1));
            g2d.fill(new Rectangle2D.Float(250, 195, 90, 60));
        }
    }

    对于上例paintRectangle方法中的Graphics2D.draw和Graphics2D.fill方法，可以分别替换为g2d.drawRect(10,15,90,60) 和 g2d.fillRect(250,195,90,60)，他们的结果是完全一致的。然而在《Java极富客户端效果开发》中，推荐使用后者，原因是通用的draw方法会由于在绘制前需要做一些和类型判断相关的工作，因此会影响效率。而后者由于直接调用和形状相关的方法，如drawRect和fillRect，这样在绘制时已经非常清楚当前的形状为矩形，见如下比较代码：

    private void paintTest(Graphics g) {
        final int LINE_X = 100;
        final int RECT_X = 200;
        final int TEXT_X = 250;
        final int BAD_Y = 60;
        final int GOOD_Y = 160;
        final int ITERATIONS = 1000;
        Graphics2D g2d = (Graphics2D) g;
        long startTime, endTime, totalTime;
        g.setColor(Color.WHITE);
        g.fillRect(0, 0, getWidth(), getHeight());
        g.setColor(Color.BLACK);

        g.drawString("Bad vs. Good Primitive Rendering", 50, 20);
        g.drawString("(" + ITERATIONS + " iterations)", 100, 35);
        g.drawString("Bad: ", 10, BAD_Y + 30);
        g.drawString("Good: ", 10, GOOD_Y + 30);
        // Bad line
        Shape line = new Line2D.Double(LINE_X, BAD_Y, LINE_X + 50, BAD_Y + 50);
        startTime = System.nanoTime();
        for (int i = 0; i < ITERATIONS; ++i) {
            g2d.draw(line);
        }
        endTime = System.nanoTime();
        totalTime = (endTime - startTime) / 1000000;
        System.out.println("bad line = " + totalTime);
        g.drawString(totalTime + " ms", LINE_X, BAD_Y + 70);

        // Good line
        startTime = System.nanoTime();
        for (int i = 0; i < ITERATIONS; ++i) {
            g.drawLine(LINE_X, GOOD_Y, LINE_X + 50, GOOD_Y + 50);
        }
        endTime = System.nanoTime();
        totalTime = (endTime - startTime) / 1000000;
        System.out.println("good line = " + totalTime);
        g.drawString(totalTime + " ms", LINE_X, GOOD_Y + 70);
        // Bad rect
        Shape rect = new Rectangle(RECT_X, BAD_Y, 50, 50);
        startTime = System.nanoTime();
        for (int i = 0; i < ITERATIONS; ++i) {
            g2d.fill(rect);
        }
        endTime = System.nanoTime();
        totalTime = (endTime - startTime) / 1000000;
        System.out.println("bad rect = " + totalTime);
        g.drawString(totalTime + " ms", RECT_X, BAD_Y + 70);

        // Good rect
        startTime = System.nanoTime();
        for (int i = 0; i < ITERATIONS; ++i) {
            g.fillRect(RECT_X, GOOD_Y, 50, 50);
        }
        endTime = System.nanoTime();
        totalTime = (endTime - startTime) / 1000000;
        System.out.println("good rect = " + totalTime);
        g.drawString(totalTime + " ms", RECT_X, GOOD_Y + 70);
    }

    在组件的paintComponent方法中直接调用该方法可以看到运行结果。
    2)    绘制Ellipse2D和RoundRectangle2D：

    public class MyTest extends JPanel {
        public static void main(String args[]) {
            JFrame f = new JFrame("Ellipse and RoundRectangle");
            f.setSize(360, 300);
            f.add(new MyTest());
            f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            f.setLocationRelativeTo(null);
            f.setVisible(true);
        }
        public MyTest() {
            setBackground(Color.white);
            setForeground(Color.white);
        }
        @Override
        public void paintComponent(Graphics g) {
            super.paintComponent(g);
            g.setColor(Color.red);
            paintOval(g);
            paintRoundRectangle(g);
        }
        //绘制一个椭圆
        private void paintOval(Graphics g) {
            Graphics2D g2 = (Graphics2D)g;
            g2.draw(new Ellipse2D.Float(5, 15, 50, 75));   
        }
        //绘制一个圆形边角的矩形
        private void paintRoundRectangle(Graphics g) {
            Graphics2D g2 = (Graphics2D)g;
            RoundRectangle2D rr = new RoundRectangle2D.Float(100, 10, 80, 30, 15, 15);
            //获取当前的Color属性并保存到临时变量中，更新该属性，在使用完之后，
            //用该临时变量恢复到原有的Color属性，这种方式是比较通用的一种技巧。
            //在很多其他的类库中也会经常被用到。
            Color oldColor = g2.getColor();
            g2.setColor(Color.blue);
            g2.fill(rr);
            g2.setColor(oldColor);
        }
    }

    3)    绘制园(drawOval)和弧形：
    之前的两个例子都是通过调用Graphics2D.draw方法绘制Shape接口的实现类，下面的示例将使用不同的方法来绘制另外两个基本形状--圆形和弧形。

    public class MyTest extends JPanel {
        public static void main(String args[]) {
            JFrame f = new JFrame("Circle");
            f.setSize(360, 300);
            f.add(new MyTest());
            f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            f.setLocationRelativeTo(null);
            f.setVisible(true);
        }
        public MyTest() {
            setBackground(Color.white);
            setForeground(Color.white);
        }
        @Override
        public void paintComponent(Graphics g) {
            super.paintComponent(g);
            g.setColor(Color.red);
            paintCircle(g);
            paintArc(g);
        }
        //画圆
        private void paintCircle(Graphics g) {
            Graphics2D g2 = (Graphics2D)g;
            //没有提供drawCircle方法，通过将椭圆的width和heigh参数设置为等长，
            //即可获得一个圆形。
            g2.drawOval(5, 15, 75, 75);   
        }
        private void paintArc(Graphics g) {
            Graphics2D g2 = (Graphics2D) g;
            int x = 50;
            int y = 70;
            g2.setStroke(new BasicStroke(8.0f));
            //缺省填充为饼图
            g2.fillArc(x, y, 200, 200, 90, 135);
            //还可以通过Arc2D构造函数中的最后一个参数来定义不同的填充类型
            Color oldColor = g.getColor();
            g.setColor(Color.blue);
            g2.fill(new Arc2D.Double(200, 30, 200, 200, 90, 135,Arc2D.CHORD));
            g.setColor(oldColor);
        }
    }

    4)    绘制多边形：

    public class MyTest extends JPanel {
        public static void main(String args[]) {
            JFrame f = new JFrame("Polygon");
            f.setSize(360, 300);
            f.add(new MyTest());
            f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            f.setLocationRelativeTo(null);
            f.setVisible(true);
        }
        public MyTest() {
            setBackground(Color.white);
            setForeground(Color.white);
        }
        @Override
        public void paintComponent(Graphics g) {
            super.paintComponent(g);
            g.setColor(Color.red);
            paintPolygon(g);
            paintGeneralPath(g);
        }
        // 绘制多边形
        private void paintPolygon(Graphics g) {
            Polygon p = new Polygon();
            for (int i = 0; i < 5; i++) {
                p.addPoint((int) (100 + 50 * Math.cos(i * 2 * Math.PI / 5)),
                        (int) (100 + 50 * Math.sin(i * 2 * Math.PI / 5)));
            }
            g.drawPolygon(p);
        }
        //通过GeneralPath的方式绘制多边形
        private void paintGeneralPath(Graphics g) {
            Random generator = new Random();
            Point2D[] points = new Point2D[6];
            for (int i = 0; i < 6; i++) {
                double x =  generator.nextDouble() * getWidth();
                double y =  generator.nextDouble() * getHeight();
                points[i] = new Point2D.Double(x, y);
            }
    
            g.setColor(Color.red);
            Graphics2D g2 = (Graphics2D) g;
            GeneralPath s = new GeneralPath();
            s.moveTo((float) points[0].getX(), (float) points[0].getY());
            for (int i = 1; i < points.length; i++)
              s.lineTo((float) points[i].getX(), (float) points[i].getY());
            s.closePath();
            g2.draw(s);
        }
    }

    5)    绘制Rectangle的3D边框：
    可以想象一下Swing中的JButton控件，在缺省属性下，其显示效果为有凸出感的Rectangle。该效果在技术上的实现还是比较简单和通用的，见下例：

    public class MyTest extends JPanel {
        public static void main(String args[]) {
            JFrame f = new JFrame("3D Rect");
            f.setSize(360, 300);
            f.add(new MyTest());
            f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            f.setLocationRelativeTo(null);
            f.setVisible(true);
        }
        public MyTest() {
            setBackground(Color.white);
            setForeground(Color.white);
        }
        @Override
        public void paintComponent(Graphics g) {
            super.paintComponent(g);
            g.setColor(Color.red);
            paint3DRect(g);
        }
        // 绘制和填充3D效果的Rectangle边框
        private void paint3DRect(Graphics g) {
            int thickness = 4;
            //draw3DRect和fill3DRect函数的最后一个参数决定绘制的
            //3D效果是raised还是sunk，我们常见的button控件的3D效
            //果是raised。如果最后一个参数是true，则为raised。
            g.fill3DRect(200, 10, 80, 30, true);
            for (int i = 1; i <= thickness; i++)
                g.draw3DRect(200 - i, 10 - i, 80 + 2 * i - 1, 30 + 2 * i - 1, true);
    
            g.fill3DRect(200, 50, 80, 30, false);
            for (int i = 1; i <= thickness; i++)
                g.draw3DRect(200 - i, 50 - i, 80 + 2 * i - 1, 30 + 2 * i - 1, true);
        }
    }

    6)    绘制二次曲线和三次曲线：
    该示例代码中，左侧显示的是二次曲线，右侧显示的是三次曲线，中间用黑色的分隔线分隔。

    public class MyTest extends JPanel {
        public static void main(String args[]) {
            JFrame f = new JFrame("Curve Demo");
            f.setSize(360, 300);
            f.add(new MyTest());
            f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            f.setLocationRelativeTo(null);
            f.setVisible(true);
        }
        public MyTest() {
            setBackground(Color.white);
            setForeground(Color.white);
        }
        @Override
        public void paintComponent(Graphics g) {
            super.paintComponent(g);
            paintQuadCurve(g);
            //画分割线，其中左边是二次曲线，右边是三次曲线
            int x = getWidth() / 2;
            g.setColor(Color.BLACK);
            g.drawLine(x, 0, x, getHeight());
            paintCubicCurve(g);
        }
        // 绘制二次曲线
        private void paintQuadCurve(Graphics g) {
            Random generator = new Random();
            Point2D[] points = new Point2D[3];
            //二次曲线的x坐标均小于getWidth()/2，因此可以显示在JPanel左侧。
            for (int i = 0; i < 3; i++) {
                double x = generator.nextDouble() * getWidth() / 2;
                double y = generator.nextDouble() * getHeight();
                points[i] = new Point2D.Double(x, y);
            }
            g.setColor(Color.red);
            Graphics2D g2 = (Graphics2D) g;
            for (int i = 0; i < points.length; i++) {
                double x = points[i].getX() - 10 / 2;
                double y = points[i].getY() - 10 / 2;
                g2.fill(new Rectangle2D.Double(x, y, 10, 10));
            }
            Shape s = new QuadCurve2D.Double(points[0].getX(), points[0].getY(),
                    points[1].getX(), points[1].getY(), points[2].getX(),
                    points[2].getY());
            g2.draw(s);
        }
    
        // 绘制三次曲线
        private void paintCubicCurve(Graphics g) {
            Random generator = new Random();
            Point2D[] points = new Point2D[4];
            //三次曲线的x坐标均大于getWidth()/2，因此可以显示在JPanel右侧。
            for (int i = 0; i < 4; i++) {
                double x = generator.nextDouble() * getWidth() / 2 + getWidth() / 2;
                double y = generator.nextDouble() * getHeight();
                points[i] = new Point2D.Double(x, y);
            }
            g.setColor(Color.red);
            Graphics2D g2 = (Graphics2D) g;
            for (int i = 0; i < points.length; i++) {
                double x = points[i].getX() - 10 / 2;
                double y = points[i].getY() - 10 / 2;
                g2.fill(new Rectangle2D.Double(x, y, 10, 10));
            }
            Shape s = new CubicCurve2D.Double(points[0].getX(), points[0].getY(),
                    points[1].getX(), points[1].getY(), points[2].getX(),
                    points[2].getY(), points[3].getX(), points[3].getY());
            g2.draw(s);
        }
    }

    2.    区域(Area)：
    Java 2D支持4中几何图形区域计算方式，分别是add、substract、intersect和exclusiveOr。
    add：组合区域包含了所有位于第一个区域或第二个区域内的点；
    substract：组合区域包含了所有位于第一个区域内的点，但是不包括任何位于第二个区域内的点；
    intersect：组合区域既包含了所有位于第一个区域内的点，又包含了所有位于第二个区域内的点；
    exclusiveOr：组合区域包含了所有位于第一个区域内，或者是位于第二个区域内的所有点，但是这些点不能同时位于两个区域内。
    下面的示例代码绘制了两个区域的四种不同组合方式。

    public class MyTest extends JPanel {
        public static void main(String args[]) {
            JFrame f = new JFrame("Area Demo");
            f.setSize(360, 300);
            f.add(new MyTest());
            f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            f.setLocationRelativeTo(null);
            f.setVisible(true);
        }
        public MyTest() {
            setBackground(Color.white);
            setForeground(Color.white);
        }
        @Override
        public void paintComponent(Graphics g) {
            super.paintComponent(g);
            //横向和纵向各画一条分隔线，将JPanel的区域划分4个等份。
            //然后在4个区间中画出四种不同的Area组合方式
            int x = getWidth() / 2;
            int y = getHeight() / 2;
            g.setColor(Color.black);
            g.drawLine(x, 0, x, getHeight());
            g.drawLine(0, y, getWidth(), y);
            paintArea(g);
        }
        private void paintArea(Graphics g) {
            //1. 以add的方式组合两个Area，并绘制在JPanel的左上角
            Shape sOne = new Ellipse2D.Double(40, 20, 80, 80);
            Shape sTwo = new Rectangle2D.Double(60, 40, 80, 80);
            Area areaOne = new Area(sOne);
            Area areaTwo = new Area(sTwo);
            areaOne.add(areaTwo);
            Graphics2D g2 = (Graphics2D)g;
            g2.setPaint(Color.orange);
            g2.fill(areaOne);
            g2.setPaint(Color.black);
            g2.draw(areaOne);
            //2. 以subtract的方式组合两个Area，并绘制在JPanel的右上角
            Shape sThree = new Ellipse2D.Double(40 + getWidth()/2, 20, 80, 80);
            Shape sFour = new Rectangle2D.Double(60 + getWidth()/2, 40, 80, 80);
            Area areaThree = new Area(sThree);
            Area areaFour = new Area(sFour);
            areaThree.subtract(areaFour);
            g2.setPaint(Color.orange);
            g2.fill(areaThree);
            g2.setPaint(Color.black);
            g2.draw(areaThree);
            //3. 以intersect的方式组合两个Area，并绘制在JPanel的左下角
            Shape sFive = new Ellipse2D.Double(40, 20 + getHeight()/2, 80, 80);
            Shape sSix = new Rectangle2D.Double(60, 40 + getHeight()/2, 80, 80);
            Area areaFive = new Area(sFive);
            Area areaSix = new Area(sSix);
            areaFive.intersect(areaSix);
            g2.setPaint(Color.orange);
            g2.fill(areaFive);
            g2.setPaint(Color.black);
            g2.draw(areaFive);
            //4. 以exclusiveOr的方式组合两个Area，并绘制在JPanel的右下角
            Shape sSeven = new Ellipse2D.Double(40 + getWidth()/2, 20 + getHeight()/2, 80, 80);
            Shape sEight = new Rectangle2D.Double(60 + getWidth()/2, 40 + getHeight()/2, 80, 80);
            Area areaSeven = new Area(sSeven);
            Area areaEight = new Area(sEight);
            areaSeven.exclusiveOr(areaEight);
            g2.setPaint(Color.orange);
            g2.fill(areaSeven);
            g2.setPaint(Color.black);
            g2.draw(areaSeven);
        }
    }

    3.    笔划(Strokes)：
    Graphics2D类的draw操作通过使用当前选定的笔划来绘制一个形状的边界。在默认情况下，笔划是一条宽度为1像素的实线。可以通过setStroke方法来选定不同的笔划。这里我们可以通过使用Java 2D已经提供的BasicStroke类来帮助我们实现自定义笔划的功能。
    1)    设置笔划的宽度，缺省为一个像素；
    2)    当宽度为多个像素时，需要设置笔划的端头采用何种风格绘制：平头样式、圆头样式、方头样式，如果两条线相交时，采用何种方式的交叉风格：斜连接、园连接和斜肩连接；
    3)    设置虚线笔划的dash模式。
    见以下示例：

    public class MyTest extends JPanel {
        public static void main(String args[]) {
            JFrame f = new JFrame("Strokes Demo");
            f.setSize(600, 600);
            f.add(new MyTest());
            f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            f.setLocationRelativeTo(null);
            f.setVisible(true);
        }
        public MyTest() {
            setBackground(Color.white);
            setForeground(Color.white);
        }
        @Override
        public void paintComponent(Graphics g) {
            super.paintComponent(g);
            g.setColor(Color.red);
            g.drawLine(0, getHeight()/3, getWidth(), getHeight()/3);
            g.drawLine(0, getHeight() * 2 /3, getWidth(), getHeight() * 2/3);
            paintThickStroke(g);
            paintGradientStroke(g);
            paintDashPatternStroke(g);
        }
        //绘制指定宽度的笔划
        private void paintThickStroke(Graphics g) {
            Graphics2D g2d = (Graphics2D) g;
            float strokeThickness = 5.0f;
            BasicStroke stroke = new BasicStroke(strokeThickness);
            g2d.setStroke(stroke);
            g2d.setColor(Color.blue);
            g2d.draw(new Rectangle(20, 20, 200, 100));
        }
        //绘制带有渐变着色的笔划
        private void paintGradientStroke(Graphics g) {
            Graphics2D g2 = (Graphics2D) g;
            double x = 15, y = getHeight() / 3 + 50, w = 70, h = 70;
            Ellipse2D e = new Ellipse2D.Double(x, y, w, h);
            GradientPaint gp = new GradientPaint(75, 75, Color.white, 95, 95, Color.gray, true);
            // 用渐变着色来填充
            g2.setPaint(gp);
            g2.fill(e);
            // 实心颜色的笔划
            e.setFrame(x + 100, y, w, h);
            g2.setPaint(Color.black);
            g2.setStroke(new BasicStroke(8));
            g2.draw(e);
            // 渐变颜色的笔划
            e.setFrame(x + 200, y, w, h);
            g2.setPaint(gp);
            g2.draw(e);
        }
        //绘制带有dash模式和线段端头风格的笔划
        private void paintDashPatternStroke(Graphics g) {
            Graphics2D g2 = (Graphics2D) g;
            float dash[] = { 10.0f };
            //param 1: 笔划的宽度
            //param 2: 端头样式，他是CAP_BUTT、CAP_ROUND、CAP_SQUARE三种样式中的一个
            //param 3: 连接样式，他是JOIN_BEVEL、JOIN_MITER和JOIN_ROUND三种样式中的一个
            //param 4: 用度数表示的角度，如果小于这个角度，斜尖连接将呈现为斜连接
            //param 5: 虚线笔划的填充部分和空白部分交替出现的一组长度
            //param 6: 位于笔划起始点前面的这段长度被假设为已经应用了该虚线模式
            //在该例子中，可以将最后一个参数从0调整到10，以观察显示差异
            g2.setStroke(new BasicStroke(5.0f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 10.0f, dash, 3f));
            g2.setPaint(Color.blue);
            Rectangle r = new Rectangle(20, getHeight() * 2 / 3 + 20, 200, 100);
            g2.draw(r);
        }
    }

    4.    着色：
    当填充一个形状的时候，该形状的内部就上了颜色。使用setPaint方法，把颜色的样式设定为一个实现了Paint接口的类的对象。Java 2D API提供了三个这样的类：
    1)    Color: 实现了Paint接口，使用单色填充形状；
    2)    GradientPaint: 通过在两个给定的颜色值之间进行渐变，从而改变使用的颜色；
    3)    TexturePaint: 用一个图像重复的对一个区域进行着色。

    public class MyTest extends JPanel {
        public static void main(String args[]) {
            JFrame f = new JFrame("Paint Demo");
            f.setSize(600, 600);
            f.add(new MyTest());
            f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            f.setLocationRelativeTo(null);
            f.setVisible(true);
        }
        public MyTest() {
            setBackground(Color.white);
            setForeground(Color.white);
        }
        @Override
        public void paintComponent(Graphics g) {
            super.paintComponent(g);
            g.setColor(Color.red);
            g.drawLine(0, getHeight() / 4, getWidth(), getHeight() / 4);
            g.drawLine(0, getHeight() / 2, getWidth(), getHeight() / 2);
            g.drawLine(0, getHeight() * 3 / 4, getWidth(), getHeight() * 3 / 4);
            paintRadialGradient(g);
            paintGradient(g);
            paintGradientRectangle(g);
            paintTexture(g);
        }
        // 绘制放射性渐变
        private void paintRadialGradient(Graphics g) {
            Graphics2D g2 = (Graphics2D) g;
            double radius = getWidth() / (2 * 4);
            Paint p = new RadialGradientPaint(new Point2D.Double(radius, radius),
                    (float) radius, new float[] { 0.0f, 1.0f }, new Color[] {
                            new Color(6, 76, 160, 127),
                            new Color(0.0f, 0.0f, 0.0f, 0.8f) });
            g2.setPaint(p);
            g2.fillOval(0, 0, (int) radius * 2 - 10, (int) radius * 2 - 10);
        }
        // 绘制普通渐变
        private void paintGradient(Graphics g) {
            Paint paint = new GradientPaint(0, getHeight() / 4, Color.red,
                    (float) getWidth() / 4, (float) getHeight() / 2, Color.blue);
            Graphics2D g2 = (Graphics2D) g;
            g2.setPaint(paint);
            Ellipse2D circle = new Ellipse2D.Double(0, getHeight() * 0.25,
                    getWidth() / 4 - 5, getHeight() / 4 - 5);
            g2.fill(circle);
        }
        // Color的填充
        private void paintGradientRectangle(Graphics g) {
            Graphics2D g2 = (Graphics2D) g;
            Dimension d = getSize();
            // 将坐标移动到中心
            g2.translate(d.width / 2, d.height * 5 / 8);
            Color[] colors = { Color.white, Color.lightGray, Color.gray,
                    Color.darkGray, Color.black, Color.red, Color.pink,
                    Color.orange, Color.yellow, Color.green, Color.magenta,
                    Color.cyan, Color.blue };
    
            float size = 25;
            float x = -size * colors.length / 2;
            float y = -size * 3 / 2;
    
            // 在第一行显示预定义的颜色
            for (int i = 0; i < colors.length; i++) {
                Rectangle2D r = new Rectangle2D.Float(x + size * (float) i, y,
                        size, size);
                g2.setPaint(colors[i]);
                g2.fill(r);
            }
            // 显示一个手工计算的线性渐变
            y += size;
            Color c1 = Color.yellow;
            Color c2 = Color.blue;
            for (int i = 0; i < colors.length; i++) {
                float ratio = (float) i / (float) colors.length;
                int red = (int) (c2.getRed() * ratio + c1.getRed() * (1 - ratio));
                int green = (int) (c2.getGreen() * ratio + c1.getGreen()
                        * (1 - ratio));
                int blue = (int) (c2.getBlue() * ratio + c1.getBlue() * (1 - ratio));
                Color c = new Color(red, green, blue);
                Rectangle2D r = new Rectangle2D.Float(x + size * (float) i, y,
                        size, size);
                g2.setPaint(c);
                g2.fill(r);
            }
            // 显示一个手工计算透明度的线性渐变
            y += size;
            c1 = Color.red;
            for (int i = 0; i < colors.length; i++) {
                int alpha = (int) (255 * (float) i / (float) colors.length);
                Color c = new Color(c1.getRed(), c1.getGreen(), c1.getBlue(), alpha);
                Rectangle2D r = new Rectangle2D.Float(x + size * (float) i, y,
                        size, size);
                g2.setPaint(c);
                g2.fill(r);
            }
            // 在3层的最外围绘制一个框
            y -= size * 2;
            Rectangle2D frame = new Rectangle2D.Float(x, y, size * colors.length,
                    size * 3);
            g2.setPaint(Color.black);
            g2.draw(frame);
            g2.translate(-d.width / 2, -d.height * 5 / 8);
        }
        // 绘制带纹理的着色
        private void paintTexture(Graphics g) {
            Graphics2D g2 = (Graphics2D) g;
            BufferedImage bi = new BufferedImage(5, 5, BufferedImage.TYPE_INT_RGB);
            Graphics2D big = bi.createGraphics();
            big.setColor(Color.blue);
            big.drawRect(0, 0, 5, 5);
            big.setColor(Color.lightGray);
            big.fillOval(0, 0, 5, 5);
            Rectangle r = new Rectangle(0, 0, 5, 5);
            g2.setPaint(new TexturePaint(bi, r));
            // 用带有纹理的TexturePaint绘制rect。
            Rectangle rect = new Rectangle(5, 5 + getHeight() * 3 / 4, 100, 100);
            g2.fill(rect);
            big.dispose();
        }
    }