AffineTransform (Java Platform SE 8 )

java.lang.Object
- java.awt.geom.AffineTransform

All Implemented Interfaces:

Serializable ， Cloneable
```
public class AffineTransform
extends Object
implements Cloneable, Serializable
```
AffineTransform类表示2D仿射变换，其执行从2D坐标到其他2D坐标的线性映射，其保留线的“直线度”和“平行度”。仿射变换可以使用翻译，缩放，翻转，旋转和剪切的顺序来构建。
这样的坐标变换可以由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         ] 
```
Handling 90-Degree Rotations

在AffineTransform类中的rotate方法的某些变体中，双精度参数指定以弧度表示的旋转角度。这些方法对于大约90度的旋转（包括180,270和360度的倍数）具有特殊处理，使得更有效地处理象限旋转的常见情况。这种特殊的处理可以使角度非常接近90度的倍数，被视为90度的精确倍数。对于90度的小倍数，处理为象限旋转的角度范围约为0.00000121度宽。这一节解释了为什么需要这样特别的关心以及如何实施。

由于90度以弧度表示为PI/2 ，并且由于PI是超越（因此是非理性的）数字，所以不可能精确地表示90度的倍数作为以弧度测量的精确双精度值。因此，在理论上不可能使用这些值来描述象限旋转（90,180,270或360度）。双精度浮点值可以非常接近PI/2的非零倍数，但不能足够接近正弦或余弦正好为PI/2或-1.0。的实现Math.sin()和Math.cos()相应从不为比其它任何情况下返回0.0 Math.sin(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，则这些方法将角度θ视为象限旋转。作为经验法则，该属性适用于围绕Math.PI/2.0的小倍数的大约0.0000000211弧度（或0.00000121度）的Math.PI/2.0 。
从以下版本开始：

1.2

另请参见：

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`TYPE_FLIP` 该标志位指示由该对象定义的变换除了由其他标志位指示的转换之外还执行关于某个轴的镜像翻转，该轴将常规右手坐标系改变为左手系统。
`static int`	`TYPE_GENERAL_ROTATION` 该标志位表示由该对象定义的变换除了由其他标志位指示的转换之外还执行任意角度的旋转。
`static int`	`TYPE_GENERAL_SCALE` 该标志位表示由该对象定义的变换除了由其他标志位指示的转换之外还执行一般比例。
`static int`	`TYPE_GENERAL_TRANSFORM` 该常数表示由该对象定义的变换执行输入坐标的任意转换。
`static int`	`TYPE_IDENTITY` 该常数表示由该对象定义的变换是一个身份变换。
`static int`	`TYPE_MASK_ROTATION` 该常数是任何旋转标志位的位掩码。
`static int`	`TYPE_MASK_SCALE` 该常数是任何刻度标志位的位掩码。
`static int`	`TYPE_QUADRANT_ROTATION` 该标志位表示除了由其他标志位指示的转换之外，由该对象定义的变换执行90度的几倍的象限旋转。
`static int`	`TYPE_TRANSLATION` 该标志位表示由该对象定义的变换除了由其他标志位指示的转换之外还执行转换。
`static int`	`TYPE_UNIFORM_SCALE` 该标志位表示由该对象定义的变换除了由其他标志位指示的转换之外还执行统一的标度。

构造方法摘要

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

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	Method and Description
`Object`	`clone()` 返回此 `AffineTransform`对象的副本。
`void`	`concatenate(AffineTransform Tx)` 将 `AffineTransform` `Tx`到此 `AffineTransform` Cx中，以最常用的方式提供 `Tx`映射到前一个用户空间的新用户空间。
`AffineTransform`	`createInverse()` 返回表示逆变换的 `AffineTransform`对象。
`Shape`	`createTransformedShape(Shape pSrc)` 在通过此转换`Shape`后，返回由指定的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)` 返回 `true`如果这 `AffineTransform`表示相同的仿射坐标变换，指定的参数。
`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仿射变换矩阵的X坐标缩放元素（m00）。
`double`	`getScaleY()` 返回3x3仿射变换矩阵的Y坐标缩放元素（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()` 返回 `true`如果这 `AffineTransform`是恒等变换。
`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()` 将此转换重置为Identity变换。
`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(AffineTransform Tx)` 将此变换设置为指定的 `AffineTransform`对象中的变换 `AffineTransform` 。
`void`	`setTransform(double m00, double m10, double m01, double m11, double m02, double m12)` 将此变换设置为由6个双精度值指定的矩阵。
`void`	`shear(double shx, double shy)` 将此变换与剪切变换相结合。
`String`	`toString()` 返回`String`表示此值`Object` 。
`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)` 将此转换与转换变换相结合。

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

