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

All Implemented Interfaces:

Shape, java.io.Serializable, java.lang.Cloneable

public class Rectangle extends java.awt.geom.Rectangle2D implements Shape, java.io.Serializable
A Rectangle specifies an area in a coordinate space that is enclosed by the Rectangle object's upper-left point (x,y) in the coordinate space, its width, and its height.
A Rectangle object's width and height are public fields. The constructors that create a Rectangle, and the methods that can modify one, do not prevent setting a negative value for width or height.
A Rectangle whose width or height is exactly zero has location along those axes with zero dimension, but is otherwise considered empty. The isEmpty() method will return true for such a Rectangle. Methods which test if an empty Rectangle contains or intersects a point or rectangle will always return false if either dimension is zero. Methods which combine such a Rectangle with a point or rectangle will include the location of the Rectangle on that axis in the result as if the add(Point) method were being called.
A Rectangle whose width or height is negative has neither location nor dimension along those axes with negative dimensions. Such a Rectangle is treated as non-existant along those axes. Such a Rectangle is also empty with respect to containment calculations and methods which test if it contains or intersects a point or rectangle will always return false. Methods which combine such a Rectangle with a point or rectangle will ignore the Rectangle entirely in generating the result. If two Rectangle objects are combined and each has a negative dimension, the result will have at least one negative dimension.
Methods which affect only the location of a Rectangle will operate on its location regardless of whether or not it has a negative or zero dimension along either axis.
Note that a Rectangle constructed with the default no-argument constructor will have dimensions of 0x0 and therefore be empty. That Rectangle will still have a location of (0,0) and will contribute that location to the union and add operations. Code attempting to accumulate the bounds of a set of points should therefore initially construct the Rectangle with a specifically negative width and height or it should use the first point in the set to construct the Rectangle. For example:
```
     Rectangle bounds = new Rectangle(0, 0, -1, -1);
     for (int i = 0; i < points.length; i++) {
         bounds.add(points[i]);
     }
 
```
or if we know that the points array contains at least one point:
```
     Rectangle bounds = new Rectangle(points[0]);
     for (int i = 1; i < points.length; i++) {
         bounds.add(points[i]);
     }
 
```
This class uses 32-bit integers to store its location and dimensions. Frequently operations may produce a result that exceeds the range of a 32-bit integer. The methods will calculate their results in a way that avoids any 32-bit overflow for intermediate results and then choose the best representation to store the final results back into the 32-bit fields which hold the location and dimensions. The location of the result will be stored into the x and y fields by clipping the true result to the nearest 32-bit value. The values stored into the width and height dimension fields will be chosen as the 32-bit values that encompass the largest part of the true result as possible. Generally this means that the dimension will be clipped independently to the range of 32-bit integers except that if the location had to be moved to store it into its pair of 32-bit fields then the dimensions will be adjusted relative to the "best representation" of the location. If the true result had a negative dimension and was therefore non-existant along one or both axes, the stored dimensions will be negative numbers in those axes. If the true result had a location that could be represented within the range of 32-bit integers, but zero dimension along one or both axes, then the stored dimensions will be zero in those axes.
Since:

1.0

See Also:
Serialized Form

Nested Classes
	Modifier and Type	Class and Description
	awt.geom.Rectangle2D.Double	`static class` awt.geom.Rectangle2D.Double The `Double` class defines a rectangle specified in double coordinates. `static class` awt.geom.Rectangle2D.Double The `Double` class defines a rectangle specified in double coordinates. Since: 1.2 See Also: Serialized Form
	awt.geom.Rectangle2D.Float	`static class` awt.geom.Rectangle2D.Float The `Float` class defines a rectangle specified in float coordinates. `static class` awt.geom.Rectangle2D.Float The `Float` class defines a rectangle specified in float coordinates. Since: 1.2 See Also: Serialized Form

Fields
	Modifier and Type	Field and Description
	height	`int` height The height of the `Rectangle`. public int height The height of the `Rectangle`. Since: 1.0 See Also: `setSize(int, int)`, `getSize()`
	OUT_BOTTOM	`static int` OUT_BOTTOM The bitmask that indicates that a point lies below this `Rectangle2D`. 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
	OUT_LEFT	`static int` OUT_LEFT The bitmask that indicates that a point lies to the left of this `Rectangle2D`. 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_RIGHT	`static int` OUT_RIGHT The bitmask that indicates that a point lies to the right of this `Rectangle2D`. 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_TOP	`static int` OUT_TOP The bitmask that indicates that a point lies above this `Rectangle2D`. 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
	width	`int` width The width of the `Rectangle`. public int width The width of the `Rectangle`. Since: 1.0 See Also: `setSize(int, int)`, `getSize()`
	x	`int` x The X coordinate of the upper-left corner of the `Rectangle`. public int x The X coordinate of the upper-left corner of the `Rectangle`. Since: 1.0 See Also: `setLocation(int, int)`, `getLocation()`
	y	`int` y The Y coordinate of the upper-left corner of the `Rectangle`. public int y The Y coordinate of the upper-left corner of the `Rectangle`. Since: 1.0 See Also: `setLocation(int, int)`, `getLocation()`

