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

在 Java 2D 的这一部分中，我们讨论透明性。 我们提供一些基本定义和一些有趣的透明效果。

透明度说明

透明性是指能够透视材料的质量。 了解透明度的最简单方法是想象一块玻璃或水。 从技术上讲，光线可以穿过玻璃，这样我们就可以看到玻璃后面的物体。

在计算机图形学中，我们可以使用 alpha 合成实现透明效果。 Alpha 合成是将图像与背景组合以创建部分透明外观的过程。 合成过程使用 alpha 通道。 Alpha 通道是图形文件格式的 8 位层，用于表达半透明性（透明度）。 每个像素的额外八位用作掩码，表示 256 级半透明。
（answers.com，wikipedia.org）

AlphaComposite类用于 Java 2D 中的透明性。 它实现了基本的 alpha 合成规则，用于合并源像素和目标像素，以实现图形和图像的融合和透明效果。 要创建AlphaComposite，我们提供两个值：规则指示符和 alpha 值。 该规则指定了我们如何组合源像素和目标像素。 最常见的是AlphaComposite.SRC_OVER。 alpha 值的范围可以从0.0f（完全透明）到1.0f（完全不透明）。

透明矩形

第一个示例绘制了十个具有不同透明度级别的矩形。

TransparentRectanglesEx.java

  1. package com.zetcode;
  3. import java.awt.AlphaComposite;
  4. import java.awt.Color;
  5. import java.awt.EventQueue;
  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.         g2d.setPaint(Color.blue);
  19.         for (int i = 1; i <= 10; i++) {
  21.             float alpha = i * 0.1f;
  22.             AlphaComposite alcom = AlphaComposite.getInstance(
  23.                     AlphaComposite.SRC_OVER, alpha);
  24.             g2d.setComposite(alcom);
  25.             g2d.fillRect(50 * i, 20, 40, 40);
  26.         }        
  28.         g2d.dispose();
  29.     }
  31.     @Override
  32.     public void paintComponent(Graphics g) {
  34.         super.paintComponent(g);
  35.         doDrawing(g);
  36.     }
  37. }
  39. public class TransparentRectanglesEx extends JFrame {
  41.     public TransparentRectanglesEx() {
  43.         initUI();
  44.     }
  46.     private void initUI() {
  48.         add(new Surface());
  50.         setTitle("Transparent rectangles");
  51.         setSize(590, 120);
  52.         setLocationRelativeTo(null);            
  53.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  54.     }
  56.     public static void main(String[] args) {
  58.         EventQueue.invokeLater(new Runnable() {
  59.             @Override
  60.             public void run() {
  62.                 TransparentRectanglesEx ex = new TransparentRectanglesEx();
  63.                 ex.setVisible(true);
  64.             }
  65.         });
  66.     }
  67. }

在我们的示例中，我们绘制了 10 个具有不同透明度级别的蓝色矩形。

  1. float alpha = i * 0.1f;

alpha 值在for循环中动态变化。

  1. AlphaComposite alcom = AlphaComposite.getInstance(
  2.         AlphaComposite.SRC_OVER, alpha);

AlphaComposite.getInstance()方法使用指定的规则和常数 alpha 来创建AlphaComposite对象，以与源的 alpha 相乘。

  1. g2d.setComposite(alcom);

setComposite()方法设置Graphics2D对象的复合属性。

透明度 - 图1

图：透明矩形

淡出演示

在下一个示例中，我们将淡出图像。 图像将逐渐变得更加透明，直到完全不可见为止。