- 字段详细信息
  - TYPE_IDENTITY
```
public static final int TYPE_IDENTITY
```
    该常数表示由该对象定义的变换是一个身份变换。身份变换是输出坐标与输入坐标始终相同的变换。如果此变换是身份转换以外的其他变体，则该变换将作为常量GENERAL_TRANSFORM或适用于该变换执行的各种坐标转换的标志位的组合。
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    TYPE_TRANSLATION ， TYPE_UNIFORM_SCALE ， TYPE_GENERAL_SCALE ， TYPE_FLIP ， TYPE_QUADRANT_ROTATION ， TYPE_GENERAL_ROTATION ， TYPE_GENERAL_TRANSFORM ， getType() ， Constant Field Values
  - TYPE_TRANSLATION
```
public static final int TYPE_TRANSLATION
```
    该标志位表示由该对象定义的变换除了由其他标志位指示的转换之外还执行转换。平移在x和y上移动坐标恒定的量，而不改变向量的长度或角度。
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    TYPE_IDENTITY ， TYPE_UNIFORM_SCALE ， TYPE_GENERAL_SCALE ， TYPE_FLIP ， TYPE_QUADRANT_ROTATION ， TYPE_GENERAL_ROTATION ， TYPE_GENERAL_TRANSFORM ， getType() ， Constant Field Values
  - TYPE_UNIFORM_SCALE
```
public static final int TYPE_UNIFORM_SCALE
```
    该标志位表示由该对象定义的变换除了由其他标志位指示的转换之外还执行统一的标度。均匀标度在x和y方向上将向量的长度乘以相同的量，而不改变向量之间的角度。该标志位与TYPE_GENERAL_SCALE标志相互排斥。
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    TYPE_IDENTITY ， TYPE_TRANSLATION ， TYPE_GENERAL_SCALE ， TYPE_FLIP ， TYPE_QUADRANT_ROTATION ， TYPE_GENERAL_ROTATION ， TYPE_GENERAL_TRANSFORM ， getType() ， Constant Field Values
  - TYPE_GENERAL_SCALE
```
public static final int TYPE_GENERAL_SCALE
```
    该标志位表示由该对象定义的变换除了由其他标志位指示的转换之外还执行一般比例。一般比例尺在x和y方向上乘以不同量的向量长度，而不改变垂直向量之间的角度。该标志位与TYPE_UNIFORM_SCALE标志相互排斥。
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    TYPE_IDENTITY ， TYPE_TRANSLATION ， TYPE_UNIFORM_SCALE ， TYPE_FLIP ， TYPE_QUADRANT_ROTATION ， TYPE_GENERAL_ROTATION ， TYPE_GENERAL_TRANSFORM ， getType() ， Constant Field Values
  - TYPE_MASK_SCALE
```
public static final int TYPE_MASK_SCALE
```
    该常数是任何刻度标志位的位掩码。
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    TYPE_UNIFORM_SCALE ， TYPE_GENERAL_SCALE ， Constant Field Values
  - TYPE_FLIP
```
public static final int TYPE_FLIP
```
    该标志位指示由该对象定义的变换除了由其他标志位指示的转换之外还执行关于某个轴的镜像翻转，该轴将常规右手坐标系改变为左手系统。右手坐标系是正X轴逆时针旋转以覆盖正Y轴的方式，类似于当您盯着拇指时右手指卷曲的方向。左手坐标系是正X轴顺时针旋转以覆盖正Y轴的方式，类似于左手指上的手指卷曲。没有数学方法来确定原始翻转或镜像变换的角度，因为在适当的调整旋转情况下，所有翻转角都相同。
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    TYPE_IDENTITY ， TYPE_TRANSLATION ， TYPE_UNIFORM_SCALE ， TYPE_GENERAL_SCALE ， TYPE_QUADRANT_ROTATION ， TYPE_GENERAL_ROTATION ， TYPE_GENERAL_TRANSFORM ， getType() ， Constant Field Values
  - TYPE_QUADRANT_ROTATION
