AlphaComposite - [ Java参考文档 ] - 在线原生手册

文字

概述

软件包

类

使用

树

已过时

索引

帮助

Java^TM 2 Platform
Standard Ed. 6

上一个类 下一个类

框架 无框架

摘要：嵌套 | 字段 | 构造方法 | 方法

详细信息：字段 | 构造方法 | 方法

java.awt
类 AlphaComposite

java.lang.Object
  java.awt.AlphaComposite

所有已实现的接口：: Composite

public final class AlphaComposite
extends Object
implements Composite

AlphaComposite 类实现一些基本的 alpha 合成规则，将源色与目标色组合，在图形和图像中实现混合和透明效果。此类实现的特定规则是 T. Porter 和 T. Duff 合著的 "Compositing Digital Images", SIGGRAPH 84, 253-259 中描述的 12 条基本规则集。本文档的其余部分假定读者熟悉上述论文中概括的定义和概念。

此类扩展了 Porter 和 Duff 定义的方程，包含一个额外的因子。AlphaComposite 类的实例可以包含一个 alpha 值，在将该值用于混合方程之前，可以用它来修改不透明度和每个源像素的覆盖率。

要重点注意的是，Porter 和 Duff 的论文中定义的方程完全是为颜色分量方面的操作定义的，这些颜色分量都要用它们对应的 alpha 分量预乘。因为 ColorModel 和 Raster 类允许以预乘和非预乘的方式存储像素数据，所以在将所有输入数据应用到方程之前，必须将它们标准化为预乘形式，并且在存储像素值之前，可能需要将所有结果都调整回目标所需的形式。

还要注意的是，此类只定义了以纯数学方式组合颜色和 alpha 值的方程。方程的具体应用取决于从数据源中检索数据和将它们存储到其目标中的方式。有关更多信息，请参阅实现警告事项。

Porter 和 Duff 的论文在混合方程的描述中使用了以下因子：

因子定义

A_s 源像素的 alpha 分量

C_s 源像素的预乘形式的颜色分量

A_d 目标像素的 alpha 分量

C_d 目标像素的预乘形式的颜色分量

F_s 用于输出的源像素的分数值

F_d 用于输出的目标像素的分数值

A_r 结果 alpha 分量

C_r 结果预乘形式的颜色分量

因子	定义
A_s	源像素的 alpha 分量
C_s	源像素的预乘形式的颜色分量
A_d	目标像素的 alpha 分量
C_d	目标像素的预乘形式的颜色分量
F_s	用于输出的源像素的分数值
F_d	用于输出的目标像素的分数值
A_r	结果 alpha 分量
C_r	结果预乘形式的颜色分量

使用这些因子，Porter 和 Duff 定义了 12 种选择混合因子 F_s 和 F_d 的方法，从而产生了 12 种令人满意的可视效果。在对 12 个指定可视效果的静态字段的描述中，给出了具有确定 F_s 和 F_d 值的方程。例如，对 SRC_OVER 的描述指定了 F_s = 1 和 F_d = (1-A_s)。一旦已知一组确定混合因子的方程，就可以使用以下方程组将它们应用于每个像素以生成结果：

        F_s = f(A_d)
        F_d = f(A_s)
        A_r = A_s*F_s + A_d*F_d
        C_r = C_s*F_s + C_d*F_d

在我们对 Porter 和 Duff 论文混合方程的扩展中，用到了以下因子：

因子定义

C_sr 源像素的原始颜色分量之一

C_dr 目标像素的原始颜色分量之一

A_ac 取自 AlphaComposite 实例的“额外的”alpha 分量

A_sr 源像素的原始 alpha 分量

A_dr 目标像素的原始 alpha 分量

A_df 目标中存储的最终 alpha 分量

C_df 目标中存储的最终原始颜色分量

因子	定义
C_sr	源像素的原始颜色分量之一
C_dr	目标像素的原始颜色分量之一
A_ac	取自 AlphaComposite 实例的“额外的”alpha 分量
A_sr	源像素的原始 alpha 分量
A_dr	目标像素的原始 alpha 分量
A_df	目标中存储的最终 alpha 分量
C_df	目标中存储的最终原始颜色分量

准备输入

AlphaComposite 类定义一个应用于源 alpha 的额外 alpha 值。应用此值就好像首先将隐式的 SRC_IN 规则应用于源像素（通过将原始源 alpha 和原始源色乘以 AlphaComposite 中的 alpha 值获得），而不是应用于具有指定 alpha 值的像素。这产生了以下方程，该方程生成 Porter 和 Duff 的混合方程中使用的 alpha 值：

        A_s = A_sr * A_ac