FadeOutEx.java

  1. package com.zetcode;
  3. import java.awt.AlphaComposite;
  4. import java.awt.Dimension;
  5. import java.awt.EventQueue;
  6. import java.awt.Graphics;
  7. import java.awt.Graphics2D;
  8. import java.awt.Image;
  9. import java.awt.event.ActionEvent;
  10. import java.awt.event.ActionListener;
  11. import javax.swing.ImageIcon;
  12. import javax.swing.JFrame;
  13. import javax.swing.JPanel;
  14. import javax.swing.Timer;
  16. class Surface extends JPanel
  17.         implements ActionListener {
  19.     private Image img;
  20.     private Timer timer;
  21.     private float alpha = 1f;
  23.     private final int DELAY = 40;
  24.     private final int INITIAL_DELAY = 500;
  26.     public Surface() {
  28.         loadImage();
  29.         setSurfaceSize();
  30.         initTimer();
  31.     }
  33.     private void loadImage() {
  35.         img = new ImageIcon("mushrooms.jpg").getImage();
  36.     }
  38.     private void setSurfaceSize() {
  40.         int h = img.getHeight(this);
  41.         int w = img.getWidth(this);
  42.         setPreferredSize(new Dimension(w, h));
  43.     }
  45.     private void initTimer() {
  47.         timer = new Timer(DELAY, this);
  48.         timer.setInitialDelay(INITIAL_DELAY);
  49.         timer.start();
  50.     }
  52.     private void doDrawing(Graphics g) {
  54.         Graphics2D g2d = (Graphics2D) g.create();
  56.         AlphaComposite acomp = AlphaComposite.getInstance(
  57.                 AlphaComposite.SRC_OVER, alpha);
  58.         g2d.setComposite(acomp);
  59.         g2d.drawImage(img, 0, 0, null);
  61.         g2d.dispose();
  62.     }
  64.     @Override
  65.     public void paintComponent(Graphics g) {
  67.         super.paintComponent(g);
  68.         doDrawing(g);
  69.     }
  71.     private void step() {
  73.         alpha += -0.01f;
  75.         if (alpha <= 0) {
  77.             alpha = 0;
  78.             timer.stop();
  79.         }
  80.     }
  82.     @Override
  83.     public void actionPerformed(ActionEvent e) {
  85.         step();
  86.         repaint();
  87.     }
  88. }
  90. public class FadeOutEx extends JFrame {
  92.     public FadeOutEx() {
  94.         initUI();
  95.     }
  97.     private void initUI() {
  99.         add(new Surface());
  101.         pack();
  103.         setTitle("Fade out");
  104.         setLocationRelativeTo(null);
  105.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  106.     }
  108.     public static void main(String[] args) {
  110.         EventQueue.invokeLater(new Runnable() {
  111.             @Override
  112.             public void run() {
  114.                 FadeOutEx ex = new FadeOutEx();
  115.                 ex.setVisible(true);
  116.             }
  117.         });
  118.     }
  119. }

使用AlphaComposite，我们逐渐淡出面板上的图像。

  1. private void setSurfaceSize() {
  3.     int h = img.getHeight(this);
  4.     int w = img.getWidth(this);
  5.     setPreferredSize(new Dimension(w, h));        
  6. }

setSurfaceSize()方法找出图像的大小并为面板设置首选大小。 首选大小与pack()方法的组合将显示恰好足以显示整个图像的窗口。

  1. private void initTimer() {
  3.     timer = new Timer(DELAY, this);
  4.     timer.setInitialDelay(INITIAL_DELAY);
  5.     timer.start();
  6. }

initTimer()方法启动一个计时器。 计时器在指定的初始延迟后触发操作事件。 在事件之间延迟之后会生成连续的动作事件。 为了响应动作事件，我们将更改 Alpha 值并重新绘制面板。

  1. AlphaComposite acomp = AlphaComposite.getInstance(
  2.         AlphaComposite.SRC_OVER, alpha);
  3. g2d.setComposite(acomp);
  4. g2d.drawImage(img, 0, 0, null);

此代码在面板上绘制具有增加的透明度的图像。

  1. private void step() {
  3.     alpha += -0.01f;
  5.     if (alpha <= 0) {
  7.         alpha = 0;
  8.         timer.stop();
  9.     }
  10. }

step()方法代表淡出周期。 alpha逐渐降低。 请注意，alpha 值不得为负。 当达到零时，计时器停止。

  1. repaint();

repaint()方法重新绘制组件。 它调用面板组件的paint()方法，然后又调用paintComponent()方法。

等待演示

在此示例中，我们使用透明效果创建一个等待演示。 我们绘制了 8 条逐渐消失的线，从而产生了一条线在移动的错觉。 此类效果通常用于通知用户幕后正在进行繁重的任务。 例如，通过互联网流式传输视频时。