```
public static final int TYPE_QUADRANT_ROTATION
```
    该标志位表示除了由其他标志位指示的转换之外，由该对象定义的变换执行90度的几倍的象限旋转。旋转方向将向量的角度改变相同的量，而不管矢量的原始方向如何，而不改变向量的长度。该标志位与TYPE_GENERAL_ROTATION标志相互排斥。
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    TYPE_IDENTITY ， TYPE_TRANSLATION ， TYPE_UNIFORM_SCALE ， TYPE_GENERAL_SCALE ， TYPE_FLIP ， TYPE_GENERAL_ROTATION ， TYPE_GENERAL_TRANSFORM ， getType() ， Constant Field Values
  - TYPE_GENERAL_ROTATION
```
public static final int TYPE_GENERAL_ROTATION
```
    该标志位表示由该对象定义的变换除了由其他标志位指示的转换之外还执行任意角度的旋转。旋转方向将向量的角度改变相同的量，而不管矢量的原始方向如何，而不改变向量的长度。该标志位与TYPE_QUADRANT_ROTATION标志相互排斥。
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    TYPE_IDENTITY ， TYPE_TRANSLATION ， TYPE_UNIFORM_SCALE ， TYPE_GENERAL_SCALE ， TYPE_FLIP ， TYPE_QUADRANT_ROTATION ， TYPE_GENERAL_TRANSFORM ， getType() ， Constant Field Values
  - TYPE_MASK_ROTATION
```
public static final int TYPE_MASK_ROTATION
```
    该常数是任何旋转标志位的位掩码。
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    TYPE_QUADRANT_ROTATION ， TYPE_GENERAL_ROTATION ， Constant Field Values
  - TYPE_GENERAL_TRANSFORM
```
public static final int TYPE_GENERAL_TRANSFORM
```
    该常数表示由该对象定义的变换执行输入坐标的任意转换。如果该变换可以通过以上任何常数进行分类，则该变换将执行常量TYPE_IDENTITY或适用于各种坐标转换的相应标志位的组合。
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    TYPE_IDENTITY ， TYPE_TRANSLATION ， TYPE_UNIFORM_SCALE ， TYPE_GENERAL_SCALE ， TYPE_FLIP ， TYPE_QUADRANT_ROTATION ， TYPE_GENERAL_ROTATION ， getType() ， Constant Field Values
- 构造方法详细信息
  - AffineTransform
```
public AffineTransform()
```
    构造一个新 AffineTransform表示恒等变换。
    
    从以下版本开始：
    
    1.2
  - AffineTransform
```
public AffineTransform(AffineTransform Tx)
```
    构造一个新的 AffineTransform ，它是指定的 AffineTransform对象的副本。
    
    参数
    
    Tx - 要复制的 AffineTransform对象
    
    从以下版本开始：
    
    1.2
  - AffineTransform
```
@ConstructorProperties(value={"scaleX","shearY","shearX","scaleY","translateX","translateY"})
public AffineTransform(float m00,
                                                                                                                     float m10,
                                                                                                                     float m01,
                                                                                                                     float m11,
                                                                                                                     float m02,
                                                                                                                     float m12)
```
    从6个浮点值构造新的 AffineTransform ，表示3x3变换矩阵的6个可指定条目。
    
    参数
    
    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)
```
    从6个双精度值构造新的 AffineTransform ，表示3x3变换矩阵的6个可指定条目。
    
    参数
    
    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   ] 
```
    以正角度θ旋转正X轴上的点朝向正Y轴旋转。另请参见上述Handling 90-Degree Rotations的讨论。
    参数
    
    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        ] 
```
    以正角度θ旋转正X轴上的点朝向正Y轴旋转。还要注意上面Handling 90-Degree Rotations的讨论。
    参数
    
    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_TRANSLATION标志位以及TYPE_QUADRANT_ROTATION或TYPE_GENERAL_ROTATION标志位之一之外的组合的异或运算。
    
    结果
    
    任何适用于此变换的指示标志的OR组合
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    TYPE_IDENTITY ， TYPE_TRANSLATION ， TYPE_UNIFORM_SCALE ， TYPE_GENERAL_SCALE ， TYPE_QUADRANT_ROTATION ， TYPE_GENERAL_ROTATION ， TYPE_GENERAL_TRANSFORM
  - getDeterminant
```
public double getDeterminant()
```
    返回变换的矩阵表示的行列式。决定因素对于确定变换是否可以被反转并且获得表示变换的组合X和Y缩放的单个值是有用的。
    如果行列式不为零，则该变换是可逆的，并且依赖逆变换的各种方法不需要抛出一个NoninvertibleTransformException 。如果行列式为零，则该变换不能反转，因为变换将所有输入坐标映射到一行或一点上。如果决定因素接近于零，那么逆变换操作可能不足以产生有意义的结果。
    
    如果此变换表示统一缩放，由所指示的getType方法则决定因子也代表通过该所有的点是用膨胀或朝向原点收缩均匀缩放因子的平方。如果该变换表示不均匀的标度或更一般的变换，那么除了确定逆变换是否可能之外，行列式不太可能表示用于任何目的的值。
    
    在数学上，行列式使用以下公式计算：
```
  |  m00  m01  m02  |
          |  m10  m11  m12  |  =  m00 * m11 - m01 * m10
          |   0    0    1   | 
