# 2d Rectangle

Volume of a Rectangle Calculator. A Rectangular box is a geometrical figure bounded by six quadrilateral faces. The shape is also known as the rectangular cuboid, right cuboid, rectangular hexahedron, right rectangular prism, or rectangular parallelepiped. The volume of a rectangular box is the amount of space occupied by the object. Hello everyone,For this tutorial video, I would like to demonstrate the perimeter and area of a rectangle graphically, exactly like how I did with the square.

JavaScript is disabled on your browser.
• Class

## Class Rectangle2D

• java.awt.geom.Rectangle2D
• All Implemented Interfaces:
Shape, Cloneable
Direct Known Subclasses:
Rectangle, Rectangle2D.Double, Rectangle2D.Float

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 TypeClass and 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 TypeField and 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
ModifierConstructor and Description
`protected ``Rectangle2D()`
This is an abstract class that cannot be instantiated directly.
• ### Method Summary

Methods
Modifier and TypeMethod and 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)`
`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()`
`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 inherited from 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 inherited from class java.lang.Object

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

## Holo 2d Rectangle

• ### Field Detail

• #### OUT_LEFT

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

The bitmask that indicates that a point lies above this `Rectangle2D`.
Since:
1.2
Constant Field Values
• #### OUT_RIGHT

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

The bitmask that indicates that a point lies below this `Rectangle2D`.
Since:
1.2
Constant Field Values
• ### Constructor Detail

• #### 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
`Rectangle2D.Float`, `Rectangle2D.Double`, `Rectangle`
• ### Method Detail

• #### setRect

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

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

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

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

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
`OUT_LEFT`, `OUT_TOP`, `OUT_RIGHT`, `OUT_BOTTOM`
• #### outcode

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
`OUT_LEFT`, `OUT_TOP`, `OUT_RIGHT`, `OUT_BOTTOM`
• #### setFrame

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
`RectangularShape.getFrame()`
• #### 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
`Shape.getBounds()`
• #### contains

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

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
`Area`
• #### contains

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
`Area`, `Shape.intersects(double, double, double, double)`
• #### createIntersection

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

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

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

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

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

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

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

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

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

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

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
`Object.hashCode()`, `HashMap`
• Class

## 2d Rectangle Area Formula

• Summary:
• Nested
• Field
• Constr
• Detail:
• Field
• Constr

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.