原文： https://zetcode.com/gfx/java2d/shapesandfills/

在 Java 2D 教程的这一部分中，我们创建一些基本的和更高级的形状。 我们用纯色，渐变和纹理填充形状。

基本形状

首先，我们绘制一些基本的 Java 2D 形状。

BasicShapes.java

  1. package com.zetcode;
  3. import java.awt.Color;
  4. import java.awt.EventQueue;
  5. import java.awt.Graphics;
  6. import java.awt.Graphics2D;
  7. import java.awt.RenderingHints;
  8. import java.awt.geom.Ellipse2D;
  9. import javax.swing.JFrame;
  10. import javax.swing.JPanel;
  12. class Surface extends JPanel {
  14.     private void doDrawing(Graphics g) {
  16.         Graphics2D g2d = (Graphics2D) g;
  18.         g2d.setPaint(new Color(150, 150, 150));
  20.         RenderingHints rh = new RenderingHints(
  21.                 RenderingHints.KEY_ANTIALIASING,
  22.                 RenderingHints.VALUE_ANTIALIAS_ON);
  24.         rh.put(RenderingHints.KEY_RENDERING,
  25.                RenderingHints.VALUE_RENDER_QUALITY);
  27.         g2d.setRenderingHints(rh);
  29.         g2d.fillRect(30, 20, 50, 50);
  30.         g2d.fillRect(120, 20, 90, 60);
  31.         g2d.fillRoundRect(250, 20, 70, 60, 25, 25);
  33.         g2d.fill(new Ellipse2D.Double(10, 100, 80, 100));
  34.         g2d.fillArc(120, 130, 110, 100, 5, 150);
  35.         g2d.fillOval(270, 130, 50, 50);
  36.    } 
  38.     @Override
  39.     public void paintComponent(Graphics g) {
  41.         super.paintComponent(g);
  42.         doDrawing(g);
  43.     }    
  44. }
  46. public class BasicShapesEx extends JFrame {
  48.     public BasicShapesEx() {
  50.         initUI();
  51.     }
  53.     private void initUI() {
  55.         add(new Surface());
  57.         setTitle("Basic shapes");
  58.         setSize(350, 250);
  59.         setLocationRelativeTo(null);        
  60.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  61.     }
  63.     public static void main(String[] args) {
  65.         EventQueue.invokeLater(new Runnable() {
  67.             @Override
  68.             public void run() {
  69.                 BasicShapesEx ex = new BasicShapesEx();
  70.                 ex.setVisible(true);
  71.             }
  72.         });
  73.     }
  74. }

在此示例中，我们在面板上绘制了六个基本形状：正方形，矩形，圆角矩形，椭圆形，弧形和圆形。

  1. g2d.setPaint(new Color(150, 150, 150));

形状将以灰色背景绘制。

  1. g2d.fillRect(20, 20, 50, 50);
  2. g2d.fillRect(120, 20, 90, 60);

fillRect()方法用于绘制矩形和正方形。 前两个参数是要绘制的形状的 x，y 坐标。 最后两个参数是形状的宽度和高度。

  1. g2d.fillRoundRect(250, 20, 70, 60, 25, 25);

在这里，我们创建一个圆角矩形。 最后两个参数是四个角处圆弧的水平和垂直直径。

  1. g2d.fill(new Ellipse2D.Double(10, 100, 80, 100));

fill()方法绘制给定形状的内部-椭圆。

  1. g2d.fillArc(120, 130, 110, 100, 5, 150);

fillArc()方法填充覆盖指定矩形的圆弧或椭圆弧。 圆弧是圆的圆周的一部分。

  1. g2d.fillOval(270, 130, 50, 50);

使用fillOval()方法绘制一个圆。

形状和填充 - 图1

图：基本形状

一般路径

可以使用GeneralPath构造更复杂的形状。 它代表由直线，二次贝塞尔曲线和三次贝塞尔曲线构成的几何路径。

下面的示例使用此类创建星形。