所有这些原始源色分量都必须乘以 AlphaComposite 实例中的 alpha 值。此外，如果源色分量不是预乘形式的，那么还需要将颜色分量乘以源 alpha 值。因此，用来生成 Porter 和 Duff 方程源色分量的方程取决于源像素是否已经被预乘：

        C_s = C_sr * A_sr * A_ac     （如果源像素没有被预乘）
        C_s = C_sr * A_ac           （如果源像素被预乘）

无需对目标 alpha 进行调整：

        A_d = A_dr

仅当目标色分量不是预乘形式时，才需要对它们进行调整：

        C_d = C_dr * A_d    （如果目标色分量没有被预乘）
        C_d = C_dr         （如果目标色分量被预乘）

应用混合方程

调整后的 A_s、A_d、C_s 和 C_d 将用于标准的 Porter 和 Duff 方程，以计算混合因子 F_s 和 F_d，然后计算得到的预乘分量 A_r 和 C_r。

准备结果

仅当结果要存储回保存未预乘数据的目标缓冲区时，才需要使用以下方程调整结果：

        A_df = A_r
        C_df = C_r                 （如果目标数据被预乘）
        C_df = C_r / A_r            （如果目标数据没有被预乘）

注意，在所得 alpha 为零时除法是不明确的，所以在这种情况下会忽略除法以避免“除以零”的情况，此时颜色分量都将为零。

性能考虑事项

出于性能方面的原因，传递给 CompositeContext 对象（由 AlphaComposite 类创建） compose 方法的 Raster 对象最好有预乘数据。不过，如果源 Raster 或目标 Raster 没有被预乘，那么可以在合成操作之前或之后执行适当的转换。

实现警告事项

许多源图像，比如 BufferedImage 类中列出的一些不透明图像类型，没有为它们的像素存储 alpha 值。这类源图像为它们所有的像素提供了值为 1.0 的 alpha 值。
许多目标也没有地方存储 alpha 值（这些值是此类执行混合计算的结果）。这类目标会隐式丢弃此类产生的 alpha 值。建议这类目标将它们存储的颜色值作为未预乘的值对待，并在存储颜色值和丢弃 alpha 值之前，将得到的颜色值除以得到的 alpha 值。
结果的精度取决于将像素存储到目标中的方式。对于一连串十二种合成操作中的少数操作，将为每种颜色和 alpha 分量提供至少 8 个存储位的图像格式作为目标无论如何都应该足够了。在舍入误差支配结果之前，为每个分量提供少于 8 个存储位的图像格式仅限用于一或两个合成操作。对于任何半透明混合的类型而言，不单独存储颜色分量的图像格式不是一个好的候选方式。例如，不应将 BufferedImage.TYPE_BYTE_INDEXED 用作混合操作的目标，因为需要从限定的调色板选择像素，以匹配混合方程的结果，所以每个操作都可能引入大量错误。
几乎所有的格式都将像素存储为离散整数，而不是将它们存储为上述方程中使用的浮点值。该实现可以将整数像素值缩放成范围在 0.0 到 1.0 之间的浮点值，或者使用稍作修改的方程，完全在整数域内操作，从而生成与上述方程类似的结果。
通常，整数值与浮点值存在某种相关性：整数 0 等于浮点值 0.0，整数 2^n-1（其中 n 是表示形式中的位数）等于 1.0。对于 8 位的表示形式，这意味着 0x00 表示 0.0，0xff 表示 1.0。
内部实现可能近似于某些方程，它们也可以消除一些步骤，以避免不必要的操作。例如，可以考虑一个离散整数图像，它带有未预乘的 alpha 值，并为存储每个分量使用了 8 个位。接近透明的暗红色存储的值可能是：
```
    (A, R, G, B) = (0x01, 0xb0, 0x00, 0x00)
```
如果正在使用整数运算，并且此值在 SRC 模式下没有与任何 alpha 值合成，则该运算将指示此运算的结果为（整数格式）：
```
    (A, R, G, B) = (0x01, 0x01, 0x00, 0x00)
```
注意中间的值，它总是以已预乘的形式出现，并且只允许整数 red 分量为 0x00 或 0x01。当试图将此结果存储回未预乘的目标中时，用 alpha 值相除之后，对于未预乘的 red 值，可进行的选择很少。在这种情况下，在整数空间内执行运算（没有快捷方式）的实现最后可能提供以下最终像素值：
```
    (A, R, G, B) = (0x01, 0xff, 0x00, 0x00)
```
（注意，0x01 除以 0x01 得到的是 1.0，等于 8 位存储格式的值 0xff。）