WaitingEx.java

  1. package com.zetcode;
  3. import java.awt.AlphaComposite;
  4. import java.awt.BasicStroke;
  5. import java.awt.EventQueue;
  6. import java.awt.Graphics;
  7. import java.awt.Graphics2D;
  8. import java.awt.RenderingHints;
  9. import java.awt.event.ActionEvent;
  10. import java.awt.event.ActionListener;
  11. import javax.swing.JFrame;
  12. import javax.swing.JPanel;
  13. import javax.swing.Timer;
  15. class Surface extends JPanel
  16.         implements ActionListener {
  18.     private Timer timer;
  19.     private int count;
  20.     private final int INITIAL_DELAY = 200;
  21.     private final int DELAY = 80;
  22.     private final int NUMBER_OF_LINES = 8;
  23.     private final int STROKE_WIDTH = 3;
  25.     private final double[][] trs = {
  26.         {0.0, 0.15, 0.30, 0.5, 0.65, 0.80, 0.9, 1.0},
  27.         {1.0, 0.0, 0.15, 0.30, 0.5, 0.65, 0.8, 0.9},
  28.         {0.9, 1.0, 0.0, 0.15, 0.3, 0.5, 0.65, 0.8},
  29.         {0.8, 0.9, 1.0, 0.0, 0.15, 0.3, 0.5, 0.65},
  30.         {0.65, 0.8, 0.9, 1.0, 0.0, 0.15, 0.3, 0.5},
  31.         {0.5, 0.65, 0.8, 0.9, 1.0, 0.0, 0.15, 0.3},
  32.         {0.3, 0.5, 0.65, 0.8, 0.9, 1.0, 0.0, 0.15},
  33.         {0.15, 0.3, 0.5, 0.65, 0.8, 0.9, 1.0, 0.0}
  34.     };
  36.     public Surface() {
  38.         initTimer();
  39.     }
  41.     private void initTimer() {
  43.         timer = new Timer(DELAY, this);
  44.         timer.setInitialDelay(INITIAL_DELAY);
  45.         timer.start();        
  46.     }
  48.     private void doDrawing(Graphics g) {
  50.         Graphics2D g2d = (Graphics2D) g.create();
  52.         g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
  53.                 RenderingHints.VALUE_ANTIALIAS_ON);
  54.         g2d.setRenderingHint(RenderingHints.KEY_RENDERING,
  55.                 RenderingHints.VALUE_RENDER_QUALITY);
  57.         int width = getWidth();
  58.         int height = getHeight();
  60.         g2d.setStroke(new BasicStroke(STROKE_WIDTH, BasicStroke.CAP_ROUND,
  61.                 BasicStroke.JOIN_ROUND));
  62.         g2d.translate(width / 2, height / 2);
  64.         for (int i = 0; i < NUMBER_OF_LINES; i++) {
  66.             float alpha = (float) trs[count % NUMBER_OF_LINES][i];
  67.             AlphaComposite acomp = AlphaComposite.getInstance(
  68.                     AlphaComposite.SRC_OVER, alpha);
  69.             g2d.setComposite(acomp);
  71.             g2d.rotate(Math.PI / 4f);
  72.             g2d.drawLine(0, -10, 0, -40);
  73.         }
  75.         g2d.dispose();
  76.     }
  78.     @Override
  79.     public void paintComponent(Graphics g) {
  81.         super.paintComponent(g);
  82.         doDrawing(g);
  83.     }
  85.     @Override
  86.     public void actionPerformed(ActionEvent e) {
  88.         repaint();
  89.         count++;
  90.     }
  91. }
  93. public class WaitingEx extends JFrame {
  95.     public WaitingEx() {
  97.         initUI();
  98.     }
  100.     private void initUI() {
  102.         add(new Surface());
  104.         setTitle("Waiting");
  105.         setSize(300, 200);
  106.         setLocationRelativeTo(null);
  107.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  108.     }
  110.     public static void main(String[] args) {
  112.         EventQueue.invokeLater(new Runnable() {
  113.             @Override
  114.             public void run() {
  116.                 WaitingEx ex = new WaitingEx();
  117.                 ex.setVisible(true);
  118.             }
  119.         });
  120.     }
  121. }

我们用八个不同的 alpha 值绘制八条线。

  1. private final double[][] trs = { 
  2. ...
  3. };

这是此演示中使用的透明度值的二维数组。 有 8 行，每行一种状态。 8 行中的每行将连续使用这些值。

  1. g2d.setStroke(new BasicStroke(STROKE_WIDTH, BasicStroke.CAP_ROUND,
  2.         BasicStroke.JOIN_ROUND));

我们使线条更粗一些，以便更好地显示它们。 我们用圆帽画线。

  1. g2d.rotate(Math.PI/4f);
  2. g2d.drawLine(0, -10, 0, -40);

这段代码绘制了八行。 rotate()方法用于沿直线旋转线。

透明度 - 图2

图：等待

在 Java 2D 教程的这一部分中，我们讨论了透明性。