StarEx.java

  1. package com.zetcode;
  3. import java.awt.Color;
  4. import java.awt.EventQueue;
  5. import java.awt.Graphics;
  6. import java.awt.Graphics2D;
  7. import java.awt.RenderingHints;
  8. import java.awt.geom.GeneralPath;
  9. import javax.swing.JFrame;
  10. import javax.swing.JPanel;
  12. class Surface extends JPanel {
  14.     private final double points[][] = { 
  15.         { 0, 85 }, { 75, 75 }, { 100, 10 }, { 125, 75 }, 
  16.         { 200, 85 }, { 150, 125 }, { 160, 190 }, { 100, 150 }, 
  17.         { 40, 190 }, { 50, 125 }, { 0, 85 } 
  18.     };
  20.     private void doDrawing(Graphics g) {
  22.         Graphics2D g2d = (Graphics2D) g.create();
  24.         g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
  25.                              RenderingHints.VALUE_ANTIALIAS_ON);
  27.         g2d.setRenderingHint(RenderingHints.KEY_RENDERING,
  28.                              RenderingHints.VALUE_RENDER_QUALITY);
  30.         g2d.setPaint(Color.gray);
  31.         g2d.translate(25, 5);
  33.         GeneralPath star = new GeneralPath();
  35.         star.moveTo(points[0][0], points[0][1]);
  37.         for (int k = 1; k < points.length; k++)
  38.             star.lineTo(points[k][0], points[k][1]);
  40.         star.closePath();
  41.         g2d.fill(star);        
  43.         g2d.dispose();
  44.     }
  46.     @Override
  47.     public void paintComponent(Graphics g) {
  48.         super.paintComponent(g);
  50.         doDrawing(g);
  51.     }
  52. }
  54. public class StarEx extends JFrame {
  56.     public StarEx() {
  58.         initUI();
  59.     }    
  61.     private void initUI() {
  63.         add(new Surface());
  65.         setTitle("Star");
  66.         setSize(350, 250);
  67.         setLocationRelativeTo(null);           
  68.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  69.     }
  71.     public static void main(String[] args) {
  73.         EventQueue.invokeLater(new Runnable() {
  75.             @Override
  76.             public void run() {
  77.                 StarEx ex = new StarEx();
  78.                 ex.setVisible(true);
  79.             }
  80.         });
  81.     }    
  82. }

我们从一系列角度创造一颗星星。

  1. private final double points[][] = { 
  2.     { 0, 85 }, { 75, 75 }, { 100, 10 }, { 125, 75 }, 
  3.     { 200, 85 }, { 150, 125 }, { 160, 190 }, { 100, 150 }, 
  4.     { 40, 190 }, { 50, 125 }, { 0, 85 } 
  5. };

这些是星星的坐标。

  1. GeneralPath star = new GeneralPath();

在这里，我们实例化了GeneralPath类。

  1. star.moveTo(points[0][0], points[0][1]);

我们移到GeneralPath的初始坐标。

  1. for (int k = 1; k < points.length; k++)
  2.     star.lineTo(points[k][0], points[k][1]);

在这里，我们连接星的所有坐标。

  1. star.closePath();
  2. g2d.fill(star);

我们封闭路径并填充星星内部。

形状和填充 - 图2

图：星星

区域

创建复杂形状的另一种方法是组成区域。 Area存储和操纵二维空间的封闭区域的与分辨率无关的描述。 可以通过加，减，交，异或运算来操纵它。