```
    结果
    
    用于转换坐标的矩阵的行列式。
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    getType() ， createInverse() ， inverseTransform(java.awt.geom.Point2D, java.awt.geom.Point2D) ， TYPE_UNIFORM_SCALE
  - getMatrix
```
public void getMatrix(double[] flatmatrix)
```
    检索3x3仿射变换矩阵中的6个可指定值，并将它们放入双重精度值的数组中。这些值作为{m00 m10 m01 m11 m02 m12}存储在数组中。也可以指定4个双精度数组，在这种情况下，仅检索表示数组的非变换部分的前四个元素，并将该值作为{m00 m10 m01 m11}存储到数组中
    
    参数
    
    flatmatrix - 用于存储返回值的double数组。
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    getScaleX() ， getScaleY() ， getShearX() ， getShearY() ， getTranslateX() ， getTranslateY()
  - getScaleX
```
public double getScaleX()
```
    返回3x3仿射变换矩阵的X坐标缩放元素（m00）。
    
    结果
    
    作为仿射变换矩阵的缩放元素的X坐标的双重值。
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    getMatrix(double[])
  - getScaleY
```
public double getScaleY()
```
    返回3x3仿射变换矩阵的Y坐标缩放元素（m11）。
    
    结果
    
    作为仿射变换矩阵的缩放元素的Y坐标的双重值。
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    getMatrix(double[])
  - getShearX
```
public double getShearX()
```
    返回3x3仿射变换矩阵的X坐标剪切元素（m01）。
    
    结果
    
    作为仿射变换矩阵的剪切元素的X坐标的双重值。
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    getMatrix(double[])
  - getShearY
```
public double getShearY()
```
    返回3x3仿射变换矩阵的Y坐标剪切元素（m10）。
    
    结果
    
    作为仿射变换矩阵的剪切元素的Y坐标的双重值。
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    getMatrix(double[])
  - getTranslateX
```
public double getTranslateX()
```
    返回3x3仿射变换矩阵的平移元素（m02）的X坐标。
    
    结果
    
    一个双重值，它是仿射变换矩阵的平移元素的X坐标。
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    getMatrix(double[])
  - getTranslateY
```
public double getTranslateY()
```
    返回3x3仿射变换矩阵的平移元素（m12）的Y坐标。
    
    结果
    
    作为仿射变换矩阵的平移元素的Y坐标的双重值。
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    getMatrix(double[])
  - 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   ] 
```
    以正角度θ旋转正X轴上的点朝向正Y轴旋转。另请参见上述Handling 90-Degree Rotations的讨论。
    参数
    
    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 
```
    以正角度θ旋转正X轴上的点朝向正Y轴旋转。还请注意上述Handling 90-Degree Rotations的讨论。
    参数
    
    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()
```
    将此转换重置为Identity变换。
    
    从以下版本开始：
    
    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   ] 
```
    以正角度θ旋转正X轴上的点朝向正Y轴旋转。还要注意上面Handling 90-Degree Rotations的讨论。
    参数
    
    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        ] 
```
    以正角度θ旋转正X轴上的点朝向正Y轴旋转。还要注意上述Handling 90-Degree Rotations的讨论。
    参数
    
    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对象中的变换 AffineTransform 。
    
    参数
    
    Tx - AffineTransform复制转换的 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等价于首先将p变换为Tx ，然后将结果转换为原始变换Cx，如下所示：Cx'（p）= Cx（Tx（p））以矩阵表示法，如果这样变换Cx由矩阵[this] Tx ，Tx由矩阵[Tx]表示，则该方法执行以下操作：
```
  [this] = [this] x [Tx] 
```
    参数
    
    Tx - AffineTransform对象要连接到这个 AffineTransform对象。
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    preConcatenate(java.awt.geom.AffineTransform)
  - 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由矩阵[Tx]表示，则该方法执行以下操作：
