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.

@version
1.29, 12/19/03
@author
Jim Graham
The bitmask that indicates that a point lies below this Rectangle2D.
@since
1.2
The bitmask that indicates that a point lies to the left of this Rectangle2D.
@since
1.2
The bitmask that indicates that a point lies to the right of this Rectangle2D.
@since
1.2
The bitmask that indicates that a point lies above this Rectangle2D.
@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, newythe coordinates of the new point
@since
JDK1.0
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
ptthe new Point2D to add to this Rectangle2D.
@since
JDK1.0
Adds a Rectangle2D object to this Rectangle2D. The resulting Rectangle2D is the union of the two Rectangle2D objects.
Parameters
rthe Rectangle2D to add to this Rectangle2D.
@since
JDK1.0
Creates a new object of the same class and with the same contents as this object.
Return
a clone of this instance.
Throws
OutOfMemoryErrorif there is not enough memory.
@since
1.2
Tests if a specified coordinate is inside the boundary of this Rectangle2D.
Parameters
x, ythe coordinates to test
Return
true if the specified coordinates are inside the boundary of this Rectangle2D; false otherwise.
@since
1.2
Tests if the interior of this Rectangle2D entirely contains the specified set of rectangular coordinates.
Parameters
x, ythe coordinates of the upper left corner of the specified set of rectangular coordinates
wthe width of the specified set of rectangular coordinates
hthe height of the specified set of rectangular coordinates
Return
true if this Rectangle2D entirely contains specified set of rectangular coordinates; false otherwise.
@since
1.2
Tests if a specified Point2D is inside the boundary of the Shape.
Parameters
pthe specified Point2D
Return
true if the Point2D is inside the Shape object's boundary; false otherwise.
Tests if the interior of the Shape entirely contains the specified Rectangle2D.
Parameters
rthe specified Rectangle2D
Return
true if the Shape entirely contains the specified Rectangle2D; false otherwise.
Returns a new Rectangle2D object representing the intersection of this Rectangle2D with the specified Rectangle2D.
Parameters
rthe Rectangle2D to be intersected with this Rectangle2D
Return
the largest Rectangle2D contained in both the specified Rectangle2D and in this Rectangle2D.
@since
1.2
Returns a new Rectangle2D object representing the union of this Rectangle2D with the specified Rectangle2D.
Parameters
rthe Rectangle2D to be combined with this Rectangle2D
Return
the smallest Rectangle2D containing both the specified Rectangle2D and this Rectangle2D.
@since
1.2
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.
Parameters
objan Object to be compared with this Rectangle2D.
Return
true if obj is an instance of Rectangle2D and has the same values; false otherwise.
@since
1.2
Returns the bounding box of the Shape.
Return
a {@link Rectangle} object that bounds the Shape.
Returns the high precision bounding box of this Rectangle2D.
Return
the bounding box of this Rectangle2D.
@since
1.2
Returns the X coordinate of the center of the framing rectangle of the Shape in double precision.
Return
the x coordinate of the framing rectangle of the Shape object's center.
Returns the Y coordinate of the center of the framing rectangle of the Shape in double precision.
Return
the y coordinate of the framing rectangle of the Shape object's center.
Returns the runtime class of an object. That Class object is the object that is locked by static synchronized methods of the represented class.
Return
The java.lang.Class object that represents the runtime class of the object. The result is of type {@code Class} where X is the erasure of the static type of the expression on which getClass is called.
Returns the framing Rectangle2D that defines the overall shape of this object.
Return
a Rectangle2D, specified in double coordinates.
Returns the height of the framing rectangle in double precision.
Return
the height of the framing rectangle.
Returns the largest X coordinate of the framing rectangle of the Shape in double precision.
Return
the largest x coordinate of the framing rectangle of the Shape.
Returns the largest Y coordinate of the framing rectangle of the Shape in double precision.
Return
the largest y coordinate of the framing rectangle of the Shape.
Returns the smallest X coordinate of the framing rectangle of the Shape in double precision.
Return
the smallest x coordinate of the framing rectangle of the Shape.
Returns the smallest Y coordinate of the framing rectangle of the Shape in double precision.
Return
the smallest y coordinate of the framing rectangle of the Shape.
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
atan optional AffineTransform to be applied to the coordinates as they are returned in the iteration, or null if untransformed coordinates are desired
Return
the PathIterator object that returns the geometry of the outline of this Rectangle2D, one segment at a time.
@since
1.2
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.
Parameters
atan optional AffineTransform to be applied to the coordinates as they are returned in the iteration, or null if untransformed coordinates are desired
flatnessthe 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.
Return
the PathIterator object that returns the geometry of the outline of this Rectangle2D, one segment at a time.
@since
1.2
Returns the width of the framing rectangle in double precision.
Return
the width of the framing rectangle.
Returns the X coordinate of the upper left corner of the framing rectangle in double precision.
Return
the x coordinate of the upper left corner of the framing rectangle.
Returns the Y coordinate of the upper left corner of the framing rectangle in double precision.
Return
the y coordinate of the upper left corner of the framing rectangle.
Returns the hashcode for this Rectangle2D.
Return
the hashcode for this 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
src1the first of a pair of Rectangle2D objects to be intersected with each other
src2the second of a pair of Rectangle2D objects to be intersected with each other
destthe Rectangle2D that holds the results of the intersection of src1 and src2
@since
1.2
Tests if the interior of this Rectangle2D intersects the interior of a specified set of rectangular coordinates.
Parameters
x, ythe coordinates of the upper left corner of the specified set of rectangular coordinates
wthe width of the specified set of rectangular coordinates
hthe height of the specified set of rectangular coordinates
Return
true if this Rectangle2D intersects the interior of a specified set of rectangular coordinates; false otherwise.
@since
1.2
Tests if the interior of theShape intersects the interior of a specified Rectangle2D.
Parameters
rthe specified Rectangle2D
Return
true if the Shape and the specified Rectangle2D intersect each other; false otherwise.
Tests if the specified line segment intersects the interior of this Rectangle2D.
Parameters
x1, y1the first endpoint of the specified line segment
x2, y2the second endpoint of the specified line segment
Return
true if the specified line segment intersects the interior of this Rectangle2D; false otherwise.
@since
1.2
Tests if the specified line segment intersects the interior of this Rectangle2D.
Parameters
lthe specified {@link Line2D} to test for intersection with the interior of this Rectangle2D
Return
true if the specified Line2D intersects the interior of this Rectangle2D; false otherwise.
@since
1.2
Determines whether the RectangularShape is empty. When the RectangularShape is empty, it encloses no area.
Return
true if the RectangularShape is empty; false otherwise.
Wakes up a single thread that is waiting on this object's monitor. If any threads are waiting on this object, one of them is chosen to be awakened. The choice is arbitrary and occurs at the discretion of the implementation. A thread waits on an object's monitor by calling one of the wait methods.