AreasEx.java

  1. package com.zetcode;
  3. import java.awt.Color;
  4. import java.awt.EventQueue;
  5. import java.awt.Graphics;
  6. import java.awt.Graphics2D;
  7. import java.awt.RenderingHints;
  8. import java.awt.geom.Area;
  9. import java.awt.geom.Ellipse2D;
  10. import java.awt.geom.Rectangle2D;
  11. import javax.swing.JFrame;
  12. import javax.swing.JPanel;
  14. class Surface extends JPanel {
  16.     public void doDrawing(Graphics g) {
  18.         Graphics2D g2d = (Graphics2D) g;
  20.         RenderingHints rh = new RenderingHints(
  21.                 RenderingHints.KEY_ANTIALIASING,
  22.                 RenderingHints.VALUE_ANTIALIAS_ON);
  24.         rh.put(RenderingHints.KEY_RENDERING,
  25.                RenderingHints.VALUE_RENDER_QUALITY);    
  26.         g2d.setRenderingHints(rh);
  28.         g2d.setPaint(Color.gray);
  30.         Area a1 = new Area(new Rectangle2D.Double(20, 20, 100, 100));
  31.         Area a2 = new Area(new Ellipse2D.Double(50, 50, 100, 100));
  33.         a1.subtract(a2);
  34.         g2d.fill(a1);
  36.         Area a3 = new Area(new Rectangle2D.Double(150, 20, 100, 100));
  37.         Area a4 = new Area(new Ellipse2D.Double(150, 20, 100, 100));        
  39.         a3.subtract(a4);
  40.         g2d.fill(a3);
  42.         Area a5 = new Area(new Rectangle2D.Double(280, 20, 100, 100));
  43.         Area a6 = new Area(new Ellipse2D.Double(320, 40, 100, 100));        
  45.         a5.add(a6);
  46.         g2d.fill(a5);        
  47.     }
  49.     @Override
  50.     public void paintComponent(Graphics g) {
  52.         super.paintComponent(g);
  53.         doDrawing(g);
  54.     }           
  55. }
  57. public class AreasEx extends JFrame {
  59.     public AreasEx() {
  61.         initUI();
  62.     }
  64.     private void initUI() {
  66.         add(new Surface());
  68.         setTitle("Areas");
  69.         setSize(450, 200);
  70.         setLocationRelativeTo(null);        
  71.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  72.     }
  74.     public static void main(String[] args) {
  76.         EventQueue.invokeLater(new Runnable() {
  78.             @Override
  79.             public void run() {
  80.                 AreasEx ex = new AreasEx();
  81.                 ex.setVisible(true);
  82.             }
  83.         });
  84.     }
  85. }

该示例通过操纵区域来创建三种不同的形状。

  1. Area a1 = new Area(new Rectangle2D.Double(20, 20, 100, 100));
  2. Area a2 = new Area(new Ellipse2D.Double(50, 50, 100, 100));
  4. a1.subtract(a2);
  5. g2d.fill(a1);

此代码通过从矩形中减去椭圆来构造形状。

  1. Area a5 = new Area(new Rectangle2D.Double(280, 20, 100, 100));
  2. Area a6 = new Area(new Ellipse2D.Double(320, 40, 100, 100));        
  4. a5.add(a6);
  5. g2d.fill(a5);

这些线通过在椭圆上添加矩形来构造形状。

形状和填充 - 图3

图：区域

色彩

Color类用于处理 Java 2D 中的颜色。 要使用当前颜色填充矩形，我们使用fillRect()方法。

ColoursEx.java

  1. package com.zetcode;
  3. import java.awt.Color;
  4. import java.awt.EventQueue;
  5. import java.awt.Graphics;
  6. import java.awt.Graphics2D;
  7. import javax.swing.JFrame;
  8. import javax.swing.JPanel;
  10. class Surface extends JPanel {
  12.     public void doDrawing(Graphics g) {
  14.         Graphics2D g2d = (Graphics2D) g;
  16.         g2d.setColor(new Color(125, 167, 116));
  17.         g2d.fillRect(10, 10, 90, 60);
  19.         g2d.setColor(new Color(42, 179, 231));
  20.         g2d.fillRect(130, 10, 90, 60);
  22.         g2d.setColor(new Color(70, 67, 123));
  23.         g2d.fillRect(250, 10, 90, 60);
  25.         g2d.setColor(new Color(130, 100, 84));
  26.         g2d.fillRect(10, 100, 90, 60);
  28.         g2d.setColor(new Color(252, 211, 61));
  29.         g2d.fillRect(130, 100, 90, 60);
  31.         g2d.setColor(new Color(241, 98, 69));
  32.         g2d.fillRect(250, 100, 90, 60);
  34.         g2d.setColor(new Color(217, 146, 54));
  35.         g2d.fillRect(10, 190, 90, 60);
  37.         g2d.setColor(new Color(63, 121, 186));
  38.         g2d.fillRect(130, 190, 90, 60);
  40.         g2d.setColor(new Color(31, 21, 1));
  41.         g2d.fillRect(250, 190, 90, 60);
  42.     }
  44.     @Override
  45.     public void paintComponent(Graphics g) {
  47.         super.paintComponent(g);
  48.         doDrawing(g);
  49.     }           
  50. }
  52. public class ColoursEx extends JFrame {
  54.     public ColoursEx() {
  56.         initUI();
  57.     }
  59.     private void initUI() {
  61.         add(new Surface());
  63.         setTitle("Colours");
  64.         setSize(360, 300);
  65.         setLocationRelativeTo(null);        
  66.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  67.     }
  69.     public static void main(String[] args) {
  71.         EventQueue.invokeLater(new Runnable() {
  73.             @Override
  74.             public void run() {
  75.                 ColoursEx ex = new ColoursEx();
  76.                 ex.setVisible(true);
  77.             }
  78.         });
  79.     }
  80. }

