模块 java.desktop
包 java.awt.geom

类 AffineTransform

java.lang.Object
java.awt.geom.AffineTransform
所有已实现的接口：
Serializable , Cloneable
public class AffineTransform extends Object implements Cloneable , Serializable
AffineTransform 类表示二维仿射变换，它执行从二维坐标到其他二维坐标的线性映射，以保持线条的“直线度”和“平行度”。可以使用平移、缩放、翻转、旋转和剪切的序列来构建仿射变换。

这样的坐标变换可以用 3 行乘 3 列的矩阵表示，最后一行隐含为 [ 0 0 1 ]。该矩阵将源坐标 (x,y) 转换为目标坐标 (x',y')，方法是将它们视为列向量，并根据以下过程将坐标向量乘以矩阵：

   [ x']  [ m00 m01 m02 ] [ x ]  [ m00x + m01y + m02 ]
   [ y'] = [ m10 m11 m12 ] [ y ] = [ m10x + m11y + m12 ]
   [ 1 ]  [  0  0  1  ] [ 1 ]  [     1     ]

处理 90 度旋转

在 AffineTransform 类中的 rotate 方法的某些变体中，双精度参数以弧度指定旋转角度。这些方法对大约 90 度（包括 180、270 和 360 度等倍数）的旋转有特殊处理，因此可以更有效地处理常见的象限旋转情况。这种特殊处理会导致非常接近 90 度倍数的角度被视为 90 度的精确倍数。对于 90 度的小倍数，被视为象限旋转的角度范围约为 0.00000121 度宽。本节解释为什么需要这种特殊照顾以及如何实施。

由于 90 度以弧度表示为 PI/2，并且由于 PI 是超越数（因此是无理数），因此无法将 90 度的倍数精确表示为以弧度测量的精确双精度值。因此，理论上不可能使用这些值来描述象限旋转（90、180、270 或 360 度）。双精度浮点值可以非常接近 PI/2 的非零倍数，但永远不会接近到足以使正弦或余弦正好为 0.0、1.0 或 -1.0。 Math.sin() 和 Math.cos() 的实现相应地从不为 Math.sin(0.0) 以外的任何情况返回 0.0。但是，对于 90 度的每个倍数附近的某些数字范围，这些相同的实现确实会返回 1.0 和 -1.0，因为正确答案非常接近 1.0 或 -1.0，双精度有效数字无法尽可能准确地表示差异对于接近 0.0 的数字。

这些问题的最终结果是，如果 Math.sin() 和 Math.cos() 方法用于在这些基于弧度的旋转操作期间直接生成矩阵修改的值，那么即使对于像这样的简单情况，生成的变换也永远不会严格归类为象限旋转rotate(Math.PI/2.0) ，由于正弦和余弦获得的非 0.0 值导致矩阵发生微小变化。如果这些变换没有被归类为象限旋转，那么尝试根据变换类型优化进一步操作的后续代码将被归类为最通用的实现。

因为象限旋转相当普遍，所以此类应该相当快地处理这些情况，无论是将旋转应用到变换还是将生成的变换应用到坐标。为了促进这种最佳处理，采用以弧度为单位测量的旋转角度的方法试图检测旨在作为象限旋转的角度并将它们视为象限旋转。因此，如果 Math.sin(theta) 或 Math.cos(theta) 恰好返回 1.0 或 -1.0，则这些方法将角度 theta 视为象限旋转。根据经验，此属性适用于围绕 Math.PI/2.0 的小倍数的大约 0.0000000211 弧度（或 0.00000121 度）的范围。

自从：
1.2
参见：

  • 字段摘要

    字段
    修饰符和类型
    Field
    描述
    static final int
    TYPE_FLIP
    此标志位指示此对象定义的变换执行围绕某个轴的镜像翻转，除了其他标志位指示的转换之外，还将通常的右手坐标系更改为左手坐标系。
    static final int
    TYPE_GENERAL_ROTATION
    此标志位指示此对象定义的变换除了由其他标志位指示的转换外，还执行任意角度的旋转。
    static final int
    TYPE_GENERAL_SCALE
    此标志位指示除其他标志位指示的转换外，此对象定义的转换还执行一般缩放。
    static final int
    TYPE_GENERAL_TRANSFORM
    此常量表示此对象定义的变换对输入坐标执行任意转换。
    static final int
    TYPE_IDENTITY
    此常量表示此对象定义的转换是恒等转换。
    static final int
    TYPE_MASK_ROTATION
    该常量是任何旋转标志位的位掩码。
    static final int
    TYPE_MASK_SCALE
    该常量是任何标度标志位的位掩码。
    static final int
    TYPE_QUADRANT_ROTATION
    此标志位指示除其他标志位指示的转换外，此对象定义的转换还执行象限旋转 90 度的某个倍数。
    static final int
    TYPE_TRANSLATION
    此标志位指示除其他标志位指示的转换外，此对象定义的转换还执行转换。
    static final int
    TYPE_UNIFORM_SCALE
    除其他标志位指示的转换外，此对象定义的转换还执行统一缩放。

  • 构造方法总结

    构造方法
    构造方法
    描述
    AffineTransform()
    构造一个新的 AffineTransform 表示身份转换。
    AffineTransform(double[] flatmatrix)
    从代表 3x3 变换矩阵的 4 个非翻译条目或 6 个可指定条目的双精度值数组构造一个新的 AffineTransform。
    AffineTransform(double m00, double m10, double m01, double m11, double m02, double m12)
    从表示 3x3 变换矩阵的 6 个可指定条目的 6 个双精度值构造一个新的 AffineTransform。
    AffineTransform(float[] flatmatrix)
    从代表 3x3 变换矩阵的 4 个非翻译条目或 6 个可指定条目的浮点值数组构造一个新的 AffineTransform。
    AffineTransform(float m00, float m10, float m01, float m11, float m02, float m12)
    从表示 3x3 变换矩阵的 6 个可指定条目的 6 个浮点值构造一个新的 AffineTransform。
    AffineTransform(AffineTransform Tx)
    构造一个新的 AffineTransform，它是指定 AffineTransform 对象的副本。

  • 方法总结

    修饰符和类型
    方法
    描述
    Object
    clone()
    返回此 AffineTransform 对象的副本。
    void
    concatenate(AffineTransform Tx)
    以最常用的方式将 AffineTransform Tx 连接到此 AffineTransform Cx，以提供由 Tx 映射到先前用户空间的新用户空间。
    AffineTransform
    createInverse()
    返回表示逆变换的 AffineTransform 对象。
    Shape
    createTransformedShape(Shape pSrc)
    返回一个新的 Shape 对象，该对象由指定的 Shape 的几何形状定义，之后它已被此转换转换。
    void
    deltaTransform(double[] srcPts, int srcOff, double[] dstPts, int dstOff, int numPts)
    通过此变换变换相对距离向量数组。
    Point2D
    deltaTransform(Point2D ptSrc, Point2D ptDst)
    转换 ptSrc 指定的相对距离向量并将结果存储在 ptDst 中。
    boolean
    equals(Object obj)
    如果此 AffineTransform 表示与指定参数相同的仿射坐标变换，则返回 true。
    double
    getDeterminant()
    返回变换的矩阵表示的行列式。
    void
    getMatrix(double[] flatmatrix)
    检索 3x3 仿射变换矩阵中的 6 个可指定值，并将它们放入双精度值数组中。
    static AffineTransform
    getQuadrantRotateInstance(int numquadrants)
    返回按指定数量的象限旋转坐标的变换。
    static AffineTransform
    getQuadrantRotateInstance(int numquadrants, double anchorx, double anchory)
    返回一个变换，该变换将坐标围绕指定锚点旋转指定数量的象限。
    static AffineTransform
    getRotateInstance(double theta)
    返回表示旋转变换的变换。
    static AffineTransform
    getRotateInstance(double vecx, double vecy)
    返回根据旋转向量旋转坐标的变换。
    static AffineTransform
    getRotateInstance(double theta, double anchorx, double anchory)
    返回围绕锚点旋转坐标的变换。
    static AffineTransform
    getRotateInstance(double vecx, double vecy, double anchorx, double anchory)
    返回根据旋转向量围绕锚点旋转坐标的变换。
    static AffineTransform
    getScaleInstance(double sx, double sy)
    返回表示缩放变换的变换。
    double
    getScaleX()
    返回 3x3 仿射变换矩阵的 m00 元素。
    double
    getScaleY()
    返回 3x3 仿射变换矩阵的 m11 元素。
    static AffineTransform
    getShearInstance(double shx, double shy)
    返回表示剪切变换的变换。
    double
    getShearX()
    返回 3x3 仿射变换矩阵的 X 坐标剪切元素 (m01)。
    double
    getShearY()
    返回 3x3 仿射变换矩阵的 Y 坐标剪切元素 (m10)。
    static AffineTransform
    getTranslateInstance(double tx, double ty)
    返回表示翻译转换的转换。
    double
    getTranslateX()
    返回 3x3 仿射变换矩阵的平移元素 (m02) 的 X 坐标。
    double
    getTranslateY()
    返回 3x3 仿射变换矩阵的平移元素 (m12) 的 Y 坐标。
    int
    getType()
    检索描述此转换的转换属性的标志位。
    int
    hashCode()
    返回此转换的哈希码。
    void
    inverseTransform(double[] srcPts, int srcOff, double[] dstPts, int dstOff, int numPts)
    通过此变换对双精度坐标数组进行逆变换。
    Point2D
    inverseTransform(Point2D ptSrc, Point2D ptDst)
    对指定的 ptSrc 进行逆变换并将结果存储在 ptDst 中。
    void
    invert()
    将此变换设置为其自身的逆。
    boolean
    isIdentity()
    如果此 AffineTransform 是身份转换，则返回 true。
    void
    preConcatenate(AffineTransform Tx)
    以不太常用的方式将 AffineTransform Tx 连接到此 AffineTransform Cx，以便 Tx 修改相对于绝对像素空间而不是相对于现有用户空间的坐标变换。
    void
    quadrantRotate(int numquadrants)
    将此变换与按指定数量的象限旋转坐标的变换连接。
    void
    quadrantRotate(int numquadrants, double anchorx, double anchory)
    将此变换与围绕指定锚点按指定数量的象限旋转坐标的变换连接起来。
    void
    rotate(double theta)
    将此变换与旋转变换连接起来。
    void
    rotate(double vecx, double vecy)
    将此变换与根据旋转向量旋转坐标的变换连接起来。
    void
    rotate(double theta, double anchorx, double anchory)
    将此变换与围绕锚点旋转坐标的变换连接起来。
    void
    rotate(double vecx, double vecy, double anchorx, double anchory)
    将此变换与根据旋转向量围绕锚点旋转坐标的变换连接起来。
    void
    scale(double sx, double sy)
    将此转换与缩放转换连接起来。
    void
    setToIdentity()
    将此转换重置为恒等转换。
    void
    setToQuadrantRotation(int numquadrants)
    将此变换设置为旋转变换，将坐标旋转指定数量的象限。
    void
    setToQuadrantRotation(int numquadrants, double anchorx, double anchory)
    将此变换设置为平移旋转变换，该变换将坐标围绕指定锚点旋转指定数量的象限。
    void
    setToRotation(double theta)
    将此变换设置为旋转变换。
    void
    setToRotation(double vecx, double vecy)
    将此变换设置为根据旋转向量旋转坐标的旋转变换。
    void
    setToRotation(double theta, double anchorx, double anchory)
    将此变换设置为平移的旋转变换。
    void
    setToRotation(double vecx, double vecy, double anchorx, double anchory)
    将此变换设置为旋转变换，根据旋转矢量围绕锚点旋转坐标。
    void
    setToScale(double sx, double sy)
    将此变换设置为缩放变换。
    void
    setToShear(double shx, double shy)
    将此变换设置为剪切变换。
    void
    setToTranslation(double tx, double ty)
    将此转换设置为平移转换。
    void
    setTransform(double m00, double m10, double m01, double m11, double m02, double m12)
    将此转换设置为由 6 个双精度值指定的矩阵。
    void
    setTransform(AffineTransform Tx)
    将此转换设置为指定 AffineTransform 对象中转换的副本。
    void
    shear(double shx, double shy)
    将此变换与剪切变换连接起来。
    String
    toString()
    返回表示此 Object 值的 String。
    void
    transform(double[] srcPts, int srcOff, double[] dstPts, int dstOff, int numPts)
    通过此转换转换双精度坐标数组。
    void
    transform(double[] srcPts, int srcOff, float[] dstPts, int dstOff, int numPts)
    通过此转换转换双精度坐标数组，并将结果存储到浮点数数组中。
    void
    transform(float[] srcPts, int srcOff, double[] dstPts, int dstOff, int numPts)
    通过此转换转换浮点坐标数组，并将结果存储到双精度数组中。
    void
    transform(float[] srcPts, int srcOff, float[] dstPts, int dstOff, int numPts)
    通过此转换转换浮点坐标数组。
    void
    transform(Point2D[] ptSrc, int srcOff, Point2D[] ptDst, int dstOff, int numPts)
    通过此变换变换点对象数组。
    Point2D
    transform(Point2D ptSrc, Point2D ptDst)
    转换指定的 ptSrc 并将结果存储在 ptDst 中。
    void
    translate(double tx, double ty)
    将此转换与翻译转换连接起来。

    在类 java.lang.Object 中声明的方法

    finalize, getClass, notify, notifyAll, wait, wait, wait

  • 字段详细信息

  • 构造方法详细信息

    • AffineTransform

      public AffineTransform()
      构造一个新的 AffineTransform 表示身份转换。
      自从：
      1.2

    • AffineTransform

      public AffineTransform(AffineTransform  Tx)
      构造一个新的 AffineTransform，它是指定 AffineTransform 对象的副本。
      参数：
      Tx - 要复制的 AffineTransform 对象
      自从：
      1.2

    • AffineTransform

      @ConstructorProperties ({"scaleX","shearY","shearX","scaleY","translateX","translateY"}) public AffineTransform(float m00, float m10, float m01, float m11, float m02, float m12)
      从表示 3x3 变换矩阵的 6 个可指定条目的 6 个浮点值构造一个新的 AffineTransform。
      参数：
      m00 - 3x3 矩阵的 X 坐标缩放元素
      m10 - 3x3矩阵的Y坐标剪切元素
      m01 - 3x3矩阵的X坐标剪切元素
      m11 - 3x3 矩阵的 Y 坐标缩放元素
      m02 - 3x3 矩阵的 X 坐标平移元素
      m12 - 3x3 矩阵的 Y 坐标平移元素
      自从：
      1.2

    • AffineTransform

      public AffineTransform(float[] flatmatrix)
      从代表 3x3 变换矩阵的 4 个非翻译条目或 6 个可指定条目的浮点值数组构造一个新的 AffineTransform。这些值从数组中检索为 { m00 m10 m01 m11 [m02 m12]}。
      参数：
      flatmatrix - 包含要在新 AffineTransform 对象中设置的值的浮点数组。假定数组的长度至少为 4。如果数组的长度小于 6，则只取前 4 个值。如果数组的长度大于 6，则取前 6 个值。
      自从：
      1.2

    • AffineTransform

      public AffineTransform(double m00, double m10, double m01, double m11, double m02, double m12)
      从表示 3x3 变换矩阵的 6 个可指定条目的 6 个双精度值构造一个新的 AffineTransform。
      参数：
      m00 - 3x3 矩阵的 X 坐标缩放元素
      m10 - 3x3矩阵的Y坐标剪切元素
      m01 - 3x3矩阵的X坐标剪切元素
      m11 - 3x3 矩阵的 Y 坐标缩放元素
      m02 - 3x3 矩阵的 X 坐标平移元素
      m12 - 3x3 矩阵的 Y 坐标平移元素
      自从：
      1.2

    • AffineTransform

      public AffineTransform(double[] flatmatrix)
      从代表 3x3 变换矩阵的 4 个非翻译条目或 6 个可指定条目的双精度值数组构造一个新的 AffineTransform。这些值从数组中检索为 { m00 m10 m01 m11 [m02 m12]}。
      参数：
      flatmatrix - 包含要在新 AffineTransform 对象中设置的值的双精度数组。假定数组的长度至少为 4。如果数组的长度小于 6，则只取前 4 个值。如果数组的长度大于 6，则取前 6 个值。
      自从：
      1.2

  • 方法详情

    • getTranslateInstance

      public static AffineTransform  getTranslateInstance(double tx, double ty)
      返回表示翻译转换的转换。表示返回变换的矩阵是： 
           [  1  0  tx ]
     [  0  1  ty ]
     [  0  0  1  ]
      参数：
      tx - 坐标在 X 轴方向平移的距离
      ty - 坐标在 Y 轴方向平移的距离
      返回：
      一个 AffineTransform 对象，代表一个翻译转换，用指定的向量创建。
      自从：
      1.2

    • getRotateInstance

      public static AffineTransform  getRotateInstance(double theta)
      返回表示旋转变换的变换。表示返回变换的矩阵是： 
           [  cos(theta)  -sin(theta)  0  ]
     [  sin(theta)   cos(theta)  0  ]
     [    0       0     1  ]
      旋转正角度 theta 会将正 X 轴上的点旋转到正 Y 轴。另请注意上面对 处理 90 度旋转 的讨论。
      参数：
      theta - 以弧度测量的旋转角度
      返回：
      一个 AffineTransform 对象，它是一个旋转变换，以指定的旋转角度创建。
      自从：
      1.2

    • getRotateInstance

      public static AffineTransform  getRotateInstance(double theta, double anchorx, double anchory)
      返回围绕锚点旋转坐标的变换。这个操作相当于平移坐标，使锚点在原点（S1），然后绕新原点（S2）旋转，最后平移，使中间原点恢复到原锚点的坐标(S3)。

      此操作等效于以下调用序列：

         AffineTransform Tx = new AffineTransform();
   Tx.translate(anchorx, anchory);  // S3: final translation
   Tx.rotate(theta);         // S2: rotate around anchor
   Tx.translate(-anchorx, -anchory); // S1: translate anchor to origin
      表示返回变换的矩阵是： 
           [  cos(theta)  -sin(theta)  x-x*cos+y*sin ]
     [  sin(theta)   cos(theta)  y-x*sin-y*cos ]
     [    0       0        1    ]
      旋转正角度 theta 会将正 X 轴上的点旋转到正 Y 轴。另请注意上面对 处理 90 度旋转 的讨论。
      参数：
      theta - 以弧度测量的旋转角度
      anchorx - 旋转锚点的X坐标
      anchory - 旋转锚点的Y坐标
      返回：
      一个 AffineTransform 对象，它以指定的旋转角度围绕指定点旋转坐标。
      自从：
      1.2

    • getRotateInstance

      public static AffineTransform  getRotateInstance(double vecx, double vecy)
      返回根据旋转向量旋转坐标的变换。所有坐标都围绕原点旋转相同的量。旋转量使得沿前一个正 X 轴的坐标随后与从原点指向指定矢量坐标的矢量对齐。如果 vecx 和 vecy 都为 0.0，则返回恒等变换。这个操作相当于调用： 
         AffineTransform.getRotateInstance(Math.atan2(vecy, vecx));
      参数：
      vecx - 旋转向量的X坐标
      vecy - 旋转向量的Y坐标
      返回：
      根据指定的旋转向量旋转坐标的 AffineTransform 对象。
      自从：
      1.6

    • getRotateInstance

      public static AffineTransform  getRotateInstance(double vecx, double vecy, double anchorx, double anchory)
      返回根据旋转向量围绕锚点旋转坐标的变换。所有坐标都围绕指定的锚点坐标旋转相同的量。旋转量使得沿前一个正 X 轴的坐标随后与从原点指向指定矢量坐标的矢量对齐。如果 vecx 和 vecy 都为 0.0，则返回恒等变换。这个操作相当于调用： 
         AffineTransform.getRotateInstance(Math.atan2(vecy, vecx),
                    anchorx, anchory);
      参数：
      vecx - 旋转向量的X坐标
      vecy - 旋转向量的Y坐标
      anchorx - 旋转锚点的X坐标
      anchory - 旋转锚点的Y坐标
      返回：
      一个 AffineTransform 对象，它根据指定的旋转向量围绕指定点旋转坐标。
      自从：
      1.6

    • getQuadrantRotateInstance

      public static AffineTransform  getQuadrantRotateInstance(int numquadrants)
      返回按指定数量的象限旋转坐标的变换。此操作等效于调用： 
         AffineTransform.getRotateInstance(numquadrants * Math.PI / 2.0);
      旋转正数象限将正 X 轴上的点向正 Y 轴旋转。
      参数：
      numquadrants - 要旋转的 90 度弧的数量
      返回：
      一个 AffineTransform 对象，它按指定的象限数旋转坐标。
      自从：
      1.6

    • getQuadrantRotateInstance

      public static AffineTransform  getQuadrantRotateInstance(int numquadrants, double anchorx, double anchory)
      返回一个变换，该变换将坐标围绕指定锚点旋转指定数量的象限。此操作等效于调用： 
         AffineTransform.getRotateInstance(numquadrants * Math.PI / 2.0,
                    anchorx, anchory);
      旋转正数象限将正 X 轴上的点向正 Y 轴旋转。
      参数：
      numquadrants - 要旋转的 90 度弧的数量
      anchorx - 旋转锚点的X坐标
      anchory - 旋转锚点的Y坐标
      返回：
      一个 AffineTransform 对象，它围绕指定锚点将坐标旋转指定数量的象限。
      自从：
      1.6

    • getScaleInstance

      public static AffineTransform  getScaleInstance(double sx, double sy)
      返回表示缩放变换的变换。表示返回变换的矩阵是： 
           [  sx  0  0  ]
     [  0  sy  0  ]
     [  0  0  1  ]
      参数：
      sx - 坐标沿 X 轴方向缩放的因子
      sy - 坐标沿 Y 轴方向缩放的因子
      返回：
      一个 AffineTransform 对象，它按指定的因子缩放坐标。
      自从：
      1.2

    • getShearInstance

      public static AffineTransform  getShearInstance(double shx, double shy)
      返回表示剪切变换的变换。表示返回变换的矩阵是： 
           [  1  shx  0  ]
     [ shy  1  0  ]
     [  0  0  1  ]
      参数：
      shx - 坐标在正 X 轴方向上移动的乘数，作为其 Y 坐标的因数
      shy - 坐标在正 Y 轴方向上移动的乘数，作为其 X 坐标的一个因子
      返回：
      一个 AffineTransform 对象，它按指定的乘数剪切坐标。
      自从：
      1.2

    • getType

      public int getType()
      检索描述此转换的转换属性的标志位。返回值是常量 TYPE_IDENTITY 或 TYPE_GENERAL_TRANSFORM 之一，或者是适当标志位的组合。标志位的有效组合是异或运算，除了 TYPE_UNIFORM_SCALE 或 TYPE_GENERAL_SCALE 标志位以及 TYPE_QUADRANT_ROTATION 或 TYPE_GENERAL_ROTATION 标志位之外，还可以组合 TYPE_TRANSLATION 标志位。
      返回：
      适用于此转换的任何指示标志的 OR 组合
      自从：
      1.2
      参见：

    • getDeterminant

      public double getDeterminant()
      返回变换的矩阵表示的行列式。行列式既可用于确定变换是否可以反转，也可用于获得表示变换的组合 X 和 Y 缩放比例的单个值。

      如果行列式非零，则此变换是可逆的，并且依赖于逆变换的各种方法不需要抛出 NoninvertibleTransformException 。如果行列式为零，则此变换无法反转，因为变换将所有输入坐标映射到一条线或一个点上。如果行列式足够接近零，则逆变换操作可能无法提供足够的精度来产生有意义的结果。

      如果此变换表示统一比例，如 getType 方法所示，则行列式也表示统一比例因子的平方，所有点都通过该比例因子从原点扩展或收缩。如果此变换表示非均匀比例或更一般的变换，则行列式不太可能表示对除确定逆变换是否可能以外的任何目的有用的值。

      在数学上，行列式是使用以下公式计算的：

           | m00 m01 m02 |
     | m10 m11 m12 | = m00 * m11 - m01 * m10
     |  0  0  1  |
      返回：
      用于变换坐标的矩阵的行列式。
      自从：
      1.2
      参见：

    • getMatrix

      public void getMatrix(double[] flatmatrix)
      检索 3x3 仿射变换矩阵中的 6 个可指定值，并将它们放入双精度值数组中。这些值以 { m00 m10 m01 m11 m02 m12 } 的形式存储在数组中。还可以指定一个包含 4 个双精度数的数组，在这种情况下，仅检索表示数组的非转换部分的前四个元素，并将值存储到数组中，如 { m00 m10 m01 m11 }
      参数：
      flatmatrix - 用于存储返回值的双精度数组。
      自从：
      1.2
      参见：

    • getScaleX

      public double getScaleX()
      返回 3x3 仿射变换矩阵的 m00 元素。该矩阵因子确定输入 X 坐标将如何影响输出 X 坐标，并且是变换比例的一个元素。要测量此变换拉伸或收缩 X 坐标的全部量，请使用以下代码： 
         Point2D p = new Point2D.Double(1, 0);
   p = tx.deltaTransform(p, p);
   double scaleX = p.distance(0, 0);
      返回：
      一个双精度值，它是 3x3 仿射变换矩阵的 m00 元素。
      自从：
      1.2
      参见：

    • getScaleY

      public double getScaleY()
      返回 3x3 仿射变换矩阵的 m11 元素。此矩阵因子确定输入 Y 坐标将如何影响输出 Y 坐标，并且是变换比例的一个元素。要测量此变换拉伸或收缩 Y 坐标的全部量，请使用以下代码： 
         Point2D p = new Point2D.Double(0, 1);
   p = tx.deltaTransform(p, p);
   double scaleY = p.distance(0, 0);
      返回：
      一个双精度值，它是 3x3 仿射变换矩阵的 m11 元素。
      自从：
      1.2
      参见：

    • getShearX

      public double getShearX()
      返回 3x3 仿射变换矩阵的 X 坐标剪切元素 (m01)。
      返回：
      一个 double 值，它是仿射变换矩阵的剪切元素的 X 坐标。
      自从：
      1.2
      参见：

    • getShearY

      public double getShearY()
      返回 3x3 仿射变换矩阵的 Y 坐标剪切元素 (m10)。
      返回：
      一个 double 值，它是仿射变换矩阵的剪切元素的 Y 坐标。
      自从：
      1.2
      参见：

    • getTranslateX

      public double getTranslateX()
      返回 3x3 仿射变换矩阵的平移元素 (m02) 的 X 坐标。
      返回：
      一个 double 值，它是仿射变换矩阵的平移元素的 X 坐标。
      自从：
      1.2
      参见：

    • getTranslateY

      public double getTranslateY()
      返回 3x3 仿射变换矩阵的平移元素 (m12) 的 Y 坐标。
      返回：
      一个 double 值，它是仿射变换矩阵的平移元素的 Y 坐标。
      自从：
      1.2
      参见：

    • translate

      public void translate(double tx, double ty)
      将此转换与翻译转换连接起来。这等效于调用 concatenate(T)，其中 T 是由以下矩阵表示的 AffineTransform： 
           [  1  0  tx ]
     [  0  1  ty ]
     [  0  0  1  ]
      参数：
      tx - 坐标在 X 轴方向平移的距离
      ty - 坐标在 Y 轴方向平移的距离
      自从：
      1.2

    • rotate

      public void rotate(double theta)
      将此变换与旋转变换连接起来。这等效于调用 concatenate(R)，其中 R 是由以下矩阵表示的 AffineTransform： 
           [  cos(theta)  -sin(theta)  0  ]
     [  sin(theta)   cos(theta)  0  ]
     [    0       0     1  ]
      旋转正角度 theta 会将正 X 轴上的点旋转到正 Y 轴。另请注意上面对 处理 90 度旋转 的讨论。
      参数：
      theta - 以弧度测量的旋转角度
      自从：
      1.2

    • rotate

      public void rotate(double theta, double anchorx, double anchory)
      将此变换与围绕锚点旋转坐标的变换连接起来。这个操作相当于平移坐标，使锚点在原点（S1），然后绕新原点（S2）旋转，最后平移，使中间原点恢复到原锚点的坐标(S3)。

      此操作等效于以下调用序列：

         translate(anchorx, anchory);   // S3: final translation
   rotate(theta);          // S2: rotate around anchor
   translate(-anchorx, -anchory);  // S1: translate anchor to origin
      旋转正角度 theta 会将正 X 轴上的点旋转到正 Y 轴。另请注意上面对 处理 90 度旋转 的讨论。
      参数：
      theta - 以弧度测量的旋转角度
      anchorx - 旋转锚点的X坐标
      anchory - 旋转锚点的Y坐标
      自从：
      1.2

    • rotate

      public void rotate(double vecx, double vecy)
      将此变换与根据旋转向量旋转坐标的变换连接起来。所有坐标都围绕原点旋转相同的量。旋转量使得沿前一个正 X 轴的坐标随后与从原点指向指定矢量坐标的矢量对齐。如果 vecx 和 vecy 均为 0.0，则不会向此变换添加额外的旋转。这个操作相当于调用： 
           rotate(Math.atan2(vecy, vecx));
      参数：
      vecx - 旋转向量的X坐标
      vecy - 旋转向量的Y坐标
      自从：
      1.6

    • rotate

      public void rotate(double vecx, double vecy, double anchorx, double anchory)
      将此变换与根据旋转向量围绕锚点旋转坐标的变换连接起来。所有坐标都围绕指定的锚点坐标旋转相同的量。旋转量使得沿前一个正 X 轴的坐标随后与从原点指向指定矢量坐标的矢量对齐。如果 vecx 和 vecy 均为 0.0，则不会以任何方式修改转换。这个方法相当于调用： 
         rotate(Math.atan2(vecy, vecx), anchorx, anchory);
      参数：
      vecx - 旋转向量的X坐标
      vecy - 旋转向量的Y坐标
      anchorx - 旋转锚点的X坐标
      anchory - 旋转锚点的Y坐标
      自从：
      1.6

    • quadrantRotate

      public void quadrantRotate(int numquadrants)
      将此变换与按指定数量的象限旋转坐标的变换连接。这相当于调用： 
         rotate(numquadrants * Math.PI / 2.0);
      旋转正数的象限将正 X 轴上的点旋转到正 Y 轴。
      参数：
      numquadrants - 要旋转的 90 度弧的数量
      自从：
      1.6

    • quadrantRotate

      public void quadrantRotate(int numquadrants, double anchorx, double anchory)
      将此变换与围绕指定锚点按指定数量的象限旋转坐标的变换连接起来。此方法等效于调用： 
         rotate(numquadrants * Math.PI / 2.0, anchorx, anchory);
      旋转正数象限将正 X 轴上的点向正 Y 轴旋转。
      参数：
      numquadrants - 要旋转的 90 度弧的数量
      anchorx - 旋转锚点的X坐标
      anchory - 旋转锚点的Y坐标
      自从：
      1.6

    • scale

      public void scale(double sx, double sy)
      将此转换与缩放转换连接起来。这等效于调用 concatenate(S)，其中 S 是由以下矩阵表示的 AffineTransform： 
           [  sx  0  0  ]
     [  0  sy  0  ]
     [  0  0  1  ]
      参数：
      sx - 坐标沿 X 轴方向缩放的因子
      sy - 坐标沿 Y 轴方向缩放的因子
      自从：
      1.2

    • shear

      public void shear(double shx, double shy)
      将此变换与剪切变换连接起来。这相当于调用 concatenate(SH)，其中 SH 是由以下矩阵表示的 AffineTransform： 
           [  1  shx  0  ]
     [ shy  1  0  ]
     [  0  0  1  ]
      参数：
      shx - 坐标在正 X 轴方向上移动的乘数，作为其 Y 坐标的因数
      shy - 坐标在正 Y 轴方向上移动的乘数，作为其 X 坐标的一个因子
      自从：
      1.2

    • setToIdentity

      public void setToIdentity()
      将此转换重置为恒等转换。
      自从：
      1.2

    • setToTranslation

      public void setToTranslation(double tx, double ty)
      将此转换设置为平移转换。表示此变换的矩阵变为： 
           [  1  0  tx ]
     [  0  1  ty ]
     [  0  0  1  ]
      参数：
      tx - 坐标在 X 轴方向平移的距离
      ty - 坐标在 Y 轴方向平移的距离
      自从：
      1.2

    • setToRotation

      public void setToRotation(double theta)
      将此变换设置为旋转变换。表示此变换的矩阵变为： 
           [  cos(theta)  -sin(theta)  0  ]
     [  sin(theta)   cos(theta)  0  ]
     [    0       0     1  ]
      旋转正角度 theta 会将正 X 轴上的点旋转到正 Y 轴。另请注意上面对 处理 90 度旋转 的讨论。
      参数：
      theta - 以弧度测量的旋转角度
      自从：
      1.2

    • setToRotation

      public void setToRotation(double theta, double anchorx, double anchory)
      将此变换设置为平移的旋转变换。这个操作相当于平移坐标，使锚点在原点（S1），然后绕新原点（S2）旋转，最后平移，使中间原点恢复到原锚点的坐标(S3)。

      此操作等效于以下调用序列：

         setToTranslation(anchorx, anchory); // S3: final translation
   rotate(theta);           // S2: rotate around anchor
   translate(-anchorx, -anchory);   // S1: translate anchor to origin
      表示此变换的矩阵变为： 
           [  cos(theta)  -sin(theta)  x-x*cos+y*sin ]
     [  sin(theta)   cos(theta)  y-x*sin-y*cos ]
     [    0       0        1    ]
      旋转正角度 theta 会将正 X 轴上的点旋转到正 Y 轴。另请注意上面对 处理 90 度旋转 的讨论。
      参数：
      theta - 以弧度测量的旋转角度
      anchorx - 旋转锚点的X坐标
      anchory - 旋转锚点的Y坐标
      自从：
      1.2

    • setToRotation

      public void setToRotation(double vecx, double vecy)
      将此变换设置为根据旋转向量旋转坐标的旋转变换。所有坐标都围绕原点旋转相同的量。旋转量使得沿前一个正 X 轴的坐标随后与从原点指向指定矢量坐标的矢量对齐。如果 vecx 和 vecy 均为 0.0，则转换设置为恒等转换。这个操作相当于调用： 
         setToRotation(Math.atan2(vecy, vecx));
      参数：
      vecx - 旋转向量的X坐标
      vecy - 旋转向量的Y坐标
      自从：
      1.6

    • setToRotation

      public void setToRotation(double vecx, double vecy, double anchorx, double anchory)
      将此变换设置为旋转变换，根据旋转矢量围绕锚点旋转坐标。所有坐标都围绕指定的锚点坐标旋转相同的量。旋转量使得沿前一个正 X 轴的坐标随后与从原点指向指定矢量坐标的矢量对齐。如果 vecx 和 vecy 均为 0.0，则转换设置为恒等转换。这个操作相当于调用： 
         setToTranslation(Math.atan2(vecy, vecx), anchorx, anchory);
      参数：
      vecx - 旋转向量的X坐标
      vecy - 旋转向量的Y坐标
      anchorx - 旋转锚点的X坐标
      anchory - 旋转锚点的Y坐标
      自从：
      1.6

    • setToQuadrantRotation

      public void setToQuadrantRotation(int numquadrants)
      将此变换设置为旋转变换，将坐标旋转指定数量的象限。此操作等效于调用： 
         setToRotation(numquadrants * Math.PI / 2.0);
      旋转正数象限将正 X 轴上的点向正 Y 轴旋转。
      参数：
      numquadrants - 要旋转的 90 度弧的数量
      自从：
      1.6

    • setToQuadrantRotation

      public void setToQuadrantRotation(int numquadrants, double anchorx, double anchory)
      将此变换设置为平移旋转变换，该变换将坐标围绕指定锚点旋转指定数量的象限。此操作等效于调用： 
         setToRotation(numquadrants * Math.PI / 2.0, anchorx, anchory);
      旋转正数象限将正 X 轴上的点向正 Y 轴旋转。
      参数：
      numquadrants - 要旋转的 90 度弧的数量
      anchorx - 旋转锚点的X坐标
      anchory - 旋转锚点的Y坐标
      自从：
      1.6

    • setToScale

      public void setToScale(double sx, double sy)
      将此变换设置为缩放变换。表示此变换的矩阵变为： 
           [  sx  0  0  ]
     [  0  sy  0  ]
     [  0  0  1  ]
      参数：
      sx - 坐标沿 X 轴方向缩放的因子
      sy - 坐标沿 Y 轴方向缩放的因子
      自从：
      1.2

    • setToShear

      public void setToShear(double shx, double shy)
      将此变换设置为剪切变换。表示此变换的矩阵变为： 
           [  1  shx  0  ]
     [ shy  1  0  ]
     [  0  0  1  ]
      参数：
      shx - 坐标在正 X 轴方向上移动的乘数，作为其 Y 坐标的因数
      shy - 坐标在正 Y 轴方向上移动的乘数，作为其 X 坐标的一个因子
      自从：
      1.2

    • setTransform

      public void setTransform(AffineTransform  Tx)
      将此转换设置为指定 AffineTransform 对象中转换的副本。
      参数：
      Tx - 从中复制转换的 AffineTransform 对象
      自从：
      1.2

    • setTransform

      public void setTransform(double m00, double m10, double m01, double m11, double m02, double m12)
      将此转换设置为由 6 个双精度值指定的矩阵。
      参数：
      m00 - 3x3 矩阵的 X 坐标缩放元素
      m10 - 3x3矩阵的Y坐标剪切元素
      m01 - 3x3矩阵的X坐标剪切元素
      m11 - 3x3 矩阵的 Y 坐标缩放元素
      m02 - 3x3 矩阵的 X 坐标平移元素
      m12 - 3x3 矩阵的 Y 坐标平移元素
      自从：
      1.2

    • concatenate

      public void concatenate(AffineTransform  Tx)
      以最常用的方式将 AffineTransform Tx 连接到此 AffineTransform Cx，以提供由 Tx 映射到先前用户空间的新用户空间。更新 Cx 以执行组合转换。用更新后的变换 Cx' 变换点 p 相当于先用 Tx 变换 p，然后用原始变换 Cx 变换结果，如下所示： Cx'(p) = Cx(Tx(p)) 在矩阵表示法中，如果这个变换 Cx 由矩阵 [this] 表示，Tx 由矩阵 [Tx] 表示，然后此方法执行以下操作： 
           [this] = [this] x [Tx]
      参数：
      Tx - 要与此 AffineTransform 对象连接的 AffineTransform 对象。
      自从：
      1.2
      参见：

    • preConcatenate

      public void preConcatenate(AffineTransform  Tx)
      以不太常用的方式将 AffineTransform Tx 连接到此 AffineTransform Cx，以便 Tx 修改相对于绝对像素空间而不是相对于现有用户空间的坐标变换。更新 Cx 以执行组合转换。通过更新的变换 Cx' 变换点 p 相当于首先通过原始变换 Cx 变换 p，然后通过 Tx 变换结果，如下所示： Cx'(p) = Tx(Cx(p)) 在矩阵表示法中，如果这个变换 Cx 由矩阵 [this] 表示，Tx 由矩阵 [Tx] 表示，然后此方法执行以下操作： 
           [this] = [Tx] x [this]
      参数：
      Tx - 要与此 AffineTransform 对象连接的 AffineTransform 对象。
      自从：
      1.2
      参见：

    • createInverse

      public AffineTransform  createInverse() throws NoninvertibleTransformException
      返回表示逆变换的 AffineTransform 对象。该变换 Tx 的逆变换 Tx' 将 Tx 变换后的坐标映射回其原始坐标。换句话说，Tx'(Tx(p)) = p = Tx(Tx'(p))。

      如果此变换将所有坐标映射到一个点或一条线上，那么它不会有逆映射，因为不在目标点或线上的坐标不会有逆映射。 getDeterminant 方法可用于确定此转换是否没有逆，在这种情况下，如果调用 createInverse 方法将抛出异常。

      返回：
      表示逆变换的新 AffineTransform 对象。
      抛出：
      NoninvertibleTransformException - 如果矩阵不能反转。
      自从：
      1.2
      参见：

    • invert

      public void invert() throws NoninvertibleTransformException
      将此变换设置为其自身的逆。该变换 Tx 的逆变换 Tx' 将 Tx 变换后的坐标映射回其原始坐标。换句话说，Tx'(Tx(p)) = p = Tx(Tx'(p))。

      如果此变换将所有坐标映射到一个点或一条线上，那么它不会有逆映射，因为不在目标点或线上的坐标不会有逆映射。 getDeterminant 方法可用于确定此转换是否没有逆，在这种情况下，如果调用 invert 方法将抛出异常。

      抛出：
      NoninvertibleTransformException - 如果矩阵不能反转。
      自从：
      1.6
      参见：

    • transform

      public Point2D  transform(Point2D  ptSrc, Point2D  ptDst)
      转换指定的 ptSrc 并将结果存储在 ptDst 中。如果 ptDst 为 null ，则分配一个新的 Point2D 对象，然后将转换结果存储在该对象中。在任何一种情况下，为方便起见，返回包含转换点的 ptDst。如果 ptSrc 和 ptDst 是同一个对象，输入点将被转换后的点正确覆盖。
      参数：
      ptSrc - 要转换的指定 Point2D
      ptDst - 存储转换 ptSrc 结果的指定 Point2D
      返回：
      转换 ptSrc 并将结果存储在 ptDst 之后的 ptDst。
      自从：
      1.2

    • transform

      public void transform(Point2D [] ptSrc, int srcOff, Point2D [] ptDst, int dstOff, int numPts)
      通过此变换变换点对象数组。如果 ptDst 数组的任何元素是 null ，则在存储转换结果之前分配一个新的 Point2D 对象并将其存储到该元素中。

      请注意，此方法不采取任何预防措施来避免将结果存储到 Point2D 对象中而引起的问题，这些对象将用作源数组下方计算的源。此方法确实保证如果指定的 Point2D 对象既是同一单点变换操作的源又是目标，则在计算完成之前不会存储结果，以避免将结果存储在操作数之上。但是，如果一个操作的目标 Point2D 对象与源数组下方另一操作的源 Point2D 对象是同一对象，则该点中的原始坐标将在转换之前被覆盖。

      参数：
      ptSrc - 包含源点对象的数组
      srcOff - 源数组中要转换的第一个点对象的偏移量
      ptDst - 变换点对象返回到的数组
      dstOff - 存储在目标数组中的第一个变换点对象位置的偏移量
      numPts - 要变换的点对象的数量
      自从：
      1.2

    • transform

      public void transform(float[] srcPts, int srcOff, float[] dstPts, int dstOff, int numPts)
      通过此转换转换浮点坐标数组。两个坐标数组部分可以完全相同，也可以是同一数组的重叠部分，而不影响结果的有效性。此方法可确保源坐标在转换之前不会被先前的操作覆盖。坐标存储在数组中，从指定偏移量开始，顺序为 [x0, y0, x1, y1, ..., xn, yn] 。
      参数：
      srcPts - 包含源点坐标的数组。每个点都存储为一对 x、y 坐标。
      srcOff - 源数组中要转换的第一个点的偏移量
      dstPts - 返回变换后的点坐标的数组。每个点都存储为一对 x、y 坐标。
      dstOff - 存储在目标数组中的第一个变换点位置的偏移量
      numPts - 要转换的点数
      自从：
      1.2

    • transform

      public void transform(double[] srcPts, int srcOff, double[] dstPts, int dstOff, int numPts)
      通过此转换转换双精度坐标数组。两个坐标数组部分可以完全相同，也可以是同一数组的重叠部分，而不影响结果的有效性。此方法可确保源坐标在转换之前不会被先前的操作覆盖。坐标存储在数组中，从指示的偏移量开始，顺序为 [x0, y0, x1, y1, ..., xn, yn]。
      参数：
      srcPts - 包含源点坐标的数组。每个点都存储为一对 x、y 坐标。
      srcOff - 源数组中要转换的第一个点的偏移量
      dstPts - 返回变换后的点坐标的数组。每个点都存储为一对 x、y 坐标。
      dstOff - 存储在目标数组中的第一个变换点位置的偏移量
      numPts - 要变换的点对象的数量
      自从：
      1.2

    • transform

      public void transform(float[] srcPts, int srcOff, double[] dstPts, int dstOff, int numPts)
      通过此转换转换浮点坐标数组，并将结果存储到双精度数组中。坐标存储在数组中，从指定偏移量开始，顺序为 [x0, y0, x1, y1, ..., xn, yn] 。
      参数：
      srcPts - 包含源点坐标的数组。每个点都存储为一对 x、y 坐标。
      srcOff - 源数组中要转换的第一个点的偏移量
      dstPts - 返回变换后的点坐标的数组。每个点都存储为一对 x、y 坐标。
      dstOff - 存储在目标数组中的第一个变换点位置的偏移量
      numPts - 要转换的点数
      自从：
      1.2

    • transform

      public void transform(double[] srcPts, int srcOff, float[] dstPts, int dstOff, int numPts)
      通过此转换转换双精度坐标数组，并将结果存储到浮点数数组中。坐标存储在数组中，从指定偏移量开始，顺序为 [x0, y0, x1, y1, ..., xn, yn] 。
      参数：
      srcPts - 包含源点坐标的数组。每个点都存储为一对 x、y 坐标。
      srcOff - 源数组中要转换的第一个点的偏移量
      dstPts - 返回变换后的点坐标的数组。每个点都存储为一对 x、y 坐标。
      dstOff - 存储在目标数组中的第一个变换点位置的偏移量
      numPts - 要变换的点对象的数量
      自从：
      1.2

    • inverseTransform

      public Point2D  inverseTransform(Point2D  ptSrc, Point2D  ptDst) throws NoninvertibleTransformException
      对指定的 ptSrc 进行逆变换并将结果存储在 ptDst 中。如果 ptDst 为 null ，则分配一个新的 Point2D 对象，然后将转换结果存储在该对象中。在任何一种情况下，为方便起见，返回包含转换点的 ptDst。如果 ptSrc 和 ptDst 是同一个对象，输入点将被转换后的点正确覆盖。
      参数：
      ptSrc - 要进行逆变换的点
      ptDst - 生成的变换点
      返回：
      ptDst ，其中包含逆变换的结果。
      抛出：
      NoninvertibleTransformException - 如果矩阵不能反转。
      自从：
      1.2

    • inverseTransform

      public void inverseTransform(double[] srcPts, int srcOff, double[] dstPts, int dstOff, int numPts) throws NoninvertibleTransformException
      通过此变换对双精度坐标数组进行逆变换。两个坐标数组部分可以完全相同，也可以是同一数组的重叠部分，而不影响结果的有效性。此方法可确保源坐标在转换之前不会被先前的操作覆盖。坐标存储在数组中，从指定偏移量开始，顺序为 [x0, y0, x1, y1, ..., xn, yn] 。
      参数：
      srcPts - 包含源点坐标的数组。每个点都存储为一对 x、y 坐标。
      srcOff - 源数组中要转换的第一个点的偏移量
      dstPts - 返回变换后的点坐标的数组。每个点都存储为一对 x、y 坐标。
      dstOff - 存储在目标数组中的第一个变换点位置的偏移量
      numPts - 要变换的点对象的数量
      抛出：
      NoninvertibleTransformException - 如果矩阵不能反转。
      自从：
      1.2

    • deltaTransform

      public Point2D  deltaTransform(Point2D  ptSrc, Point2D  ptDst)
      转换 ptSrc 指定的相对距离向量并将结果存储在 ptDst 中。使用以下等式在不应用仿射变换矩阵的平移组件的情况下对相对距离向量进行变换： 
       [ x' ]  [ m00 m01 (m02) ] [ x ]  [ m00x + m01y ]
 [ y' ] = [ m10 m11 (m12) ] [ y ] = [ m10x + m11y ]
 [ (1) ]  [ (0) (0) ( 1 ) ] [ (1) ]  [   (1)   ]
      如果 ptDst 为 null，则分配一个新的 Point2D 对象，然后将变换结果存储在该对象中。在任何一种情况下，为方便起见，返回包含转换点的 ptDst。如果 ptSrc 和 ptDst 是同一个对象，输入点将被转换后的点正确覆盖。
      参数：
      ptSrc - 要进行增量变换的距离向量
      ptDst - 转换后的距离向量
      返回：
      ptDst ，其中包含转换的结果。
      自从：
      1.2

    • deltaTransform

      public void deltaTransform(double[] srcPts, int srcOff, double[] dstPts, int dstOff, int numPts)
      通过此变换变换相对距离向量数组。使用以下等式，在不应用仿射变换矩阵的平移组件的情况下对相对距离向量进行变换： 
       [ x' ]  [ m00 m01 (m02) ] [ x ]  [ m00x + m01y ]
 [ y' ] = [ m10 m11 (m12) ] [ y ] = [ m10x + m11y ]
 [ (1) ]  [ (0) (0) ( 1 ) ] [ (1) ]  [   (1)   ]
      两个坐标数组部分可以完全相同，也可以是同一数组的重叠部分，而不影响结果的有效性。此方法可确保源坐标在转换之前不会被先前的操作覆盖。坐标存储在数组中，从指示的偏移量开始，顺序为 [x0, y0, x1, y1, ..., xn, yn]。
      参数：
      srcPts - 包含源距离向量的数组。每个向量存储为一对相对的 x、y 坐标。
      srcOff - 源数组中要转换的第一个向量的偏移量
      dstPts - 转换后的距离向量返回到的数组。每个向量存储为一对相对的 x、y 坐标。
      dstOff - 存储在目标数组中的第一个变换向量位置的偏移量
      numPts - 要变换的矢量坐标对的数量
      自从：
      1.2

    • createTransformedShape

      public Shape  createTransformedShape(Shape  pSrc)
      返回一个新的 Shape 对象，该对象由指定的 Shape 的几何形状定义，之后它已被此转换转换。
      参数：
      pSrc - 要由此转换转换的指定 Shape 对象。
      返回：
      一个新的 Shape 对象，它定义转换后的 Shape 的几何形状，如果 pSrc 为空，则为空。
      自从：
      1.2

    • toString

      public String  toString()
      返回表示此 Object 值的 String。
      重写：
      toString 在类 Object 中
      返回：
      一个 String 表示这个 Object 的值。
      自从：
      1.2

    • isIdentity

      public boolean isIdentity()
      如果此 AffineTransform 是身份转换，则返回 true。
      返回：
      true 如果这个 AffineTransform 是恒等变换； false否则。
      自从：
      1.2

    • clone

      public Object  clone()
      返回此 AffineTransform 对象的副本。
      重写：
      clone 在类 Object 中
      返回：
      Object 是此 AffineTransform 对象的副本。
      自从：
      1.2
      参见：

    • hashCode

      public int hashCode()
      返回此转换的哈希码。
      重写：
      hashCode 在类 Object 中
      返回：
      此转换的哈希码。
      自从：
      1.2
      参见：

    • equals

      public boolean equals(Object  obj)
      如果此 AffineTransform 表示与指定参数相同的仿射坐标变换，则返回 true。
      重写：
      equals 在类 Object 中
      参数：
      obj - Object 测试与此 AffineTransform 是否相等
      返回：
      true 如果 obj 等于这个 AffineTransform 对象； false否则。
      自从：
      1.2
      参见：