The awakened thread will not be able to proceed until the current thread relinquishes the lock on this object. The awakened thread will compete in the usual manner with any other threads that might be actively competing to synchronize on this object; for example, the awakened thread enjoys no reliable privilege or disadvantage in being the next thread to lock this object.

This method should only be called by a thread that is the owner of this object's monitor. A thread becomes the owner of the object's monitor in one of three ways:

  • By executing a synchronized instance method of that object.
  • By executing the body of a synchronized statement that synchronizes on the object.
  • For objects of type Class, by executing a synchronized static method of that class.

Only one thread at a time can own an object's monitor.

Throws
IllegalMonitorStateExceptionif the current thread is not the owner of this object's monitor.
Wakes up all threads that are waiting on this object's monitor. A thread waits on an object's monitor by calling one of the wait methods.

The awakened threads will not be able to proceed until the current thread relinquishes the lock on this object. The awakened threads will compete in the usual manner with any other threads that might be actively competing to synchronize on this object; for example, the awakened threads enjoy no reliable privilege or disadvantage in being the next thread to lock this object.

This method should only be called by a thread that is the owner of this object's monitor. See the notify method for a description of the ways in which a thread can become the owner of a monitor.

Throws
IllegalMonitorStateExceptionif the current thread is not the owner of this object's monitor.
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, ythe specified coordinates
Return
the logical OR of all appropriate out codes.
@since
1.2
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
pthe specified Point2D
Return
the logical OR of all appropriate out codes.
@since
1.2
Sets the location and size of the outer bounds of this Rectangle2D to the specified rectangular values.
Parameters
x, ythe coordinates to which to set the location of the upper left corner of the outer bounds of this Rectangle2D
wthe value to use to set the width of the outer bounds of this Rectangle2D
hthe value to use to set the height of the outer bounds of this Rectangle2D
@since
1.2
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
locthe specified Point2D
sizethe specified Dimension2D
See Also
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
rthe specified Rectangle2D
See Also
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, centerYthe center point coordinates
cornerX, cornerYthe corner point coordinates
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
centerthe specified center Point2D
cornerthe specified corner Point2D
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, y1the first specified coordinates
x2, y2the second specified coordinates
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, p2the two specified Point2D objects
Sets the location and size of this Rectangle2D to the specified double values.
Parameters
x, ythe coordinates to which to set the location of the upper left corner of this Rectangle2D
wthe value to use to set the width of this Rectangle2D
hthe value to use to set the height of this Rectangle2D
@since
1.2
Sets this Rectangle2D to be the same as the specified Rectangle2D.
Parameters
rthe specified Rectangle2D
@since
1.2
Returns a string representation of the object. In general, the toString method returns a string that "textually represents" this object. The result should be a concise but informative representation that is easy for a person to read. It is recommended that all subclasses override this method.