另一方面，使用浮点运算的实现可以生成更精确的结果，并以返回原始像素值结束，该值有可能带有少量的舍入误差。或者，使用整数运算的实现可能决定是否可以将未涉及的像素传输给目标，完全避免所有运算。因为如果在浮点空间内执行运算，方程可简单归结为颜色值上的一个虚拟 NOP。

这些实现都试图遵守相同的方程，但使用经过权衡的不同整数和浮点运算，并使用部分的或全部的方程。为了说明这些不同之处，可能最好只期望获得已预乘形式的结果，以在实现和图像格式之间进行匹配。在这种情况下，以预乘形式表示的两种答案将等同于：
```
    (A, R, G, B) = (0x01, 0x01, 0x00, 0x00)
```
并且它们将是完全匹配的。
因为那些通过简化方程使计算更有效的技术，在非预乘的目标上遇到值为 0.0 的结果 alpha 值时，一些实现的执行可能会有所不同。注意，如果分母 (alpha) 为 0，则在 SRC 规则下移除除以 alpha 这一简化操作技术上是不合法的。但是，因为在以预乘形式查看时只期望结果是精确的，所以，结果为 0 的 alpha 值呈现的实质上是所得到的不相关颜色分量，因此，在这种情况下，具体的行为应该是无法预料的。

另请参见：: Composite, CompositeContext

字段摘要
`static AlphaComposite`	`Clear` 实现不透明 CLEAR 规则的 `AlphaComposite` 对象，具有 1.0f 的 alpha 值。
`static int`	`CLEAR` 目标色和目标 alpha 值都被清除（Porter-Duff Clear 规则）。
`static AlphaComposite`	`Dst` 实现不透明 DST 规则的 `AlphaComposite` 对象，具有 1.0f 的 alpha 值。
`static int`	`DST` 目标色不变（Porter-Duff Destination 规则）。
`static int`	`DST_ATOP` 在源色之上合成源色中的目标色部分，并将替换目标色（Porter-Duff Destination Atop Source 规则）。
`static int`	`DST_IN` 源色中的目标色部分将替换目标色（Porter-Duff Destination In Source 规则）。
`static int`	`DST_OUT` 源色以外的目标色部分将替换目标色（Porter-Duff Destination Held Out By Source 规则）。
`static int`	`DST_OVER` 在源色之上合成目标色，产生的结果将替代目标色（Porter-Duff Destination Over Source 规则）。
`static AlphaComposite`	`DstAtop` 实现不透明 DST_ATOP 规则的 `AlphaComposite` 对象，具有 1.0f 的 alpha 值。
`static AlphaComposite`	`DstIn` 实现不透明 DST_IN 规则的 `AlphaComposite` 对象，具有 1.0f 的 alpha 值。
`static AlphaComposite`	`DstOut` 实现不透明 DST_OUT 规则的 `AlphaComposite` 对象，具有 1.0f 的 alpha 值。
`static AlphaComposite`	`DstOver` 实现不透明 DST_OVER 规则的 `AlphaComposite` 对象，具有 1.0f 的 alpha 值。
`static AlphaComposite`	`Src` 实现不透明 SRC 规则的 `AlphaComposite` 对象，具有 1.0f 的 alpha 值。
`static int`	`SRC` 将源色复制到目标色（Porter-Duff Source 规则）。
`static int`	`SRC_ATOP` 目标色中的源色部分将被合成到目标色中（Porter-Duff Source Atop Destination 规则）。
`static int`	`SRC_IN` 目标色中的源色部分将替换目标色（Porter-Duff Source In Destination 规则）。
`static int`	`SRC_OUT` 目标色以外的源色部分将替换目标色（Porter-Duff Source Held Out By Destination 规则）。
`static int`	`SRC_OVER` 在目标色之上合成源色（Porter-Duff Source Over Destination 规则）。
`static AlphaComposite`	`SrcAtop` 实现不透明 SRC_ATOP 规则的 `AlphaComposite` 对象，具有 1.0f 的 alpha 值。
`static AlphaComposite`	`SrcIn` 实现不透明 SRC_IN 规则的 `AlphaComposite` 对象，具有 1.0f 的 alpha 值。
`static AlphaComposite`	`SrcOut` 实现不透明 SRC_OUT 规则的 `AlphaComposite` 对象，具有 1.0f 的 alpha 值。
`static AlphaComposite`	`SrcOver` 实现不透明 SRC_OVER 规则的 `AlphaComposite` 对象，具有 1.0f 的 alpha 值。
`static AlphaComposite`	`Xor` 实现不透明 XOR 规则的 `AlphaComposite` 对象，具有 1.0f 的 alpha 值。
`static int`	`XOR` 将目标色之外的源色部分与源色之外的目标色部分结合到一起（Porter-Duff Source Xor Destination 规则）。

