Rectangle2D (Java SE 11 & JDK 11 )
Keywords: java.awt.geom.Rectangle2D class

Module java.desktop
Package java.awt.geom

## Class Rectangle2D

- java.lang.Object
- - java.awt.geom.RectangularShape
  - - java.awt.geom.Rectangle2D

- All Implemented Interfaces:
    `Shape`, `Cloneable`
  Direct Known Subclasses:
    `Rectangle`, `Rectangle2D.Double`, `Rectangle2D.Float`

      public abstract class Rectangle2D
      extends RectangularShape

  The `Rectangle2D` class describes a rectangle defined by a location `(x,y)` and dimension `(w x h)`.

  This class is only the abstract superclass for all objects that store a 2D rectangle. The actual storage representation of the coordinates is left to the subclass.

  Since:
    1.2

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class | Description
    --- | --- | ---
    `static class` | `Rectangle2D.Double` | The `Double` class defines a rectangle specified in double coordinates.
    `static class` | `Rectangle2D.Float` | The `Float` class defines a rectangle specified in float coordinates.

  - ### Field Summary

    Fields
    Modifier and Type | Field | Description
    --- | --- | ---
    `static int` | `OUT_BOTTOM` | The bitmask that indicates that a point lies below this `Rectangle2D`.
    `static int` | `OUT_LEFT` | The bitmask that indicates that a point lies to the left of this `Rectangle2D`.
    `static int` | `OUT_RIGHT` | The bitmask that indicates that a point lies to the right of this `Rectangle2D`.
    `static int` | `OUT_TOP` | The bitmask that indicates that a point lies above this `Rectangle2D`.

  - ### Constructor Summary

    Constructors
    Modifier | Constructor | Description
    --- | --- | ---
    `protected` | `Rectangle2D()` | This is an abstract class that cannot be instantiated directly.

  - ### Method Summary

    All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `void` | `add​(double newx, double newy)` | Adds a point, specified by the double precision arguments `newx` and `newy`, to this `Rectangle2D`.
    `void` | `add​(Point2D pt)` | Adds the `Point2D` object `pt` to this `Rectangle2D`.
    `void` | `add​(Rectangle2D r)` | Adds a `Rectangle2D` object to this `Rectangle2D`.
    `boolean` | `contains​(double x, double y)` | Tests if the specified coordinates are inside the boundary of the `Shape`, as described by the definition of insideness.
    `boolean` | `contains​(double x, double y, double w, double h)` | Tests if the interior of the `Shape` entirely contains the specified rectangular area.
    `abstract Rectangle2D` | `createIntersection​(Rectangle2D r)` | Returns a new `Rectangle2D` object representing the intersection of this `Rectangle2D` with the specified `Rectangle2D`.
    `abstract Rectangle2D` | `createUnion​(Rectangle2D r)` | Returns a new `Rectangle2D` object representing the union of this `Rectangle2D` with the specified `Rectangle2D`.
    `boolean` | `equals​(Object obj)` | Determines whether or not the specified `Object` is equal to this `Rectangle2D`.
    `Rectangle2D` | `getBounds2D()` | Returns a high precision and more accurate bounding box of the `Shape` than the `getBounds` method.
    `PathIterator` | `getPathIterator​(AffineTransform at)` | Returns an iteration object that defines the boundary of this `Rectangle2D`.
    `PathIterator` | `getPathIterator​(AffineTransform at, double flatness)` | Returns an iteration object that defines the boundary of the flattened `Rectangle2D`.
    `int` | `hashCode()` | Returns the hashcode for this `Rectangle2D`.
    `static void` | `intersect​(Rectangle2D src1, Rectangle2D src2, Rectangle2D dest)` | Intersects the pair of specified source `Rectangle2D` objects and puts the result into the specified destination `Rectangle2D` object.
    `boolean` | `intersects​(double x, double y, double w, double h)` | Tests if the interior of the `Shape` intersects the interior of a specified rectangular area.
    `boolean` | `intersectsLine​(double x1, double y1, double x2, double y2)` | Tests if the specified line segment intersects the interior of this `Rectangle2D`.
    `boolean` | `intersectsLine​(Line2D l)` | Tests if the specified line segment intersects the interior of this `Rectangle2D`.
    `abstract int` | `outcode​(double x, double y)` | Determines where the specified coordinates lie with respect to this `Rectangle2D`.
    `int` | `outcode​(Point2D p)` | Determines where the specified `Point2D` lies with respect to this `Rectangle2D`.
    `void` | `setFrame​(double x, double y, double w, double h)` | Sets the location and size of the outer bounds of this `Rectangle2D` to the specified rectangular values.
    `abstract void` | `setRect​(double x, double y, double w, double h)` | Sets the location and size of this `Rectangle2D` to the specified `double` values.
    `void` | `setRect​(Rectangle2D r)` | Sets this `Rectangle2D` to be the same as the specified `Rectangle2D`.
    `static void` | `union​(Rectangle2D src1, Rectangle2D src2, Rectangle2D dest)` | Unions the pair of source `Rectangle2D` objects and puts the result into the specified destination `Rectangle2D` object.

    - ### Methods declared in class java.awt.geom.RectangularShape

      `clone, contains, contains, getBounds, getCenterX, getCenterY, getFrame, getHeight, getMaxX, getMaxY, getMinX, getMinY, getWidth, getX, getY, intersects, isEmpty, setFrame, setFrame, setFrameFromCenter, setFrameFromCenter, setFrameFromDiagonal, setFrameFromDiagonal`

    - ### Methods declared in class java.lang.Object

      `finalize, getClass, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### OUT_LEFT

          public static final int OUT_LEFT

      The bitmask that indicates that a point lies to the left of this `Rectangle2D`.
      Since:
        1.2
      See Also:
        Constant Field Values

    - #### OUT_TOP

          public static final int OUT_TOP

      The bitmask that indicates that a point lies above this `Rectangle2D`.
      Since:
        1.2
      See Also:
        Constant Field Values

    - #### OUT_RIGHT

          public static final int OUT_RIGHT

      The bitmask that indicates that a point lies to the right of this `Rectangle2D`.
      Since:
        1.2
      See Also:
        Constant Field Values

    - #### OUT_BOTTOM

          public static final int OUT_BOTTOM

      The bitmask that indicates that a point lies below this `Rectangle2D`.
      Since:
        1.2
      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### Rectangle2D

          protected Rectangle2D()

      This is an abstract class that cannot be instantiated directly. Type-specific implementation subclasses are available for instantiation and provide a number of formats for storing the information necessary to satisfy the various accessor methods below.
      Since:
        1.2
      See Also:
        `Rectangle2D.Float`, `Rectangle2D.Double`, `Rectangle`

  - ### Method Detail

    - #### setRect

          public abstract void setRect​(double x,
                                       double y,
                                       double w,
                                       double h)

      Sets the location and size of this `Rectangle2D` to the specified `double` values.
      Parameters:
        `x` - the X coordinate of the upper-left corner of this `Rectangle2D`
        `y` - the Y coordinate of the upper-left corner of this `Rectangle2D`
        `w` - the width of this `Rectangle2D`
        `h` - the height of this `Rectangle2D`
      Since:
        1.2

    - #### setRect

          public void setRect​(Rectangle2D r)

      Sets this `Rectangle2D` to be the same as the specified `Rectangle2D`.
      Parameters:
        `r` - the specified `Rectangle2D`
      Since:
        1.2

    - #### intersectsLine

          public boolean intersectsLine​(double x1,
                                        double y1,
                                        double x2,
                                        double y2)

      Tests if the specified line segment intersects the interior of this `Rectangle2D`.
      Parameters:
        `x1` - the X coordinate of the start point of the specified line segment
        `y1` - the Y coordinate of the start point of the specified line segment
        `x2` - the X coordinate of the end point of the specified line segment
        `y2` - the Y coordinate of the end point of the specified line segment
      Returns:
        `true` if the specified line segment intersects the interior of this `Rectangle2D`; `false` otherwise.
      Since:
        1.2

    - #### intersectsLine

          public boolean intersectsLine​(Line2D l)

      Tests if the specified line segment intersects the interior of this `Rectangle2D`.
      Parameters:
        `l` - the specified `Line2D` to test for intersection with the interior of this `Rectangle2D`
      Returns:
        `true` if the specified `Line2D` intersects the interior of this `Rectangle2D`; `false` otherwise.
      Since:
        1.2

    - #### outcode

          public abstract int outcode​(double x,
                                      double y)

      Determines where the specified coordinates lie with respect to this `Rectangle2D`. This method computes a binary OR of the appropriate mask values indicating, for each side of this `Rectangle2D`, whether or not the specified coordinates are on the same side of the edge as the rest of this `Rectangle2D`.
      Parameters:
        `x` - the specified X coordinate
        `y` - the specified Y coordinate
      Returns:
        the logical OR of all appropriate out codes.
      Since:
        1.2
      See Also:
        `OUT_LEFT`, `OUT_TOP`, `OUT_RIGHT`, `OUT_BOTTOM`

    - #### outcode

          public int outcode​(Point2D p)

      Determines where the specified `Point2D` lies with respect to this `Rectangle2D`. This method computes a binary OR of the appropriate mask values indicating, for each side of this `Rectangle2D`, whether or not the specified `Point2D` is on the same side of the edge as the rest of this `Rectangle2D`.
      Parameters:
        `p` - the specified `Point2D`
      Returns:
        the logical OR of all appropriate out codes.
      Since:
        1.2
      See Also:
        `OUT_LEFT`, `OUT_TOP`, `OUT_RIGHT`, `OUT_BOTTOM`

    - #### setFrame

          public void setFrame​(double x,
                               double y,
                               double w,
                               double h)

      Sets the location and size of the outer bounds of this `Rectangle2D` to the specified rectangular values.
      Specified by:
        `setFrame` in class `RectangularShape`
      Parameters:
        `x` - the X coordinate of the upper-left corner of this `Rectangle2D`
        `y` - the Y coordinate of the upper-left corner of this `Rectangle2D`
        `w` - the width of this `Rectangle2D`
        `h` - the height of this `Rectangle2D`
      Since:
        1.2
      See Also:
        `RectangularShape.getFrame()`

    - #### getBounds2D

          public Rectangle2D getBounds2D()

      Returns a high precision and more accurate bounding box of the `Shape` than the `getBounds` method. Note that there is no guarantee that the returned `Rectangle2D` is the smallest bounding box that encloses the `Shape`, only that the `Shape` lies entirely within the indicated `Rectangle2D`. The bounding box returned by this method is usually tighter than that returned by the `getBounds` method and never fails due to overflow problems since the return value can be an instance of the `Rectangle2D` that uses double precision values to store the dimensions.

      Note that the definition of insideness can lead to situations where points on the defining outline of the `shape` may not be considered contained in the returned `bounds` object, but only in cases where those points are also not considered contained in the original `shape`.

      If a `point` is inside the `shape` according to the `contains(point)` method, then it must be inside the returned `Rectangle2D` bounds object according to the `contains(point)` method of the `bounds`. Specifically:

      `shape.contains(p)` requires `bounds.contains(p)`

      If a `point` is not inside the `shape`, then it might still be contained in the `bounds` object:

      `bounds.contains(p)` does not imply `shape.contains(p)`

      Returns:
        an instance of `Rectangle2D` that is a high-precision bounding box of the `Shape`.
      Since:
        1.2
      See Also:
        `Shape.getBounds()`

    - #### contains

          public boolean contains​(double x,
                                  double y)

      Tests if the specified coordinates are inside the boundary of the `Shape`, as described by the definition of insideness.
      Parameters:
        `x` - the specified X coordinate to be tested
        `y` - the specified Y coordinate to be tested
      Returns:
        `true` if the specified coordinates are inside the `Shape` boundary; `false` otherwise.
      Since:
        1.2

    - #### intersects

          public boolean intersects​(double x,
                                    double y,
                                    double w,
                                    double h)

      Tests if the interior of the `Shape` intersects the interior of a specified rectangular area. The rectangular area is considered to intersect the `Shape` if any point is contained in both the interior of the `Shape` and the specified rectangular area.

      The `Shape.intersects()` method allows a `Shape` implementation to conservatively return `true` when:

      - there is a high probability that the rectangular area and the `Shape` intersect, but
      - the calculations to accurately determine this intersection are prohibitively expensive.
      This means that for some `Shapes` this method might return `true` even though the rectangular area does not intersect the `Shape`. The `Area` class performs more accurate computations of geometric intersection than most `Shape` objects and therefore can be used if a more precise answer is required.
      Parameters:
        `x` - the X coordinate of the upper-left corner of the specified rectangular area
        `y` - the Y coordinate of the upper-left corner of the specified rectangular area
        `w` - the width of the specified rectangular area
        `h` - the height of the specified rectangular area
      Returns:
        `true` if the interior of the `Shape` and the interior of the rectangular area intersect, or are both highly likely to intersect and intersection calculations would be too expensive to perform; `false` otherwise.
      Since:
        1.2
      See Also:
        `Area`

    - #### contains

          public boolean contains​(double x,
                                  double y,
                                  double w,
                                  double h)

      Tests if the interior of the `Shape` entirely contains the specified rectangular area. All coordinates that lie inside the rectangular area must lie within the `Shape` for the entire rectangular area to be considered contained within the `Shape`.

      The `Shape.contains()` method allows a `Shape` implementation to conservatively return `false` when:

      - the `intersect` method returns `true` and
      - the calculations to determine whether or not the `Shape` entirely contains the rectangular area are prohibitively expensive.
      This means that for some `Shapes` this method might return `false` even though the `Shape` contains the rectangular area. The `Area` class performs more accurate geometric computations than most `Shape` objects and therefore can be used if a more precise answer is required.
      Parameters:
        `x` - the X coordinate of the upper-left corner of the specified rectangular area
        `y` - the Y coordinate of the upper-left corner of the specified rectangular area
        `w` - the width of the specified rectangular area
        `h` - the height of the specified rectangular area
      Returns:
        `true` if the interior of the `Shape` entirely contains the specified rectangular area; `false` otherwise or, if the `Shape` contains the rectangular area and the `intersects` method returns `true` and the containment calculations would be too expensive to perform.
      Since:
        1.2
      See Also:
        `Area`, `Shape.intersects(double, double, double, double)`

    - #### createIntersection

          public abstract Rectangle2D createIntersection​(Rectangle2D r)

      Returns a new `Rectangle2D` object representing the intersection of this `Rectangle2D` with the specified `Rectangle2D`.
      Parameters:
        `r` - the `Rectangle2D` to be intersected with this `Rectangle2D`
      Returns:
        the largest `Rectangle2D` contained in both the specified `Rectangle2D` and in this `Rectangle2D`.
      Since:
        1.2

    - #### intersect

          public static void intersect​(Rectangle2D src1,
                                       Rectangle2D src2,
                                       Rectangle2D dest)

      Intersects the pair of specified source `Rectangle2D` objects and puts the result into the specified destination `Rectangle2D` object. One of the source rectangles can also be the destination to avoid creating a third Rectangle2D object, but in this case the original points of this source rectangle will be overwritten by this method.
      Parameters:
        `src1` - the first of a pair of `Rectangle2D` objects to be intersected with each other
        `src2` - the second of a pair of `Rectangle2D` objects to be intersected with each other
        `dest` - the `Rectangle2D` that holds the results of the intersection of `src1` and `src2`
      Since:
        1.2

    - #### createUnion

          public abstract Rectangle2D createUnion​(Rectangle2D r)

      Returns a new `Rectangle2D` object representing the union of this `Rectangle2D` with the specified `Rectangle2D`.
      Parameters:
        `r` - the `Rectangle2D` to be combined with this `Rectangle2D`
      Returns:
        the smallest `Rectangle2D` containing both the specified `Rectangle2D` and this `Rectangle2D`.
      Since:
        1.2

    - #### union

          public static void union​(Rectangle2D src1,
                                   Rectangle2D src2,
                                   Rectangle2D dest)

      Unions the pair of source `Rectangle2D` objects and puts the result into the specified destination `Rectangle2D` object. One of the source rectangles can also be the destination to avoid creating a third Rectangle2D object, but in this case the original points of this source rectangle will be overwritten by this method.
      Parameters:
        `src1` - the first of a pair of `Rectangle2D` objects to be combined with each other
        `src2` - the second of a pair of `Rectangle2D` objects to be combined with each other
        `dest` - the `Rectangle2D` that holds the results of the union of `src1` and `src2`
      Since:
        1.2

    - #### add

          public void add​(double newx,
                          double newy)

      Adds a point, specified by the double precision arguments `newx` and `newy`, to this `Rectangle2D`. The resulting `Rectangle2D` is the smallest `Rectangle2D` that contains both the original `Rectangle2D` and the specified point.

      After adding a point, a call to `contains` with the added point as an argument does not necessarily return `true`. The `contains` method does not return `true` for points on the right or bottom edges of a rectangle. Therefore, if the added point falls on the left or bottom edge of the enlarged rectangle, `contains` returns `false` for that point.

      Parameters:
        `newx` - the X coordinate of the new point
        `newy` - the Y coordinate of the new point
      Since:
        1.2

    - #### add

          public void add​(Point2D pt)

      Adds the `Point2D` object `pt` to this `Rectangle2D`. The resulting `Rectangle2D` is the smallest `Rectangle2D` that contains both the original `Rectangle2D` and the specified `Point2D`.

      After adding a point, a call to `contains` with the added point as an argument does not necessarily return `true`. The `contains` method does not return `true` for points on the right or bottom edges of a rectangle. Therefore, if the added point falls on the left or bottom edge of the enlarged rectangle, `contains` returns `false` for that point.

      Parameters:
        `pt` - the new `Point2D` to add to this `Rectangle2D`.
      Since:
        1.2

    - #### add

          public void add​(Rectangle2D r)

      Adds a `Rectangle2D` object to this `Rectangle2D`. The resulting `Rectangle2D` is the union of the two `Rectangle2D` objects.
      Parameters:
        `r` - the `Rectangle2D` to add to this `Rectangle2D`.
      Since:
        1.2

    - #### getPathIterator

          public PathIterator getPathIterator​(AffineTransform at)

      Returns an iteration object that defines the boundary of this `Rectangle2D`. The iterator for this class is multi-threaded safe, which means that this `Rectangle2D` class guarantees that modifications to the geometry of this `Rectangle2D` object do not affect any iterations of that geometry that are already in process.
      Parameters:
        `at` - an optional `AffineTransform` to be applied to the coordinates as they are returned in the iteration, or `null` if untransformed coordinates are desired
      Returns:
        the `PathIterator` object that returns the geometry of the outline of this `Rectangle2D`, one segment at a time.
      Since:
        1.2

    - #### getPathIterator

          public PathIterator getPathIterator​(AffineTransform at,
                                              double flatness)

      Returns an iteration object that defines the boundary of the flattened `Rectangle2D`. Since rectangles are already flat, the `flatness` parameter is ignored. The iterator for this class is multi-threaded safe, which means that this `Rectangle2D` class guarantees that modifications to the geometry of this `Rectangle2D` object do not affect any iterations of that geometry that are already in process.
      Specified by:
        `getPathIterator` in interface `Shape`
      Overrides:
        `getPathIterator` in class `RectangularShape`
      Parameters:
        `at` - an optional `AffineTransform` to be applied to the coordinates as they are returned in the iteration, or `null` if untransformed coordinates are desired
        `flatness` - the maximum distance that the line segments used to approximate the curved segments are allowed to deviate from any point on the original curve. Since rectangles are already flat, the `flatness` parameter is ignored.
      Returns:
        the `PathIterator` object that returns the geometry of the outline of this `Rectangle2D`, one segment at a time.
      Since:
        1.2

    - #### hashCode

          public int hashCode()

      Returns the hashcode for this `Rectangle2D`.
      Overrides:
        `hashCode` in class `Object`
      Returns:
        the hashcode for this `Rectangle2D`.
      Since:
        1.2
      See Also:
        `Object.equals(java.lang.Object)`, `System.identityHashCode(java.lang.Object)`

    - #### equals

          public boolean equals​(Object obj)

      Determines whether or not the specified `Object` is equal to this `Rectangle2D`. The specified `Object` is equal to this `Rectangle2D` if it is an instance of `Rectangle2D` and if its location and size are the same as this `Rectangle2D`.
      Overrides:
        `equals` in class `Object`
      Parameters:
        `obj` - an `Object` to be compared with this `Rectangle2D`.
      Returns:
        `true` if `obj` is an instance of `Rectangle2D` and has the same values; `false` otherwise.
      Since:
        1.2
      See Also:
        `Object.hashCode()`, `HashMap`