```
  [this] = [Tx] x [this] 
```
    参数
    
    Tx - 要与 AffineTransform对象连接的 AffineTransform对象。
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    concatenate(java.awt.geom.AffineTransform)
  - createInverse
```
public AffineTransform createInverse()
                              throws NoninvertibleTransformException
```
    返回表示逆变换的AffineTransform对象。该变换Tx的逆变换Tx'将由Tx变换的坐标映射回其原始坐标。换句话说，Tx'（Tx（p））= p = Tx（Tx'（p））。
    如果这个变换将所有的坐标映射到一个点或一行上，那么它将不会有一个反向，因为不在目标点或线上的坐标将不具有逆映射。 getDeterminant方法可用于确定此变换是否没有反向，在这种情况下，如果调用createInverse方法，将抛出异常。
    
    结果
    
    表示反向变换的新的 AffineTransform对象。
    
    异常
    
    NoninvertibleTransformException - 如果矩阵不能被反转。
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    getDeterminant()
  - invert
```
public void invert()
            throws NoninvertibleTransformException
```
    将此变换设置为本身的倒数。该变换Tx的逆变换Tx'将由Tx变换的坐标映射回其原始坐标。换句话说，Tx'（Tx（p））= p = Tx（Tx'（p））。
    如果这个变换将所有的坐标映射到一个点或一行上，那么它将不会有一个反向，因为不在目标点或线上的坐标将不具有逆映射。 getDeterminant方法可用于确定此变换是否没有反向，在这种情况下，如果调用invert方法，将抛出异常。
    
    异常
    
    NoninvertibleTransformException - 如果矩阵不能被反转。
    
    从以下版本开始：
    
    1.6
    
    另请参见：
    
    getDeterminant()
  - transform
```
public Point2D transform(Point2D ptSrc,
                         Point2D ptDst)
```
    变换指定的ptSrc并将结果在ptDst 。如果ptDst是null ，则null一个新的Point2D对象，然后将该转换的结果存储在该对象中。在任一种情况下，为ptDst ，返回包含转换点的ptDst。如果ptSrc和ptDst是相同的对象，则输入点被转换点正确地覆盖。
    
    参数
    
    ptSrc -指定 Point2D待转化
    
    ptDst - 指定的 Point2D存储转换结果 ptSrc
    
    结果
    
    在 ptDst后转化 ptSrc并存储在结果 ptDst 。
    
    从以下版本开始：
    
    1.2
  - transform
```
public void transform(Point2D[] ptSrc,
                      int srcOff,
                      Point2D[] ptDst,
                      int dstOff,
                      int numPts)
```
    通过此转换来转换点对象数组。如果ptDst数组的任何元素是null ，则在存储转换结果之前，将新的Point2D对象分配并存储到该元素中。
    请注意，此方法不采取任何预防措施，以避免将结果存储在Point2D对象中， Point2D对象将被用作源阵列进一步计算的源。该方法确保如果指定的Point2D对象既是同一个单点变换操作的源和目标，则在计算完成之前，结果将不会被存储，以避免将结果存储在操作数之上。然而，如果一个操作的目的地Point2D对象与源Point2D的另一个操作的对象相同，那么该点之前的原始坐标在被转换之前被覆盖。
    
    参数
    
    ptSrc - 包含源点对象的数组
    
    ptDst - 返回变换点对象的数组
    
    srcOff - 要在源数组中转换的第一个点对象的偏移量
    
    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坐标。
    
    dstPts - 返回转换点坐标的数组。每个点被存储为一对x，y坐标。
    
    srcOff - 要在源数组中转换的第一个点的偏移量
    
    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坐标。
    
    dstPts - 返回转换点坐标的数组。每个点被存储为一对x，y坐标。
    
    srcOff - 要在源数组中转换的第一个点的偏移量
    
    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坐标。
    
    dstPts - 返回转换点坐标的阵列。每个点被存储为一对x，y坐标。
    
    srcOff - 要在源数组中转换的第一个点的偏移量
    
    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坐标。
    
    dstPts - 返回转换点坐标的数组。每个点被存储为一对x，y坐标。
    
    srcOff - 要在源数组中转换的第一个点的偏移量
    
    dstOff - 存储在目标数组中的第一个转换点的位置的偏移量
    
    numPts - 要转换的点对象的数量
    
    从以下版本开始：
    
    1.2
  - inverseTransform