方法摘要
`CompositeContext`	`createContext(ColorModel srcColorModel, ColorModel dstColorModel, RenderingHints hints)` 为合成操作创建一个上下文。
`AlphaComposite`	`derive(float alpha)` 返回一个类似的 `AlphaComposite` 对象，该对象使用指定的 alpha 值。
`AlphaComposite`	`derive(int rule)` 返回一个类似的 `AlphaComposite` 对象，该对象使用指定的复合规则。
`boolean`	`equals(Object obj)` 确定指定的对象是否等于此 `AlphaComposite`。
`float`	`getAlpha()` 返回此 `AlphaComposite` 的 alpha 值。
`static AlphaComposite`	`getInstance(int rule)` 创建一个具有指定规则的 `AlphaComposite` 对象。
`static AlphaComposite`	`getInstance(int rule, float alpha)` 创建一个 `AlphaComposite` 对象，它具有指定的规则和用来乘源色 alpha 值的常量 alpha 值。
`int`	`getRule()` 返回此 `AlphaComposite` 的合成规则。
`int`	`hashCode()` 返回此合成的哈希码。

从类 java.lang.Object 继承的方法
`clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait`

字段详细信息

CLEAR

public static final int CLEAR

目标色和目标 alpha 值都被清除（Porter-Duff Clear 规则）。源色和目标色都不被用作输入。

F_s = 0 和 F_d = 0，因此：

        A_r = 0
        C_r = 0

另请参见：: 常量字段值

SRC

public static final int SRC

将源色复制到目标色（Porter-Duff Source 规则）。目标色不被用作输入。

F_s = 1 和 F_d = 0，因此：

        A_r = A_s
        C_r = C_s

另请参见：: 常量字段值

DST

public static final int DST

目标色不变（Porter-Duff Destination 规则）。

F_s = 0 和 F_d = 1，因此：

        A_r = A_d
        C_r = C_d

从以下版本开始：: 1.4
另请参见：: 常量字段值

SRC_OVER

public static final int SRC_OVER

在目标色之上合成源色（Porter-Duff Source Over Destination 规则）。

F_s = 1 和 F_d = (1-A_s)，因此：

        A_r = A_s + A_d*(1-A_s)
        C_r = C_s + C_d*(1-A_s)

另请参见：: 常量字段值

DST_OVER

public static final int DST_OVER

在源色之上合成目标色，产生的结果将替代目标色（Porter-Duff Destination Over Source 规则）。

F_s = (1-A_d) 和 F_d = 1，因此：

        A_r = A_s*(1-A_d) + A_d
        C_r = C_s*(1-A_d) + C_d

另请参见：: 常量字段值

SRC_IN

public static final int SRC_IN

目标色中的源色部分将替换目标色（Porter-Duff Source In Destination 规则）。

F_s = A_d 和 F_d = 0，因此：

        A_r = A_s*A_d
        C_r = C_s*A_d

另请参见：: 常量字段值

DST_IN

public static final int DST_IN

源色中的目标色部分将替换目标色（Porter-Duff Destination In Source 规则）。

F_s = 0 和 F_d = A_s，因此：

        A_r = A_d*A_s
        C_r = C_d*A_s

另请参见：: 常量字段值

SRC_OUT

public static final int SRC_OUT

目标色以外的源色部分将替换目标色（Porter-Duff Source Held Out By Destination 规则）。

F_s = (1-A_d) 和 F_d = 0，因此：

        A_r = A_s*(1-A_d)
        C_r = C_s*(1-A_d)

另请参见：: 常量字段值

DST_OUT

public static final int DST_OUT

源色以外的目标色部分将替换目标色（Porter-Duff Destination Held Out By Source 规则）。

F_s = 0 和 F_d = (1-A_s)，因此：

        A_r = A_d*(1-A_s)
        C_r = C_d*(1-A_s)