在示例中，我们绘制了九个彩色矩形。

  1. Graphics2D g2d = (Graphics2D) g;

更改图形上下文的color属性时，无需创建Graphics2D类的副本或重置该值。

  1. g2d.setColor(new Color(125, 167, 116));

使用Color类创建新的颜色。 构造器的参数是新颜色的红色，绿色和蓝色部分。 setColor()方法将图形上下文的当前颜色设置为指定的颜色值。 所有后续图形操作均使用此颜色值。

  1. g2d.fillRect(10, 15, 90, 60);

为了用颜色填充矩形，我们使用fillRect()方法。

形状和填充 - 图4

图：颜色

渐变

在计算机图形学中，渐变是从浅到深或从一种颜色到另一种颜色的阴影的平滑混合。 在 2D 绘图程序和绘画程序中，渐变用于创建彩色背景和特殊效果以及模拟灯光和阴影。 （answers.com）

GradientsEx.java

  1. package com.zetcode;
  3. import java.awt.Color;
  4. import java.awt.EventQueue;
  5. import java.awt.GradientPaint;
  6. import java.awt.Graphics;
  7. import java.awt.Graphics2D;
  8. import javax.swing.JFrame;
  9. import javax.swing.JPanel;
  11. class Surface extends JPanel {
  13.     private void doDrawing(Graphics g) {
  15.         Graphics2D g2d = (Graphics2D) g.create();
  17.         GradientPaint gp1 = new GradientPaint(5, 5, 
  18.             Color.red, 20, 20, Color.black, true);
  20.         g2d.setPaint(gp1);
  21.         g2d.fillRect(20, 20, 300, 40);
  23.         GradientPaint gp2 = new GradientPaint(5, 25, 
  24.             Color.yellow, 20, 2, Color.black, true);
  26.         g2d.setPaint(gp2);
  27.         g2d.fillRect(20, 80, 300, 40);
  29.         GradientPaint gp3 = new GradientPaint(5, 25, 
  30.             Color.green, 2, 2, Color.black, true);
  32.         g2d.setPaint(gp3);
  33.         g2d.fillRect(20, 140, 300, 40);
  35.         GradientPaint gp4 = new GradientPaint(25, 25, 
  36.             Color.blue, 15, 25, Color.black, true);
  38.         g2d.setPaint(gp4);
  39.         g2d.fillRect(20, 200, 300, 40);
  41.         GradientPaint gp5 = new GradientPaint(0, 0, 
  42.              Color.orange, 0, 20, Color.black, true);
  44.         g2d.setPaint(gp5);
  45.         g2d.fillRect(20, 260, 300, 40);   
  47.         g2d.dispose();
  48.     }
  50.     @Override
  51.     public void paintComponent(Graphics g) {
  53.         super.paintComponent(g);
  54.         doDrawing(g);
  55.     }
  56. }
  58. public class GradientsEx extends JFrame {
  60.     public GradientsEx() {
  62.         initUI();
  63.     }    
  65.     private void initUI() {
  67.         add(new Surface());
  69.         setTitle("Gradients");
  70.         setSize(350, 350);
  71.         setLocationRelativeTo(null);            
  72.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  73.     }
  75.     public static void main(String[] args) {
  77.         EventQueue.invokeLater(new Runnable() {
  79.             @Override
  80.             public void run() {
  81.                 GradientsEx ex = new GradientsEx();
  82.                 ex.setVisible(true);
  83.             }
  84.         });
  85.     }    
  86. }