The toString method for class Object returns a string consisting of the name of the class of which the object is an instance, the at-sign character `@', and the unsigned hexadecimal representation of the hash code of the object. In other words, this method returns a string equal to the value of:

 getClass().getName() + '@' + Integer.toHexString(hashCode())
 
Return
a string representation of the object.
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
src1the first of a pair of Rectangle2D objects to be combined with each other
src2the second of a pair of Rectangle2D objects to be combined with each other
destthe Rectangle2D that holds the results of the union of src1 and src2
@since
1.2
Causes current thread to wait until another thread invokes the method or the method for this object. In other words, this method behaves exactly as if it simply performs the call wait(0).

The current thread must own this object's monitor. The thread releases ownership of this monitor and waits until another thread notifies threads waiting on this object's monitor to wake up either through a call to the notify method or the notifyAll method. The thread then waits until it can re-obtain ownership of the monitor and resumes execution.

As in the one argument version, interrupts and spurious wakeups are possible, and this method should always be used in a loop:

     synchronized (obj) {
         while (<condition does not hold>)
             obj.wait();
         ... // Perform action appropriate to condition
     }
 
This method should only be called by a thread that is the owner of this object's monitor. See the notify method for a description of the ways in which a thread can become the owner of a monitor.
Throws
IllegalMonitorStateExceptionif the current thread is not the owner of the object's monitor.
InterruptedExceptionif another thread interrupted the current thread before or while the current thread was waiting for a notification. The interrupted status of the current thread is cleared when this exception is thrown.
Causes current thread to wait until either another thread invokes the method or the method for this object, or a specified amount of time has elapsed.

The current thread must own this object's monitor.

This method causes the current thread (call it T) to place itself in the wait set for this object and then to relinquish any and all synchronization claims on this object. Thread T becomes disabled for thread scheduling purposes and lies dormant until one of four things happens:

  • Some other thread invokes the notify method for this object and thread T happens to be arbitrarily chosen as the thread to be awakened.
  • Some other thread invokes the notifyAll method for this object.
  • Some other thread interrupts thread T.
  • The specified amount of real time has elapsed, more or less. If timeout is zero, however, then real time is not taken into consideration and the thread simply waits until notified.
The thread T is then removed from the wait set for this object and re-enabled for thread scheduling. It then competes in the usual manner with other threads for the right to synchronize on the object; once it has gained control of the object, all its synchronization claims on the object are restored to the status quo ante - that is, to the situation as of the time that the wait method was invoked. Thread T then returns from the invocation of the wait method. Thus, on return from the wait method, the synchronization state of the object and of thread T is exactly as it was when the wait method was invoked.

A thread can also wake up without being notified, interrupted, or timing out, a so-called spurious wakeup. While this will rarely occur in practice, applications must guard against it by testing for the condition that should have caused the thread to be awakened, and continuing to wait if the condition is not satisfied. In other words, waits should always occur in loops, like this one:

     synchronized (obj) {
         while (<condition does not hold>)
             obj.wait(timeout);
         ... // Perform action appropriate to condition
     }
 
(For more information on this topic, see Section 3.2.3 in Doug Lea's "Concurrent Programming in Java (Second Edition)" (Addison-Wesley, 2000), or Item 50 in Joshua Bloch's "Effective Java Programming Language Guide" (Addison-Wesley, 2001).

If the current thread is interrupted by another thread while it is waiting, then an InterruptedException is thrown. This exception is not thrown until the lock status of this object has been restored as described above.

Note that the wait method, as it places the current thread into the wait set for this object, unlocks only this object; any other objects on which the current thread may be synchronized remain locked while the thread waits.

This method should only be called by a thread that is the owner of this object's monitor. See the notify method for a description of the ways in which a thread can become the owner of a monitor.

Parameters
timeoutthe maximum time to wait in milliseconds.
Throws
IllegalArgumentExceptionif the value of timeout is negative.
IllegalMonitorStateExceptionif the current thread is not the owner of the object's monitor.
InterruptedExceptionif another thread interrupted the current thread before or while the current thread was waiting for a notification. The interrupted status of the current thread is cleared when this exception is thrown.
Causes current thread to wait until another thread invokes the method or the method for this object, or some other thread interrupts the current thread, or a certain amount of real time has elapsed.

This method is similar to the wait method of one argument, but it allows finer control over the amount of time to wait for a notification before giving up. The amount of real time, measured in nanoseconds, is given by:

 1000000*timeout+nanos

In all other respects, this method does the same thing as the method of one argument. In particular, wait(0, 0) means the same thing as wait(0).

The current thread must own this object's monitor. The thread releases ownership of this monitor and waits until either of the following two conditions has occurred:

  • Another thread notifies threads waiting on this object's monitor to wake up either through a call to the notify method or the notifyAll method.
  • The timeout period, specified by timeout milliseconds plus nanos nanoseconds arguments, has elapsed.

The thread then waits until it can re-obtain ownership of the monitor and resumes execution.

As in the one argument version, interrupts and spurious wakeups are possible, and this method should always be used in a loop:

     synchronized (obj) {
         while (<condition does not hold>)
             obj.wait(timeout, nanos);
         ... // Perform action appropriate to condition
     }
 
This method should only be called by a thread that is the owner of this object's monitor. See the notify method for a description of the ways in which a thread can become the owner of a monitor.
Parameters
timeoutthe maximum time to wait in milliseconds.
nanosadditional time, in nanoseconds range 0-999999.
Throws
IllegalArgumentExceptionif the value of timeout is negative or the value of nanos is not in the range 0-999999.
IllegalMonitorStateExceptionif the current thread is not the owner of this object's monitor.
InterruptedExceptionif another thread interrupted the current thread before or while the current thread was waiting for a notification. The interrupted status of the current thread is cleared when this exception is thrown.