Static Methods
	Modifier and Type	Static Method and Description
	intersect	`static void` intersect(java.awt.geom.Rectangle2D src1, java.awt.geom.Rectangle2D src2, java.awt.geom.Rectangle2D dest) Intersects the pair of specified source `Rectangle2D` objects and puts the result into the specified destination `Rectangle2D` object. public static void intersect(java.awt.geom.Rectangle2D src1, java.awt.geom.Rectangle2D src2, java.awt.geom.Rectangle2D dest) Description copied from class: `java.awt.geom.Rectangle2D` 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
	union	`static void` union(java.awt.geom.Rectangle2D src1, java.awt.geom.Rectangle2D src2, java.awt.geom.Rectangle2D dest) Unions the pair of source `Rectangle2D` objects and puts the result into the specified destination `Rectangle2D` object. public static void union(java.awt.geom.Rectangle2D src1, java.awt.geom.Rectangle2D src2, java.awt.geom.Rectangle2D dest) Description copied from class: `java.awt.geom.Rectangle2D` 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

Constructors
	Constructor and Description
	Rectangle	Rectangle() Constructs a new `Rectangle` whose upper-left corner is at (0, 0) in the coordinate space, and whose width and height are both zero. public Rectangle() Constructs a new `Rectangle` whose upper-left corner is at (0, 0) in the coordinate space, and whose width and height are both zero.
	Rectangle	Rectangle(Dimension d) Constructs a new `Rectangle` whose top left corner is (0, 0) and whose width and height are specified by the `Dimension` argument. public Rectangle(Dimension d) Constructs a new `Rectangle` whose top left corner is (0, 0) and whose width and height are specified by the `Dimension` argument. Parameters: `d` - a `Dimension`, specifying width and height
	Rectangle	Rectangle(int width, int height) Constructs a new `Rectangle` whose upper-left corner is at (0, 0) in the coordinate space, and whose width and height are specified by the arguments of the same name. public Rectangle(int width, int height) Constructs a new `Rectangle` whose upper-left corner is at (0, 0) in the coordinate space, and whose width and height are specified by the arguments of the same name. Parameters: `width` - the width of the `Rectangle` `height` - the height of the `Rectangle`
	Rectangle	Rectangle(int x, int y, int width, int height) Constructs a new `Rectangle` whose upper-left corner is specified as `(x,y)` and whose width and height are specified by the arguments of the same name. public Rectangle(int x, int y, int width, int height) Constructs a new `Rectangle` whose upper-left corner is specified as `(x,y)` and whose width and height are specified by the arguments of the same name. Parameters: `x` - the specified X coordinate `y` - the specified Y coordinate `width` - the width of the `Rectangle` `height` - the height of the `Rectangle` Since: 1.0
	Rectangle	Rectangle(Point p) Constructs a new `Rectangle` whose upper-left corner is the specified `Point`, and whose width and height are both zero. public Rectangle(Point p) Constructs a new `Rectangle` whose upper-left corner is the specified `Point`, and whose width and height are both zero. Parameters: `p` - a `Point` that is the top left corner of the `Rectangle`
	Rectangle	Rectangle(Point p, Dimension d) Constructs a new `Rectangle` whose upper-left corner is specified by the `Point` argument, and whose width and height are specified by the `Dimension` argument. public Rectangle(Point p, Dimension d) Constructs a new `Rectangle` whose upper-left corner is specified by the `Point` argument, and whose width and height are specified by the `Dimension` argument. Parameters: `p` - a `Point` that is the upper-left corner of the `Rectangle` `d` - a `Dimension`, representing the width and height of the `Rectangle`
	Rectangle	Rectangle(Rectangle r) Constructs a new `Rectangle`, initialized to match the values of the specified `Rectangle`. public Rectangle(Rectangle r) Constructs a new `Rectangle`, initialized to match the values of the specified `Rectangle`. Parameters: `r` - the `Rectangle` from which to copy initial values to a newly constructed `Rectangle` Since: 1.1