我们的代码示例展示了五个带有渐变的矩形。

  1. GradientPaint gp4 = new GradientPaint(25, 25, 
  2.     Color.blue, 15, 25, Color.black, true);

要使用渐变，我们使用GradientPaint类。 通过操纵颜色值以及起点和终点，我们可以获得不同的结果。

  1. g2d.setPaint(gp4);

通过调用setPaint()方法激活渐变。

形状和填充 - 图5

图：渐变

纹理

纹理是应用于形状的位图图像。 要在 Java 2D 中使用纹理，我们使用TexturePaint类。 通过setPaint()方法应用纹理。

TexturesEx.java

  1. package com.zetcode;
  3. import java.awt.EventQueue;
  4. import java.awt.Graphics;
  5. import java.awt.Graphics2D;
  6. import java.awt.Rectangle;
  7. import java.awt.TexturePaint;
  8. import java.awt.image.BufferedImage;
  9. import java.io.File;
  10. import java.io.IOException;
  11. import java.util.logging.Level;
  12. import java.util.logging.Logger;
  13. import javax.imageio.ImageIO;
  14. import javax.swing.JFrame;
  15. import javax.swing.JPanel;
  17. class Surface extends JPanel {
  19.     private BufferedImage slate;
  20.     private BufferedImage java;
  21.     private BufferedImage pane;
  22.     private TexturePaint slatetp;
  23.     private TexturePaint javatp;
  24.     private TexturePaint panetp;
  26.     public Surface() {
  28.         loadImages();
  29.     }
  31.     private void loadImages() {
  33.         try {
  35.             slate = ImageIO.read(new File("slate.png"));
  36.             java = ImageIO.read(new File("java.png"));
  37.             pane = ImageIO.read(new File("pane.png"));
  39.         } catch (IOException ex) {
  41.             Logger.getLogger(Surface.class.getName()).log(
  42.                     Level.SEVERE, null, ex);
  43.         }
  44.     }
  46.     private void doDrawing(Graphics g) {
  48.         Graphics2D g2d = (Graphics2D) g.create();
  50.         slatetp = new TexturePaint(slate, new Rectangle(0, 0, 90, 60));
  51.         javatp = new TexturePaint(java, new Rectangle(0, 0, 90, 60));
  52.         panetp = new TexturePaint(pane, new Rectangle(0, 0, 90, 60));
  54.         g2d.setPaint(slatetp);
  55.         g2d.fillRect(10, 15, 90, 60);
  57.         g2d.setPaint(javatp);
  58.         g2d.fillRect(130, 15, 90, 60);
  60.         g2d.setPaint(panetp);
  61.         g2d.fillRect(250, 15, 90, 60);
  63.         g2d.dispose();
  64.     }
  66.     @Override
  67.     public void paintComponent(Graphics g) {
  69.         super.paintComponent(g);
  70.         doDrawing(g);
  71.     }
  72. }
  74. public class TexturesEx extends JFrame {
  76.     public TexturesEx() {
  78.         initUI();
  79.     }
  81.     private void initUI() {
  83.         add(new Surface());
  85.         setTitle("Textures");
  86.         setSize(360, 120);
  87.         setLocationRelativeTo(null);        
  88.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  89.     }
  91.     public static void main(String[] args) {
  93.         EventQueue.invokeLater(new Runnable() {
  95.             @Override
  96.             public void run() {
  97.                 TexturesEx ex = new TexturesEx();
  98.                 ex.setVisible(true);
  99.             }
  100.         });
  101.     }
  102. }

在代码示例中，我们用三个不同的纹理填充三个矩形。

  1. slate = ImageIO.read(new File("slate.png"));

使用ImageIO类，我们将图像读取到缓冲图像中。

  1. slatetp = new TexturePaint(slate, new Rectangle(0, 0, 90, 60));

我们从缓冲图像中创建一个TexturePaint类。

  1. g2d.setPaint(slatetp);
  2. g2d.fillRect(10, 15, 90, 60);

我们用纹理填充矩形。

形状和填充 - 图6

图：纹理

在 Java 2D 教程的这一部分中，我们介绍了 Java 2D 库的一些基本形状和更高级的形状。