RectangularShape (Java Platform SE 8 )
Keywords: java.awt.geom.RectangularShape class
Date: 2015-11-19

java.awt.geom

## Class RectangularShape

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

- All Implemented Interfaces:
    Shape, Cloneable
  Direct Known Subclasses:
    Arc2D, Ellipse2D, Rectangle2D, RoundRectangle2D

      public abstract class RectangularShape
      extends Object
      implements Shape, Cloneable

  `RectangularShape` is the base class for a number of `Shape` objects whose geometry is defined by a rectangular frame. This class does not directly specify any specific geometry by itself, but merely provides manipulation methods inherited by a whole category of `Shape` objects. The manipulation methods provided by this class can be used to query and modify the rectangular frame, which provides a reference for the subclasses to define their geometry.
  Since:
    1.2

- - ### Constructor Summary

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

  - ### Method Summary

    All Methods Instance Methods Abstract Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `Object` | `clone()` Creates a new object of the same class and with the same contents as this object.
    `boolean` | `contains(Point2D p)` Tests if a specified `Point2D` is inside the boundary of the `Shape`, as described by the definition of insideness.
    `boolean` | `contains(Rectangle2D r)` Tests if the interior of the `Shape` entirely contains the specified `Rectangle2D`.
    `Rectangle` | `getBounds()` Returns an integer `Rectangle` that completely encloses the `Shape`.
    `double` | `getCenterX()` Returns the X coordinate of the center of the framing rectangle of the `Shape` in `double` precision.
    `double` | `getCenterY()` Returns the Y coordinate of the center of the framing rectangle of the `Shape` in `double` precision.
    `Rectangle2D` | `getFrame()` Returns the framing `Rectangle2D` that defines the overall shape of this object.
    `abstract double` | `getHeight()` Returns the height of the framing rectangle in `double` precision.
    `double` | `getMaxX()` Returns the largest X coordinate of the framing rectangle of the `Shape` in `double` precision.
    `double` | `getMaxY()` Returns the largest Y coordinate of the framing rectangle of the `Shape` in `double` precision.
    `double` | `getMinX()` Returns the smallest X coordinate of the framing rectangle of the `Shape` in `double` precision.
    `double` | `getMinY()` Returns the smallest Y coordinate of the framing rectangle of the `Shape` in `double` precision.
    `PathIterator` | `getPathIterator(AffineTransform at, double flatness)` Returns an iterator object that iterates along the `Shape` object's boundary and provides access to a flattened view of the outline of the `Shape` object's geometry.
    `abstract double` | `getWidth()` Returns the width of the framing rectangle in `double` precision.
    `abstract double` | `getX()` Returns the X coordinate of the upper-left corner of the framing rectangle in `double` precision.
    `abstract double` | `getY()` Returns the Y coordinate of the upper-left corner of the framing rectangle in `double` precision.
    `boolean` | `intersects(Rectangle2D r)` Tests if the interior of the `Shape` intersects the interior of a specified `Rectangle2D`.
    `abstract boolean` | `isEmpty()` Determines whether the `RectangularShape` is empty.
    `abstract void` | `setFrame(double x, double y, double w, double h)` Sets the location and size of the framing rectangle of this `Shape` to the specified rectangular values.
    `void` | `setFrame(Point2D loc, Dimension2D size)` Sets the location and size of the framing rectangle of this `Shape` to the specified `Point2D` and `Dimension2D`, respectively.
    `void` | `setFrame(Rectangle2D r)` Sets the framing rectangle of this `Shape` to be the specified `Rectangle2D`.
    `void` | `setFrameFromCenter(double centerX, double centerY, double cornerX, double cornerY)` Sets the framing rectangle of this `Shape` based on the specified center point coordinates and corner point coordinates.
    `void` | `setFrameFromCenter(Point2D center, Point2D corner)` Sets the framing rectangle of this `Shape` based on a specified center `Point2D` and corner `Point2D`.
    `void` | `setFrameFromDiagonal(double x1, double y1, double x2, double y2)` Sets the diagonal of the framing rectangle of this `Shape` based on the two specified coordinates.
    `void` | `setFrameFromDiagonal(Point2D p1, Point2D p2)` Sets the diagonal of the framing rectangle of this `Shape` based on two specified `Point2D` objects.

    - ### Methods inherited from class java.lang.Object

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

    - ### Methods inherited from interface java.awt.Shape

      `contains, contains, getBounds2D, getPathIterator, intersects`