Methods
	Modifier and Type	Method and Description
	add	`void` add(double newx, double newy) Adds a point, specified by the double precision arguments `newx` and `newy`, to this `Rectangle2D`. public void add(double newx, double newy) Description copied from class: `java.awt.geom.Rectangle2D` 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	`void` add(int newx, int newy) Adds a point, specified by the integer arguments `newx,newy` to the bounds of this `Rectangle`. public void add(int newx, int newy) Adds a point, specified by the integer arguments `newx,newy` to the bounds of this `Rectangle`. If this `Rectangle` has any dimension less than zero, the rules for non-existant rectangles apply. In that case, the new bounds of this `Rectangle` will have a location equal to the specified coordinates and width and height equal to zero. 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 right or bottom edge of the enlarged `Rectangle`, `contains` returns `false` for that point. If the specified point must be contained within the new `Rectangle`, a 1x1 rectangle should be added instead: r.add(newx, newy, 1, 1); Parameters: `newx` - the X coordinate of the new point `newy` - the Y coordinate of the new point
	add	`void` add(Point pt) Adds the specified `Point` to the bounds of this `Rectangle`. public void add(Point pt) Adds the specified `Point` to the bounds of this `Rectangle`. If this `Rectangle` has any dimension less than zero, the rules for non-existant rectangles apply. In that case, the new bounds of this `Rectangle` will have a location equal to the coordinates of the specified `Point` and width and height equal to zero. 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 right or bottom edge of the enlarged `Rectangle`, `contains` returns `false` for that `Point`. If the specified point must be contained within the new `Rectangle`, a 1x1 rectangle should be added instead: r.add(pt.x, pt.y, 1, 1); Parameters: `pt` - the new `Point` to add to this `Rectangle`
	add	`void` add(java.awt.geom.Point2D pt) Adds the `Point2D` object `pt` to this `Rectangle2D`. public void add(java.awt.geom.Point2D pt) Description copied from class: `java.awt.geom.Rectangle2D` 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	`void` add(Rectangle r) Adds a `Rectangle` to this `Rectangle`. public void add(Rectangle r) Adds a `Rectangle` to this `Rectangle`. The resulting `Rectangle` is the union of the two rectangles. If either `Rectangle` has any dimension less than 0, the result will have the dimensions of the other `Rectangle`. If both `Rectangle`s have at least one dimension less than 0, the result will have at least one dimension less than 0. If either `Rectangle` has one or both dimensions equal to 0, the result along those axes with 0 dimensions will be equivalent to the results obtained by adding the corresponding origin coordinate to the result rectangle along that axis, similar to the operation of the `add(Point)` method, but contribute no further dimension beyond that. If the resulting `Rectangle` would have a dimension too large to be expressed as an `int`, the result will have a dimension of `Integer.MAX_VALUE` along that dimension. Parameters: `r` - the specified `Rectangle`
	add	`void` add(java.awt.geom.Rectangle2D r) Adds a `Rectangle2D` object to this `Rectangle2D`. public void add(java.awt.geom.Rectangle2D r) Description copied from class: `java.awt.geom.Rectangle2D` 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
	clone	`java.lang.Object` clone() Creates a new object of the same class and with the same contents as this object. public java.lang.Object clone() Description copied from class: `java.awt.geom.RectangularShape` Creates a new object of the same class and with the same contents as this object. Overrides: `clone` in class `java.lang.Object` Returns: a clone of this instance. Throws: `java.lang.OutOfMemoryError` - if there is not enough memory. Since: 1.2 See Also: `Cloneable`
	contains	`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. public boolean contains(double x, double y) Description copied from class: `java.awt.geom.Rectangle2D` 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
	contains	`boolean` contains(double x, double y, double w, double h) Tests if the interior of the `Shape` entirely contains the specified rectangular area. public boolean contains(double x, double y, double w, double h) Description copied from class: `java.awt.geom.Rectangle2D` 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 rectanglar 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)`
	contains	`boolean` contains(int x, int y) Checks whether or not this `Rectangle` contains the point at the specified location `(x,y)`. public boolean contains(int x, int y) Checks whether or not this `Rectangle` contains the point at the specified location `(x,y)`. Parameters: `x` - the specified X coordinate `y` - the specified Y coordinate Returns: `true` if the point `(x,y)` is inside this `Rectangle`; `false` otherwise. Since: 1.1
	contains	`boolean` contains(int X, int Y, int W, int H) Checks whether this `Rectangle` entirely contains the `Rectangle` at the specified location `(X,Y)` with the specified dimensions `(W,H)`. public boolean contains(int X, int Y, int W, int H) Checks whether this `Rectangle` entirely contains the `Rectangle` at the specified location `(X,Y)` with the specified dimensions `(W,H)`. Parameters: `X` - the specified X coordinate `Y` - the specified Y coordinate `W` - the width of the `Rectangle` `H` - the height of the `Rectangle` Returns: `true` if the `Rectangle` specified by `(X, Y, W, H)` is entirely enclosed inside this `Rectangle`; `false` otherwise. Since: 1.1
	contains	`boolean` contains(Point p) Checks whether or not this `Rectangle` contains the specified `Point`. public boolean contains(Point p) Checks whether or not this `Rectangle` contains the specified `Point`. Parameters: `p` - the `Point` to test Returns: `true` if the specified `Point` is inside this `Rectangle`; `false` otherwise. Since: 1.1
	contains	`boolean` contains(java.awt.geom.Point2D p) Tests if a specified `Point2D` is inside the boundary of the `Shape`, as described by the definition of insideness. public boolean contains(java.awt.geom.Point2D p) Description copied from class: `java.awt.geom.RectangularShape` 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
	contains	`boolean` contains(Rectangle r) Checks whether or not this `Rectangle` entirely contains the specified `Rectangle`. public boolean contains(Rectangle r) Checks whether or not this `Rectangle` entirely contains the specified `Rectangle`. Parameters: `r` - the specified `Rectangle` Returns: `true` if the `Rectangle` is contained entirely inside this `Rectangle`; `false` otherwise Since: 1.2
	contains	`boolean` contains(java.awt.geom.Rectangle2D r) Tests if the interior of the `Shape` entirely contains the specified `Rectangle2D`. public boolean contains(java.awt.geom.Rectangle2D r) Description copied from class: `java.awt.geom.RectangularShape` 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)`
	createIntersection	`java.awt.geom.Rectangle2D` createIntersection(java.awt.geom.Rectangle2D r) Returns a new `Rectangle2D` object representing the intersection of this `Rectangle2D` with the specified `Rectangle2D`. public java.awt.geom.Rectangle2D createIntersection(java.awt.geom.Rectangle2D r) Returns a new `Rectangle2D` object representing the intersection of this `Rectangle2D` with the specified `Rectangle2D`. Specified by: `createIntersection` in class `java.awt.geom.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
	createUnion	`java.awt.geom.Rectangle2D` createUnion(java.awt.geom.Rectangle2D r) Returns a new `Rectangle2D` object representing the union of this `Rectangle2D` with the specified `Rectangle2D`. public java.awt.geom.Rectangle2D createUnion(java.awt.geom.Rectangle2D r) Returns a new `Rectangle2D` object representing the union of this `Rectangle2D` with the specified `Rectangle2D`. Specified by: `createUnion` in class `java.awt.geom.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
	equals	`boolean` equals(java.lang.Object obj) Checks whether two rectangles are equal. public boolean equals(java.lang.Object obj) Checks whether two rectangles are equal. The result is `true` if and only if the argument is not `null` and is a `Rectangle` object that has the same upper-left corner, width, and height as this `Rectangle`. Overrides: `equals` in class `java.awt.geom.Rectangle2D` Parameters: `obj` - the `Object` to compare with this `Rectangle` Returns: `true` if the objects are equal; `false` otherwise. See Also: `Object.hashCode()`, `HashMap`
	getBounds	`Rectangle` getBounds() Gets the bounding `Rectangle` of this `Rectangle`. public Rectangle getBounds() Gets the bounding `Rectangle` of this `Rectangle`. This method is included for completeness, to parallel the `getBounds` method of `Component`. Specified by: `getBounds` in interface `Shape` Overrides: `getBounds` in class `java.awt.geom.RectangularShape` Returns: a new `Rectangle`, equal to the bounding `Rectangle` for this `Rectangle`. Since: 1.1 See Also: `Component.getBounds()`, `setBounds(Rectangle)`, `setBounds(int, int, int, int)`
	getBounds2D	`java.awt.geom.Rectangle2D` getBounds2D() Returns a high precision and more accurate bounding box of the `Shape` than the `getBounds` method. public java.awt.geom.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)` Specified by: `getBounds2D` in interface `Shape` Overrides: `getBounds2D` in class `java.awt.geom.Rectangle2D` Returns: an instance of `Rectangle2D` that is a high-precision bounding box of the `Shape`. Since: 1.2 See Also: `Shape.getBounds()`
	getCenterX	`double` getCenterX() Returns the X coordinate of the center of the framing rectangle of the `Shape` in `double` precision. public double getCenterX() Description copied from class: `java.awt.geom.RectangularShape` 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	`double` getCenterY() Returns the Y coordinate of the center of the framing rectangle of the `Shape` in `double` precision. public double getCenterY() Description copied from class: `java.awt.geom.RectangularShape` 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	`java.awt.geom.Rectangle2D` getFrame() Returns the framing `Rectangle2D` that defines the overall shape of this object. public java.awt.geom.Rectangle2D getFrame() Description copied from class: `java.awt.geom.RectangularShape` Returns the framing `Rectangle2D` that defines the overall shape of this object. Returns: a `Rectangle2D`, specified in `double` coordinates. Since: 1.2 See Also: `RectangularShape.setFrame(double, double, double, double)`, `RectangularShape.setFrame(Point2D, Dimension2D)`, `RectangularShape.setFrame(Rectangle2D)`
	getHeight	`double` getHeight() Returns the height of the bounding `Rectangle` in `double` precision. public double getHeight() Returns the height of the bounding `Rectangle` in `double` precision. Specified by: `getHeight` in class `java.awt.geom.RectangularShape` Returns: the height of the bounding `Rectangle`.
	getLocation	`Point` getLocation() Returns the location of this `Rectangle`. public Point getLocation() Returns the location of this `Rectangle`. This method is included for completeness, to parallel the `getLocation` method of `Component`. Returns: the `Point` that is the upper-left corner of this `Rectangle`. Since: 1.1 See Also: `Component.getLocation()`, `setLocation(Point)`, `setLocation(int, int)`
	getMaxX	`double` getMaxX() Returns the largest X coordinate of the framing rectangle of the `Shape` in `double` precision. public double getMaxX() Description copied from class: `java.awt.geom.RectangularShape` 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	`double` getMaxY() Returns the largest Y coordinate of the framing rectangle of the `Shape` in `double` precision. public double getMaxY() Description copied from class: `java.awt.geom.RectangularShape` 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
	getMinX	`double` getMinX() Returns the smallest X coordinate of the framing rectangle of the `Shape` in `double` precision. public double getMinX() Description copied from class: `java.awt.geom.RectangularShape` 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	`double` getMinY() Returns the smallest Y coordinate of the framing rectangle of the `Shape` in `double` precision. public double getMinY() Description copied from class: `java.awt.geom.RectangularShape` 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
	getPathIterator	`java.awt.geom.PathIterator` getPathIterator(java.awt.geom.AffineTransform at) Returns an iteration object that defines the boundary of this `Rectangle2D`. public java.awt.geom.PathIterator getPathIterator(java.awt.geom.AffineTransform at) Description copied from class: `java.awt.geom.Rectangle2D` 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	`java.awt.geom.PathIterator` getPathIterator(java.awt.geom.AffineTransform at, double flatness) Returns an iteration object that defines the boundary of the flattened `Rectangle2D`. public java.awt.geom.PathIterator getPathIterator(java.awt.geom.AffineTransform at, double flatness) Description copied from class: `java.awt.geom.Rectangle2D` 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 `java.awt.geom.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
	getSize	`Dimension` getSize() Gets the size of this `Rectangle`, represented by the returned `Dimension`. public Dimension getSize() Gets the size of this `Rectangle`, represented by the returned `Dimension`. This method is included for completeness, to parallel the `getSize` method of `Component`. Returns: a `Dimension`, representing the size of this `Rectangle`. Since: 1.1 See Also: `Component.getSize()`, `setSize(Dimension)`, `setSize(int, int)`
	getWidth	`double` getWidth() Returns the width of the bounding `Rectangle` in `double` precision. public double getWidth() Returns the width of the bounding `Rectangle` in `double` precision. Specified by: `getWidth` in class `java.awt.geom.RectangularShape` Returns: the width of the bounding `Rectangle`.
	getX	`double` getX() Returns the X coordinate of the bounding `Rectangle` in `double` precision. public double getX() Returns the X coordinate of the bounding `Rectangle` in `double` precision. Specified by: `getX` in class `java.awt.geom.RectangularShape` Returns: the X coordinate of the bounding `Rectangle`.
	getY	`double` getY() Returns the Y coordinate of the bounding `Rectangle` in `double` precision. public double getY() Returns the Y coordinate of the bounding `Rectangle` in `double` precision. Specified by: `getY` in class `java.awt.geom.RectangularShape` Returns: the Y coordinate of the bounding `Rectangle`.
	grow	`void` grow(int h, int v) Resizes the `Rectangle` both horizontally and vertically. public void grow(int h, int v) Resizes the `Rectangle` both horizontally and vertically. This method modifies the `Rectangle` so that it is `h` units larger on both the left and right side, and `v` units larger at both the top and bottom. The new `Rectangle` has `(x - h, y - v)` as its upper-left corner, width of `(width + 2h)`, and a height of `(height + 2v)`. If negative values are supplied for `h` and `v`, the size of the `Rectangle` decreases accordingly. The `grow` method will check for integer overflow and underflow, but does not check whether the resulting values of `width` and `height` grow from negative to non-negative or shrink from non-negative to negative. Parameters: `h` - the horizontal expansion `v` - the vertical expansion
	hashCode	`int` hashCode() Returns the hashcode for this `Rectangle2D`. public int hashCode() Description copied from class: `java.awt.geom.Rectangle2D` Returns the hashcode for this `Rectangle2D`. Overrides: `hashCode` in class `java.lang.Object` Returns: the hashcode for this `Rectangle2D`. Since: 1.2 See Also: `Object.equals(java.lang.Object)`, `System.identityHashCode(java.lang.Object)`
	inside	`boolean` inside(int X, int Y) Deprecated. As of JDK version 1.1, replaced by `contains(int, int)`. @Deprecated public boolean inside(int X, int Y) Deprecated. As of JDK version 1.1, replaced by `contains(int, int)`. Checks whether or not this `Rectangle` contains the point at the specified location `(X,Y)`. Parameters: `X` - the specified X coordinate `Y` - the specified Y coordinate Returns: `true` if the point `(X,Y)` is inside this `Rectangle`; `false` otherwise.
	intersection	`Rectangle` intersection(Rectangle r) Computes the intersection of this `Rectangle` with the specified `Rectangle`. public Rectangle intersection(Rectangle r) Computes the intersection of this `Rectangle` with the specified `Rectangle`. Returns a new `Rectangle` that represents the intersection of the two rectangles. If the two rectangles do not intersect, the result will be an empty rectangle. Parameters: `r` - the specified `Rectangle` Returns: the largest `Rectangle` contained in both the specified `Rectangle` and in this `Rectangle`; or if the rectangles do not intersect, an empty rectangle.
	intersects	`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. public boolean intersects(double x, double y, double w, double h) Description copied from class: `java.awt.geom.Rectangle2D` 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`
	intersects	`boolean` intersects(Rectangle r) Determines whether or not this `Rectangle` and the specified `Rectangle` intersect. public boolean intersects(Rectangle r) Determines whether or not this `Rectangle` and the specified `Rectangle` intersect. Two rectangles intersect if their intersection is nonempty. Parameters: `r` - the specified `Rectangle` Returns: `true` if the specified `Rectangle` and this `Rectangle` intersect; `false` otherwise.
	intersects	`boolean` intersects(java.awt.geom.Rectangle2D r) Tests if the interior of the `Shape` intersects the interior of a specified `Rectangle2D`. public boolean intersects(java.awt.geom.Rectangle2D r) Description copied from class: `java.awt.geom.RectangularShape` 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)`
	intersectsLine	`boolean` intersectsLine(double x1, double y1, double x2, double y2) Tests if the specified line segment intersects the interior of this `Rectangle2D`. public boolean intersectsLine(double x1, double y1, double x2, double y2) Description copied from class: `java.awt.geom.Rectangle2D` 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	`boolean` intersectsLine(java.awt.geom.Line2D l) Tests if the specified line segment intersects the interior of this `Rectangle2D`. public boolean intersectsLine(java.awt.geom.Line2D l) Description copied from class: `java.awt.geom.Rectangle2D` 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
	isEmpty	`boolean` isEmpty() Determines whether the `RectangularShape` is empty. public boolean isEmpty() Determines whether the `RectangularShape` is empty. When the `RectangularShape` is empty, it encloses no area. Specified by: `isEmpty` in class `java.awt.geom.RectangularShape` Returns: `true` if the `RectangularShape` is empty; `false` otherwise. Since: 1.2
	move	`void` move(int x, int y) Deprecated. As of JDK version 1.1, replaced by `setLocation(int, int)`. @Deprecated public void move(int x, int y) Deprecated. As of JDK version 1.1, replaced by `setLocation(int, int)`. Moves this `Rectangle` to the specified location. Parameters: `x` - the X coordinate of the new location `y` - the Y coordinate of the new location
	outcode	`int` outcode(double x, double y) Determines where the specified coordinates lie with respect to this `Rectangle2D`. public 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`. Specified by: `outcode` in class `java.awt.geom.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: `Rectangle2D.OUT_LEFT`, `Rectangle2D.OUT_TOP`, `Rectangle2D.OUT_RIGHT`, `Rectangle2D.OUT_BOTTOM`
	outcode	`int` outcode(java.awt.geom.Point2D p) Determines where the specified `Point2D` lies with respect to this `Rectangle2D`. public int outcode(java.awt.geom.Point2D p) Description copied from class: `java.awt.geom.Rectangle2D` 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: `Rectangle2D.OUT_LEFT`, `Rectangle2D.OUT_TOP`, `Rectangle2D.OUT_RIGHT`, `Rectangle2D.OUT_BOTTOM`
	reshape	`void` reshape(int x, int y, int width, int height) Deprecated. As of JDK version 1.1, replaced by `setBounds(int, int, int, int)`. @Deprecated public void reshape(int x, int y, int width, int height) Deprecated. As of JDK version 1.1, replaced by `setBounds(int, int, int, int)`. Sets the bounding `Rectangle` of this `Rectangle` to the specified `x`, `y`, `width`, and `height`. Parameters: `x` - the new X coordinate for the upper-left corner of this `Rectangle` `y` - the new Y coordinate for the upper-left corner of this `Rectangle` `width` - the new width for this `Rectangle` `height` - the new height for this `Rectangle`
	resize	`void` resize(int width, int height) Deprecated. As of JDK version 1.1, replaced by `setSize(int, int)`. @Deprecated public void resize(int width, int height) Deprecated. As of JDK version 1.1, replaced by `setSize(int, int)`. Sets the size of this `Rectangle` to the specified width and height. Parameters: `width` - the new width for this `Rectangle` `height` - the new height for this `Rectangle`
	setBounds	`void` setBounds(int x, int y, int width, int height) Sets the bounding `Rectangle` of this `Rectangle` to the specified `x`, `y`, `width`, and `height`. public void setBounds(int x, int y, int width, int height) Sets the bounding `Rectangle` of this `Rectangle` to the specified `x`, `y`, `width`, and `height`. This method is included for completeness, to parallel the `setBounds` method of `Component`. Parameters: `x` - the new X coordinate for the upper-left corner of this `Rectangle` `y` - the new Y coordinate for the upper-left corner of this `Rectangle` `width` - the new width for this `Rectangle` `height` - the new height for this `Rectangle` Since: 1.1 See Also: `getBounds()`, `Component.setBounds(int, int, int, int)`
	setBounds	`void` setBounds(Rectangle r) Sets the bounding `Rectangle` of this `Rectangle` to match the specified `Rectangle`. public void setBounds(Rectangle r) Sets the bounding `Rectangle` of this `Rectangle` to match the specified `Rectangle`. This method is included for completeness, to parallel the `setBounds` method of `Component`. Parameters: `r` - the specified `Rectangle` Since: 1.1 See Also: `getBounds()`, `Component.setBounds(java.awt.Rectangle)`
	setFrame	`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. public void setFrame(double x, double y, double w, double h) Description copied from class: `java.awt.geom.Rectangle2D` Sets the location and size of the outer bounds of this `Rectangle2D` to the specified rectangular values. Specified by: `setFrame` in class `java.awt.geom.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()`
	setFrame	`void` setFrame(java.awt.geom.Point2D loc, java.awt.geom.Dimension2D size) Sets the location and size of the framing rectangle of this `Shape` to the specified `Point2D` and `Dimension2D`, respectively. public void setFrame(java.awt.geom.Point2D loc, java.awt.geom.Dimension2D size) Description copied from class: `java.awt.geom.RectangularShape` 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: `RectangularShape.getFrame()`
	setFrame	`void` setFrame(java.awt.geom.Rectangle2D r) Sets the framing rectangle of this `Shape` to be the specified `Rectangle2D`. public void setFrame(java.awt.geom.Rectangle2D r) Description copied from class: `java.awt.geom.RectangularShape` 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: `RectangularShape.getFrame()`
	setFrameFromCenter	`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. public void setFrameFromCenter(double centerX, double centerY, double cornerX, double cornerY) Description copied from class: `java.awt.geom.RectangularShape` 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	`void` setFrameFromCenter(java.awt.geom.Point2D center, java.awt.geom.Point2D corner) Sets the framing rectangle of this `Shape` based on a specified center `Point2D` and corner `Point2D`. public void setFrameFromCenter(java.awt.geom.Point2D center, java.awt.geom.Point2D corner) Description copied from class: `java.awt.geom.RectangularShape` 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
	setFrameFromDiagonal	`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. public void setFrameFromDiagonal(double x1, double y1, double x2, double y2) Description copied from class: `java.awt.geom.RectangularShape` 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	`void` setFrameFromDiagonal(java.awt.geom.Point2D p1, java.awt.geom.Point2D p2) Sets the diagonal of the framing rectangle of this `Shape` based on two specified `Point2D` objects. public void setFrameFromDiagonal(java.awt.geom.Point2D p1, java.awt.geom.Point2D p2) Description copied from class: `java.awt.geom.RectangularShape` 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
	setLocation	`void` setLocation(int x, int y) Moves this `Rectangle` to the specified location. public void setLocation(int x, int y) Moves this `Rectangle` to the specified location. This method is included for completeness, to parallel the `setLocation` method of `Component`. Parameters: `x` - the X coordinate of the new location `y` - the Y coordinate of the new location Since: 1.1 See Also: `getLocation()`, `Component.setLocation(int, int)`
	setLocation	`void` setLocation(Point p) Moves this `Rectangle` to the specified location. public void setLocation(Point p) Moves this `Rectangle` to the specified location. This method is included for completeness, to parallel the `setLocation` method of `Component`. Parameters: `p` - the `Point` specifying the new location for this `Rectangle` Since: 1.1 See Also: `Component.setLocation(java.awt.Point)`, `getLocation()`
	setRect	`void` setRect(double x, double y, double width, double height) Sets the bounds of this `Rectangle` to the integer bounds which encompass the specified `x`, `y`, `width`, and `height`. public void setRect(double x, double y, double width, double height) Sets the bounds of this `Rectangle` to the integer bounds which encompass the specified `x`, `y`, `width`, and `height`. If the parameters specify a `Rectangle` that exceeds the maximum range of integers, the result will be the best representation of the specified `Rectangle` intersected with the maximum integer bounds. Specified by: `setRect` in class `java.awt.geom.Rectangle2D` Parameters: `x` - the X coordinate of the upper-left corner of the specified rectangle `y` - the Y coordinate of the upper-left corner of the specified rectangle `width` - the width of the specified rectangle `height` - the new height of the specified rectangle
	setRect	`void` setRect(java.awt.geom.Rectangle2D r) Sets this `Rectangle2D` to be the same as the specified `Rectangle2D`. public void setRect(java.awt.geom.Rectangle2D r) Description copied from class: `java.awt.geom.Rectangle2D` Sets this `Rectangle2D` to be the same as the specified `Rectangle2D`. Parameters: `r` - the specified `Rectangle2D` Since: 1.2
	setSize	`void` setSize(Dimension d) Sets the size of this `Rectangle` to match the specified `Dimension`. public void setSize(Dimension d) Sets the size of this `Rectangle` to match the specified `Dimension`. This method is included for completeness, to parallel the `setSize` method of `Component`. Parameters: `d` - the new size for the `Dimension` object Since: 1.1 See Also: `Component.setSize(java.awt.Dimension)`, `getSize()`
	setSize	`void` setSize(int width, int height) Sets the size of this `Rectangle` to the specified width and height. public void setSize(int width, int height) Sets the size of this `Rectangle` to the specified width and height. This method is included for completeness, to parallel the `setSize` method of `Component`. Parameters: `width` - the new width for this `Rectangle` `height` - the new height for this `Rectangle` Since: 1.1 See Also: `Component.setSize(int, int)`, `getSize()`
	toString	`java.lang.String` toString() Returns a `String` representing this `Rectangle` and its values. public java.lang.String toString() Returns a `String` representing this `Rectangle` and its values. Overrides: `toString` in class `java.lang.Object` Returns: a `String` representing this `Rectangle` object's coordinate and size values.
	translate	`void` translate(int dx, int dy) Translates this `Rectangle` the indicated distance, to the right along the X coordinate axis, and downward along the Y coordinate axis. public void translate(int dx, int dy) Translates this `Rectangle` the indicated distance, to the right along the X coordinate axis, and downward along the Y coordinate axis. Parameters: `dx` - the distance to move this `Rectangle` along the X axis `dy` - the distance to move this `Rectangle` along the Y axis See Also: `setLocation(int, int)`, `setLocation(java.awt.Point)`
	union	`Rectangle` union(Rectangle r) Computes the union of this `Rectangle` with the specified `Rectangle`. public Rectangle union(Rectangle r) Computes the union of this `Rectangle` with the specified `Rectangle`. Returns a new `Rectangle` that represents the union of the two rectangles. If either `Rectangle` has any dimension less than zero the rules for non-existant rectangles apply. If only one has a dimension less than zero, then the result will be a copy of the other `Rectangle`. If both have dimension less than zero, then the result will have at least one dimension less than zero. If the resulting `Rectangle` would have a dimension too large to be expressed as an `int`, the result will have a dimension of `Integer.MAX_VALUE` along that dimension. Parameters: `r` - the specified `Rectangle` Returns: the smallest `Rectangle` containing both the specified `Rectangle` and this `Rectangle`.

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

SourceForge

Class Rectangle

Methods inherited from class java.lang.Object