Rectangle2D (Java SE 13 & JDK 13 )
Description: declaration: module: java.desktop, package: java.awt.geom, class: Rectangle2D
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

  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 Details

  - ### 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 Details

  - ### 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 Details

  - ### 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`