- - ### Constructor Detail

    - #### RectangularShape

          protected RectangularShape()

      This is an abstract class that cannot be instantiated directly.
      Since:
        1.2
      See Also:
        `Arc2D`, `Ellipse2D`, `Rectangle2D`, `RoundRectangle2D`

  - ### Method Detail

    - #### getX

          public abstract double getX()

      Returns the X coordinate of the upper-left corner of the framing rectangle in `double` precision.
      Returns:
        the X coordinate of the upper-left corner of the framing rectangle.
      Since:
        1.2

    - #### getY

          public abstract double getY()

      Returns the Y coordinate of the upper-left corner of the framing rectangle in `double` precision.
      Returns:
        the Y coordinate of the upper-left corner of the framing rectangle.
      Since:
        1.2

    - #### getWidth

          public abstract double getWidth()

      Returns the width of the framing rectangle in `double` precision.
      Returns:
        the width of the framing rectangle.
      Since:
        1.2

    - #### getHeight

          public abstract double getHeight()

      Returns the height of the framing rectangle in `double` precision.
      Returns:
        the height of the framing rectangle.
      Since:
        1.2

    - #### getMinX

          public double getMinX()

      Returns the smallest X coordinate of the framing rectangle of the `Shape` in `double` precision.
      Returns:
        the smallest X coordinate of the framing rectangle of the `Shape`.
      Since:
        1.2

    - #### getMinY

          public double getMinY()

      Returns the smallest Y coordinate of the framing rectangle of the `Shape` in `double` precision.
      Returns:
        the smallest Y coordinate of the framing rectangle of the `Shape`.
      Since:
        1.2

    - #### getMaxX

          public double getMaxX()

      Returns the largest X coordinate of the framing rectangle of the `Shape` in `double` precision.
      Returns:
        the largest X coordinate of the framing rectangle of the `Shape`.
      Since:
        1.2

    - #### getMaxY

          public double getMaxY()

      Returns the largest Y coordinate of the framing rectangle of the `Shape` in `double` precision.
      Returns:
        the largest Y coordinate of the framing rectangle of the `Shape`.
      Since:
        1.2

    - #### getCenterX

          public double getCenterX()

      Returns the X coordinate of the center of the framing rectangle of the `Shape` in `double` precision.
      Returns:
        the X coordinate of the center of the framing rectangle of the `Shape`.
      Since:
        1.2

    - #### getCenterY

          public double getCenterY()

      Returns the Y coordinate of the center of the framing rectangle of the `Shape` in `double` precision.
      Returns:
        the Y coordinate of the center of the framing rectangle of the `Shape`.
      Since:
        1.2

    - #### getFrame

          public Rectangle2D getFrame()

      Returns the framing `Rectangle2D` that defines the overall shape of this object.
      Returns:
        a `Rectangle2D`, specified in `double` coordinates.
      Since:
        1.2
      See Also:
        `setFrame(double, double, double, double)`, `setFrame(Point2D, Dimension2D)`, `setFrame(Rectangle2D)`

    - #### isEmpty

          public abstract boolean isEmpty()

      Determines whether the `RectangularShape` is empty. When the `RectangularShape` is empty, it encloses no area.
      Returns:
        `true` if the `RectangularShape` is empty; `false` otherwise.
      Since:
        1.2

    - #### setFrame

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

      Sets the location and size of the framing rectangle of this `Shape` to the specified rectangular values.
      Parameters:
        `x` - the X coordinate of the upper-left corner of the specified rectangular shape
        `y` - the Y coordinate of the upper-left corner of the specified rectangular shape
        `w` - the width of the specified rectangular shape
        `h` - the height of the specified rectangular shape
      Since:
        1.2
      See Also:
        `getFrame()`

    - #### setFrame

          public void setFrame(Point2D loc,
                               Dimension2D size)

      Sets the location and size of the framing rectangle of this `Shape` to the specified `Point2D` and `Dimension2D`, respectively. The framing rectangle is used by the subclasses of `RectangularShape` to define their geometry.
      Parameters:
        `loc` - the specified `Point2D`
        `size` - the specified `Dimension2D`
      Since:
        1.2
      See Also:
        `getFrame()`

    - #### setFrame

          public void setFrame(Rectangle2D r)

      Sets the framing rectangle of this `Shape` to be the specified `Rectangle2D`. The framing rectangle is used by the subclasses of `RectangularShape` to define their geometry.
      Parameters:
        `r` - the specified `Rectangle2D`
      Since:
        1.2
      See Also:
        `getFrame()`

    - #### setFrameFromDiagonal

          public void setFrameFromDiagonal(double x1,
                                           double y1,
                                           double x2,
                                           double y2)

      Sets the diagonal of the framing rectangle of this `Shape` based on the two specified coordinates. The framing rectangle is used by the subclasses of `RectangularShape` to define their geometry.
      Parameters:
        `x1` - the X coordinate of the start point of the specified diagonal
        `y1` - the Y coordinate of the start point of the specified diagonal
        `x2` - the X coordinate of the end point of the specified diagonal
        `y2` - the Y coordinate of the end point of the specified diagonal
      Since:
        1.2

    - #### setFrameFromDiagonal

          public void setFrameFromDiagonal(Point2D p1,
                                           Point2D p2)

      Sets the diagonal of the framing rectangle of this `Shape` based on two specified `Point2D` objects. The framing rectangle is used by the subclasses of `RectangularShape` to define their geometry.
      Parameters:
        `p1` - the start `Point2D` of the specified diagonal
        `p2` - the end `Point2D` of the specified diagonal
      Since:
        1.2

    - #### setFrameFromCenter

          public void setFrameFromCenter(double centerX,
                                         double centerY,
                                         double cornerX,
                                         double cornerY)

      Sets the framing rectangle of this `Shape` based on the specified center point coordinates and corner point coordinates. The framing rectangle is used by the subclasses of `RectangularShape` to define their geometry.
      Parameters:
        `centerX` - the X coordinate of the specified center point
        `centerY` - the Y coordinate of the specified center point
        `cornerX` - the X coordinate of the specified corner point
        `cornerY` - the Y coordinate of the specified corner point
      Since:
        1.2

    - #### setFrameFromCenter

          public void setFrameFromCenter(Point2D center,
                                         Point2D corner)

      Sets the framing rectangle of this `Shape` based on a specified center `Point2D` and corner `Point2D`. The framing rectangle is used by the subclasses of `RectangularShape` to define their geometry.
      Parameters:
        `center` - the specified center `Point2D`
        `corner` - the specified corner `Point2D`
      Since:
        1.2

    - #### contains

          public boolean contains(Point2D p)

      Tests if a specified `Point2D` is inside the boundary of the `Shape`, as described by the definition of insideness.
      Specified by:
        `contains` in interface `Shape`
      Parameters:
        `p` - the specified `Point2D` to be tested
      Returns:
        `true` if the specified `Point2D` is inside the boundary of the `Shape`; `false` otherwise.
      Since:
        1.2

    - #### intersects

          public boolean intersects(Rectangle2D r)

      Tests if the interior of the `Shape` intersects the interior of a specified `Rectangle2D`. The `Shape.intersects()` method allows a `Shape` implementation to conservatively return `true` when:
      - there is a high probability that the `Rectangle2D` 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 `Rectangle2D` 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.
      Specified by:
        `intersects` in interface `Shape`
      Parameters:
        `r` - the specified `Rectangle2D`
      Returns:
        `true` if the interior of the `Shape` and the interior of the specified `Rectangle2D` intersect, or are both highly likely to intersect and intersection calculations would be too expensive to perform; `false` otherwise.
      Since:
        1.2
      See Also:
        `Shape.intersects(double, double, double, double)`

    - #### contains

          public boolean contains(Rectangle2D r)

      Tests if the interior of the `Shape` entirely contains the specified `Rectangle2D`. 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 `Rectangle2D` are prohibitively expensive.
      This means that for some `Shapes` this method might return `false` even though the `Shape` contains the `Rectangle2D`. The `Area` class performs more accurate geometric computations than most `Shape` objects and therefore can be used if a more precise answer is required.
      Specified by:
        `contains` in interface `Shape`
      Parameters:
        `r` - The specified `Rectangle2D`
      Returns:
        `true` if the interior of the `Shape` entirely contains the `Rectangle2D`; `false` otherwise or, if the `Shape` contains the `Rectangle2D` and the `intersects` method returns `true` and the containment calculations would be too expensive to perform.
      Since:
        1.2
      See Also:
        `Shape.contains(double, double, double, double)`

    - #### getBounds

          public Rectangle getBounds()

      Returns an integer `Rectangle` that completely encloses the `Shape`. Note that there is no guarantee that the returned `Rectangle` is the smallest bounding box that encloses the `Shape`, only that the `Shape` lies entirely within the indicated `Rectangle`. The returned `Rectangle` might also fail to completely enclose the `Shape` if the `Shape` overflows the limited range of the integer data type. The `getBounds2D` method generally returns a tighter bounding box due to its greater flexibility in representation.

      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 `Rectangle` bounds object according to the `contains(point)` method of the `bounds`. Specifically:

      `shape.contains(x,y)` requires `bounds.contains(x,y)`

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

      `bounds.contains(x,y)` does not imply `shape.contains(x,y)`

      Specified by:
        `getBounds` in interface `Shape`
      Returns:
        an integer `Rectangle` that completely encloses the `Shape`.
      Since:
        1.2
      See Also:
        `Shape.getBounds2D()`

    - #### getPathIterator

          public PathIterator getPathIterator(AffineTransform at,
                                              double flatness)

      Returns an iterator object that iterates along the `Shape` object's boundary and provides access to a flattened view of the outline of the `Shape` object's geometry.

      Only SEG_MOVETO, SEG_LINETO, and SEG_CLOSE point types will be returned by the iterator.

      The amount of subdivision of the curved segments is controlled by the `flatness` parameter, which specifies the maximum distance that any point on the unflattened transformed curve can deviate from the returned flattened path segments. An optional `AffineTransform` can be specified so that the coordinates returned in the iteration are transformed accordingly.

      Specified by:
        `getPathIterator` in interface `Shape`
      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
      Returns:
        a `PathIterator` object that provides access to the `Shape` object's flattened geometry.
      Since:
        1.2

    - #### clone

          public Object clone()

      Creates a new object of the same class and with the same contents as this object.
      Overrides:
        `clone` in class `Object`
      Returns:
        a clone of this instance.
      Throws:
        `OutOfMemoryError` - if there is not enough memory.
      Since:
        1.2
      See Also:
        `Cloneable`

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2015, Oracle and/or its affiliates. All rights reserved.