另请参见：: 常量字段值

SRC_ATOP

public static final int SRC_ATOP

目标色中的源色部分将被合成到目标色中（Porter-Duff Source Atop Destination 规则）。

F_s = A_d 和 F_d = (1-A_s)，因此：

        A_r = A_s*A_d + A_d*(1-A_s) = A_d
        C_r = C_s*A_d + C_d*(1-A_s)

从以下版本开始：: 1.4
另请参见：: 常量字段值

DST_ATOP

public static final int DST_ATOP

在源色之上合成源色中的目标色部分，并将替换目标色（Porter-Duff Destination Atop Source 规则）。

F_s = (1-A_d) 和 F_d = A_s，因此：

        A_r = A_s*(1-A_d) + A_d*A_s = A_s
        C_r = C_s*(1-A_d) + C_d*A_s

从以下版本开始：: 1.4
另请参见：: 常量字段值

XOR

public static final int XOR

将目标色之外的源色部分与源色之外的目标色部分结合到一起（Porter-Duff Source Xor Destination 规则）。

F_s = (1-A_d) 和 F_d = (1-A_s)，因此：

        A_r = A_s*(1-A_d) + A_d*(1-A_s)
        C_r = C_s*(1-A_d) + C_d*(1-A_s)

从以下版本开始：: 1.4
另请参见：: 常量字段值

Clear

public static final AlphaComposite Clear

实现不透明 CLEAR 规则的 AlphaComposite 对象，具有 1.0f 的 alpha 值。

另请参见：: CLEAR

Src

public static final AlphaComposite Src

实现不透明 SRC 规则的 AlphaComposite 对象，具有 1.0f 的 alpha 值。

另请参见：: SRC

Dst

public static final AlphaComposite Dst

实现不透明 DST 规则的 AlphaComposite 对象，具有 1.0f 的 alpha 值。

从以下版本开始：: 1.4
另请参见：: DST

SrcOver

public static final AlphaComposite SrcOver

实现不透明 SRC_OVER 规则的 AlphaComposite 对象，具有 1.0f 的 alpha 值。

另请参见：: SRC_OVER

DstOver

public static final AlphaComposite DstOver

实现不透明 DST_OVER 规则的 AlphaComposite 对象，具有 1.0f 的 alpha 值。

另请参见：: DST_OVER

SrcIn

public static final AlphaComposite SrcIn

实现不透明 SRC_IN 规则的 AlphaComposite 对象，具有 1.0f 的 alpha 值。

另请参见：: SRC_IN

DstIn

public static final AlphaComposite DstIn

实现不透明 DST_IN 规则的 AlphaComposite 对象，具有 1.0f 的 alpha 值。

另请参见：: DST_IN

SrcOut

public static final AlphaComposite SrcOut

实现不透明 SRC_OUT 规则的 AlphaComposite 对象，具有 1.0f 的 alpha 值。

另请参见：: SRC_OUT

DstOut

public static final AlphaComposite DstOut

实现不透明 DST_OUT 规则的 AlphaComposite 对象，具有 1.0f 的 alpha 值。

另请参见：: DST_OUT

SrcAtop

public static final AlphaComposite SrcAtop

实现不透明 SRC_ATOP 规则的 AlphaComposite 对象，具有 1.0f 的 alpha 值。

从以下版本开始：: 1.4
另请参见：: SRC_ATOP

DstAtop

public static final AlphaComposite DstAtop

实现不透明 DST_ATOP 规则的 AlphaComposite 对象，具有 1.0f 的 alpha 值。

从以下版本开始：: 1.4
另请参见：: DST_ATOP

Xor

public static final AlphaComposite Xor

实现不透明 XOR 规则的 AlphaComposite 对象，具有 1.0f 的 alpha 值。

从以下版本开始：: 1.4
另请参见：: XOR

方法详细信息

getInstance

public static AlphaComposite getInstance(int rule)

创建一个具有指定规则的 AlphaComposite 对象。

参数：: rule - 合成规则
抛出：: IllegalArgumentException - 如果 rule 不是以下规则之一：CLEAR、SRC、DST、SRC_OVER、DST_OVER、SRC_IN、DST_IN、SRC_OUT、DST_OUT、SRC_ATOP、DST_ATOP 或 XOR

getInstance

public static AlphaComposite getInstance(int rule,
                                         float alpha)

创建一个 AlphaComposite 对象，它具有指定的规则和用来乘源色 alpha 值的常量 alpha 值。在将源色与目标色合成前，要将源色乘以指定的 alpha 值。