```
public Point2D inverseTransform(Point2D ptSrc,
                                Point2D ptDst)
                         throws NoninvertibleTransformException
```
    逆向变换指定的ptSrc并将结果在ptDst 。如果ptDst是null ，则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坐标。
    
    dstPts - 返回转换点坐标的数组。每个点被存储为一对x，y坐标。
    
    srcOff - 要在源数组中转换的第一个点的偏移量
    
    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 ，则null一个新的Point2D对象，然后转换的结果存储在该对象中。在任一情况下， ptDst ，其包含变换点时，返回的便利。如果ptSrc和ptDst是相同的对象，则输入点被转换点正确覆盖。
    参数
    
    ptSrc - 要进行delta变换的距离向量
    
    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坐标。
    
    dstPts - 返回变换后的距离向量的阵列。每个向量存储为一对相对的x，y坐标。
    
    srcOff - 要在源数组中转换的第一个向量的偏移量
    
    dstOff - 存储在目标数组中的第一个变换向量位置的偏移量
    
    numPts - 要转换的向量坐标对的数量
    
    从以下版本开始：
    
    1.2
  - createTransformedShape
```
public Shape createTransformedShape(Shape pSrc)
```
    在通过此变换Shape后，返回由指定的Shape的几何形状定义的新的对象Shape。
    
    参数
    
    pSrc - 指定的 Shape对象被这个变换转换。
    
    结果
    
    一个定义转换后的 Shape的几何对象的新的 Shape对象，如果 pSrc为空，则为null。
    
    从以下版本开始：
    
    1.2
  - toString
```
public String toString()
```
    返回String表示此值Object 。
    
    重写：
    
    toString在类别 Object
    
    结果
    
    一个 String代表这个 Object的价值。
    
    从以下版本开始：
    
    1.2
  - isIdentity
```
public boolean isIdentity()
```
    返回 true如果这 AffineTransform是恒等变换。
    
    结果
    
    true如果这个AffineTransform是一个身份转换; false否则。
    
    从以下版本开始：
    
    1.2
  - clone
```
public Object clone()
```
    返回此 AffineTransform对象的副本。
    
    重写：
    
    clone在类别 Object
    
    结果
    
    一个 Object是这个 AffineTransform对象的副本。
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    Cloneable
  - hashCode
```
public int hashCode()
```
    返回此转换的哈希码。
    
    重写：
    
    hashCode在 Object
    
    结果
    
    用于此转换的哈希码。
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    Object.equals(java.lang.Object) ， System.identityHashCode(java.lang.Object)
  - equals
```
public boolean equals(Object obj)
```
    返回 true如果这 AffineTransform表示相同的仿射坐标变换，指定的参数。
    
    重写：
    
    equals在 Object
    
    参数
    
    obj - Object测试与此平等 AffineTransform
    
    结果
    
    true如果obj等于这个AffineTransform对象; false否则。
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    Object.hashCode() ， HashMap

Class AffineTransform

Handling 90-Degree Rotations

Field Summary

构造方法摘要

方法摘要

Methods inherited from class java.lang.Object

字段详细信息

TYPE_IDENTITY

TYPE_TRANSLATION

TYPE_UNIFORM_SCALE

TYPE_GENERAL_SCALE

TYPE_MASK_SCALE

TYPE_FLIP

TYPE_QUADRANT_ROTATION

TYPE_GENERAL_ROTATION

TYPE_MASK_ROTATION

TYPE_GENERAL_TRANSFORM

构造方法详细信息

AffineTransform

AffineTransform

AffineTransform

AffineTransform

AffineTransform

AffineTransform

方法详细信息

getTranslateInstance

getRotateInstance

getRotateInstance

getRotateInstance

getRotateInstance

getQuadrantRotateInstance

getQuadrantRotateInstance

getScaleInstance

getShearInstance

getType

getDeterminant

getMatrix

getScaleX

getScaleY

getShearX

getShearY

getTranslateX

getTranslateY

translate

rotate

rotate

rotate

rotate

quadrantRotate

quadrantRotate

scale

shear

setToIdentity

setToTranslation

setToRotation

setToRotation

setToRotation

setToRotation

setToQuadrantRotation

setToQuadrantRotation

setToScale

setToShear

setTransform

setTransform

concatenate

preConcatenate

createInverse

invert

transform

transform

transform

transform

transform

transform

inverseTransform

inverseTransform

deltaTransform

deltaTransform

createTransformedShape

toString