Rectangle specifies an area in a coordinate space that is
enclosed by the Rectangle object's top-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 negative is considered
empty. If the Rectangle is empty, then the
isEmpty method returns true. No point can be
contained by or inside an empty Rectangle. The
values of width and height, however, are still
valid. An empty Rectangle still has a location in the
coordinate space, and methods that change its size or location remain
valid. The behavior of methods that operate on more than one
Rectangle is undefined if any of the participating
Rectangle objects has a negative
width or height. These methods include
intersects, intersection, and
union.
Rectangle whose top-left corner
is at (0, 0) in the coordinate space, and whose width and
height are both zero.Rectangle, initialized to match
the values of the specified Rectangle.Rectangle whose top-left corner is
specified as
(x, y) and whose width and height
are specified by the arguments of the same name.Rectangle whose top-left corner
is at (0, 0) in the coordinate space, and whose width and
height are specified by the arguments of the same name.Rectangle whose top-left corner is the
specified Point, and whose width and height are both zero.Rectangle whose top left corner is
(0, 0) and whose width and height are specified
by the Dimension argument.Rectangle.Rectangle2D.Rectangle2D.Rectangle2D.Rectangle2D.Rectangle.Rectangle.Rectangle.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.
newx
and newy, to this Rectangle. The
resulting Rectangle is
the smallest Rectangle that contains both the
original Rectangle 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 right or bottom edge of the enlarged
Rectangle, contains returns
false for that point.
Point to this
Rectangle. The resulting Rectangle
is the smallest Rectangle that contains both the
original Rectangle 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 right or bottom edge of the
enlarged Rectangle, contains returns
false for that Point.
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.
Rectangle to this Rectangle.
The resulting Rectangle is the union of the two
rectangles.Rectangle2D object to this
Rectangle2D. The resulting Rectangle2D
is the union of the two Rectangle2D objects.Rectangle2D.Rectangle2D entirely
contains the specified set of rectangular coordinates.Rectangle contains the
point at the specified location
(x, y).Rectangle entirely contains
the Rectangle
at the specified location (X, Y) with the
specified dimensions (W, H).Rectangle contains the
specified Point.Point2D is inside the boundary
of the Shape.Rectangle entirely contains
the specified Rectangle.Shape entirely contains the
specified Rectangle2D.Rectangle with the
specified Rectangle2D.Rectangle2D object representing the
union of this Rectangle with the specified
Rectangle2D.
The result is true if and only if the argument is not
null and is a Rectangle object that has the
same top-left corner, width, and height as this Rectangle.
Rectangle of this Rectangle.
This method is included for completeness, to parallel the
getBounds method of
Component
.
Shape in double
precision.Shape in double
precision.Rectangle in
double precision.Rectangle.
This method is included for completeness, to parallel the
getLocation method of Component.
Shape in double
precision.Shape in double
precision.Shape in double
precision.Shape in double
precision.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.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.Rectangle, represented by
the returned Dimension.
This method is included for completeness, to parallel the
getSize method of Component.
Rectangle in
double precision.Rectangle in
double precision.Rectangle in
double precision.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 top-left corner, a
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 does not check whether the resulting
values of width and height are
non-negative.
Rectangle2D.Rectangle contains the
point at the specified location
(X, Y).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.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.Rectangle2D
intersects the interior of a specified set of rectangular
coordinates.Rectangle and the specified
Rectangle intersect. Two rectangles intersect if
their intersection is nonempty.Shape intersects the
interior of a specified Rectangle2D.Rectangle2D.Rectangle2D.Rectangle is empty. A
Rectangle is empty if its width or its height is less
than or equal to zero.Rectangle to the specified location.
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:
synchronized statement
that synchronizes on the object.
Class, by executing a
synchronized static method of that class.
Only one thread at a time can own an object's monitor.
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.
Rectangle.
This method computes a binary OR of the appropriate mask values
indicating, for each side of this Rectangle,
whether or not the specified coordinates are on the same side of the
edge as the rest of this Rectangle.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.Rectangle of this
Rectangle to the specified
x, y, width,
and height.
Rectangle to the specified
width and height.
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.
Rectangle of this Rectangle
to match the specified Rectangle.
This method is included for completeness, to parallel the
setBounds method of Component.
Rectangle2D to the specified rectangular values.Shape to the specified Point2D
and
Dimension2D
, respectively. The framing rectangle is used
by the subclasses of RectangularShape to define
their geometry.Shape to
be the specified Rectangle2D. The framing rectangle is
used by the subclasses of RectangularShape to define
their geometry.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.Shape based on a
specified center Point2D and corner
Point2D. The framing rectangle is used by the subclasses
of RectangularShape to define their geometry.Shape
based on the two specified coordinates. The framing rectangle is
used by the subclasses of RectangularShape to define
their geometry.Shape
based on two specified Point2D objects. The framing
rectangle is used by the subclasses of RectangularShape
to define their geometry.Rectangle to the specified location.
This method is included for completeness, to parallel the
setLocation method of Component.
Rectangle to the specified location.
This method is included for completeness, to parallel the
setLocation method of Component.
Rectangle to the specified
x, y, width,
and height.
This method is included for completeness, to parallel the
setBounds method of Component.Rectangle2D to be the same as the specified
Rectangle2D.Rectangle to match the
specified Dimension.
This method is included for completeness, to parallel the
setSize method of Component.
Rectangle to the specified
width and height.
This method is included for completeness, to parallel the
setSize method of Component.
String representing this
Rectangle and its values.Rectangle the indicated distance,
to the right along the x coordinate axis, and
downward along the y coordinate axis.Rectangle with the
specified Rectangle. Returns a new
Rectangle that
represents the union of the two rectanglesRectangle2D 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.
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.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:
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.
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:
notify method
or the notifyAll method.
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.