参数：: rule - 合成规则; alpha - 将乘源色的 alpha 值的常量 alpha 值。alpha 必须是范围 [0.0, 1.0] 之内（包含边界值）的一个浮点数字。

抛出：

IllegalArgumentException - 如果 alpha 小于 0.0 或大于 1.0，或者 rule 是以下规则之一：CLEAR、SRC、DST、SRC_OVER、DST_OVER、SRC_IN、DST_IN、SRC_OUT、DST_OUT、SRC_ATOP、DST_ATOP 或 XOR

createContext

public CompositeContext createContext(ColorModel srcColorModel,
                                      ColorModel dstColorModel,
                                      RenderingHints hints)

为合成操作创建一个上下文。上下文中包括执行合成操作过程中使用的状态。

指定者：: 接口 Composite 中的 createContext

参数：: srcColorModel - 源色的 ColorModel; dstColorModel - 目标色的 ColorModel; hints - 上下文对象用于选择呈现方法的提示

返回：

用来执行合成操作的 CompositeContext 对象。

getAlpha

public float getAlpha()

返回此 AlphaComposite 的 alpha 值。如果此 AlphaComposite 没有 alpha 值，则返回 1.0。

返回：: 此 AlphaComposite 的 alpha 值。

getRule

public int getRule()

返回此 AlphaComposite 的合成规则。

返回：: 此 AlphaComposite 的合成规则。

derive

public AlphaComposite derive(int rule)

返回一个类似的 AlphaComposite 对象，该对象使用指定的复合规则。如果此对象已经使用指定的复合规则，则返回此对象。

参数：: rule - 复合规则
返回：: 派生于使用指定复合规则的对象的 AlphaComposite 对象。
抛出：: IllegalArgumentException - 如果 rule 不是以下规则之一： CLEAR、SRC、DST、SRC_OVER、DST_OVER、SRC_IN、DST_IN、SRC_OUT、DST_OUT、SRC_ATOP、DST_ATOP 或 XOR
从以下版本开始：: 1.6

derive

public AlphaComposite derive(float alpha)

返回一个类似的 AlphaComposite 对象，该对象使用指定的 alpha 值。如果此对象已经具有指定的 alpha 值，则返回此对象。

参数：: alpha - 常量 alpha，将乘以源的 alpha 值。alpha 必须是闭区间 [0.0, 1.0] 中的一个浮点数字。
返回：: 派生于使用指定 alpha 值的对象的 AlphaComposite 对象。
抛出：: IllegalArgumentException - 如果 alpha 小于 0.0 或大于 1.0
从以下版本开始：: 1.6

hashCode

public int hashCode()

返回此合成的哈希码。

覆盖：: 类 Object 中的 hashCode

返回：: 此合成的哈希码。
另请参见：: Object.equals(java.lang.Object), Hashtable

equals

public boolean equals(Object obj)

确定指定的对象是否等于此 AlphaComposite。

当且仅当参数不为 null，并且是一个与此对象具有相同组合规则和 alpha 值的 AlphaComposite 对象时，结果才为 true。

覆盖：: 类 Object 中的 equals

参数：: obj - 要测试相等性的 Object
返回：: 如果 obj 等于此 AlphaComposite，则返回 true；否则返回 false。
另请参见：: Object.hashCode(), Hashtable

概述

软件包

类

使用

树

已过时

索引

帮助

Java^TM 2 Platform
Standard Ed. 6

上一个类 下一个类

框架 无框架

摘要：嵌套 | 字段 | 构造方法 | 方法

详细信息：字段 | 构造方法 | 方法

提交错误或意见
有关更多的 API 参考资料和开发人员文档，请参阅 Java 2 SDK SE 开发人员文档。该文档包含更详细的、面向开发人员的描述，以及总体概述、术语定义、使用技巧和工作代码示例。

java.awt 类 AlphaComposite

准备输入

应用混合方程

准备结果

性能考虑事项

实现警告事项

CLEAR

SRC

DST

SRC_OVER

DST_OVER

SRC_IN

DST_IN

SRC_OUT

DST_OUT

SRC_ATOP

DST_ATOP

XOR

Clear

Src

Dst

SrcOver

DstOver

SrcIn

DstIn

SrcOut

DstOut

SrcAtop

DstAtop

Xor

getInstance

getInstance

createContext

getAlpha

getRule

derive

derive

hashCode

equals

java.awt
类 AlphaComposite