A new certificate handling package is created in the Java platform.
This Certificate interface is entirely deprecated and
is here to allow for a smooth transition to the new
package.
This change is effective since API version 6. This class conflicts with the sandbox design. You are
discouraged from using them. This class will be deleted in a future release.
This change is effective since API version 6. This class conflicts with the sandbox design. You are
discouraged from using them. This class will be deleted in a future release.
This change is effective since API version 6. This class conflicts with the sandbox design. You are
discouraged from using them. This class will be deleted in a future release.
This change is effective since API version 6. This class conflicts with the sandbox design. You are
discouraged from using them. This class will be deleted in a future release.
This class is no longer used. Its functionality has been
replaced by java.security.KeyStore, the
java.security.cert package, and
java.security.Principal.
This class is no longer used. Its functionality has been
replaced by java.security.KeyStore, the
java.security.cert package, and
java.security.Principal.
This class incorrectly assumes that bytes adequately represent
characters. As of JDK 1.1, the preferred way to operate on
character streams is via the new character-stream classes, which
include a class for counting line numbers.
This class is no longer used. Its functionality has been
replaced by java.security.KeyStore, the
java.security.cert package, and
java.security.Principal.
This class does not properly convert characters into bytes. As
of JDK 1.1, the preferred way to create a stream from a
string is via the StringReader class.
Initialization of this field is prone to deadlocks.
The field must be initialized by the Logger class initialization
which may cause deadlocks with the LogManager class initialization.
In such cases two class initialization wait for each other to complete.
The preferred way to get the global logger object is via the call
Logger.getGlobal().
For compatibility with old JDK versions where the
Logger.getGlobal() is not available use the call
Logger.getLogger(Logger.GLOBAL_LOGGER_NAME)
or Logger.getLogger("global").
The dependency on PropertyChangeListener creates
a significant impediment to future modularization of the
Java platform. This method will be removed in a future
release.
Applications that need to monitor progress of the packer
can poll the value of the PROGRESS
property instead.
The dependency on PropertyChangeListener creates
a significant impediment to future modularization of the
Java platform. This method will be removed in a future
release.
Applications that need to monitor progress of the
unpacker can poll the value of the PROGRESS property instead.
The dependency on PropertyChangeListener creates a
significant impediment to future modularization of the Java
platform. This method will be removed in a future release.
The global LogManager can detect changes to the
logging configuration by overridding the readConfiguration method.
The dependency on AWTPermission creates an
impediment to future modularization of the Java platform.
Users of this method should instead invoke
SecurityManager.checkPermission(java.security.Permission) directly.
This method will be changed in a future release to check
the permission java.security.AllPermission.
This method relies on the caller being at a stack depth
of 4 which is error-prone and cannot be enforced by the runtime.
Users of this method should instead invoke SecurityManager.checkPermission(java.security.Permission)
directly. This method will be changed in a future release
to check the permission java.security.AllPermission.
The dependency on AWTPermission creates an
impediment to future modularization of the Java platform.
Users of this method should instead invoke
SecurityManager.checkPermission(java.security.Permission) directly.
This method will be changed in a future release to check
the permission java.security.AllPermission.
The dependency on AWTPermission creates an
impediment to future modularization of the Java platform.
Users of this method should instead invoke
SecurityManager.checkPermission(java.security.Permission) directly.
This method will be changed in a future release to check
the permission java.security.AllPermission.
This method was originally designed to destroy this
thread without any cleanup. Any monitors it held would have
remained locked. However, the method was never implemented.
If if were to be implemented, it would be deadlock-prone in
much the manner of Thread.suspend(). If the target thread held
a lock protecting a critical system resource when it was
destroyed, no thread could ever access this resource again.
If another thread ever attempted to lock this resource, deadlock
would result. Such deadlocks typically manifest themselves as
"frozen" processes. For more information, see
Why are Thread.stop, Thread.suspend and Thread.resume Deprecated?.
This method used to return the value of a proprietary
property in the master file of the "SUN" Cryptographic Service
Provider in order to determine how to parse algorithm-specific
parameters. Use the new provider-based and algorithm-independent
AlgorithmParameters and KeyFactory engine
classes (introduced in the J2SE version 1.2 platform) instead.
This method does not properly convert characters into
bytes. As of JDK 1.1, the preferred way to do this is via the
String.getBytes() method, which uses the platform's default charset.
This change is effective since API version 2. The time when a NotificationRequest is
initialized is not accessible to the public. To obtain the time when a notification is delivered,
call the NotificationRequest.getDeliveryTime() method.
This change is effective since API version 5. Replaced by getItemPosByVisibleIndex(int)
while passing the value equaling getVisibleIndexCount() minus 1.
As of JDK 1.1, the preferred way to translate a byte
stream in the local encoding into a character stream in Unicode is via
the InputStreamReader and BufferedReader
classes.
As of JDK 1.1, the preferred way to translate a
Unicode character stream into a byte stream in the local encoding is via
the OutputStreamWriter, BufferedWriter, and
PrintWriter classes.
This change is effective since API version 8.
This method is deprecated together with Paint#setPosition.
You need to manually record the position set by Canvas#drawText.
This change is effective since API version 2. Use NotificationRequest.isShowDeliveryTime() instead. A
notification displays the time when it is delivered, rather than the time when it is created.
This method has been deprecated to maintain API consistency.
All newInstance methods have been replaced with corresponding
newFactory methods. The replacement XMLInputFactory.newFactory(java.lang.String,java.lang.ClassLoader) method
defines no changes in behavior.
This method does not properly convert bytes to characters.
As of JDK 1.1, the preferred way to read lines of text is via the
BufferedReader.readLine() method. Programs that use the
DataInputStream class to read lines can be converted to use
the BufferedReader class by replacing code of the form:
DataInputStream d = new DataInputStream(in);
with:
BufferedReader d
= new BufferedReader(new InputStreamReader(in));
The dependency on PropertyChangeListener creates
a significant impediment to future modularization of the
Java platform. This method will be removed in a future
release.
The dependency on PropertyChangeListener creates
a significant impediment to future modularization of the
Java platform. This method will be removed in a future
release.
The dependency on PropertyChangeListener creates a
significant impediment to future modularization of the Java
platform. This method will be removed in a future release.
The global LogManager can detect changes to the
logging configuration by overridding the readConfiguration method.
This method is used solely in conjunction with
Thread.suspend and ThreadGroup.suspend,
both of which have been deprecated, as they are inherently
deadlock-prone. See Thread#suspend for details.
This method is inherently unsafe. It may result in
finalizers being called on live objects while other threads are
concurrently manipulating those objects, resulting in erratic
behavior or deadlock.
This method is inherently unsafe. It may result in
finalizers being called on live objects while other threads are
concurrently manipulating those objects, resulting in erratic
behavior or deadlock.
This method does not throw an IOException if an I/O error
occurs while saving the property list. The preferred way to save a
properties list is via the store(OutputStream out,
String comments) method or the
storeToXML(OutputStream os, String comment) method.
Use the following code or its equivalent instead:
......
int ttl = mcastSocket.getTimeToLive();
mcastSocket.setTimeToLive(newttl);
mcastSocket.send(p);
mcastSocket.setTimeToLive(ttl);
......
The instance specific setRequestProperty method
should be used after an appropriate instance of URLConnection
is obtained. Invoking this method will have no effect.
This change is effective since API version 8. This method is deprecated because the duration
parameter is an integer and does not need to be represented by a floating point number.
Replaced by Transition.setDuration(long).
This change is effective since API version 8. This method is deprecated because the duration
parameter is an integer and does not need to be represented by a floating point number.
Replaced by TransitionAlpha.setDuration(long).
This change is effective since API version 8. This method is deprecated because the duration
parameter is an integer and does not need to be represented by a floating point number.
Replaced by TransitionMove.setDuration(long).
This change is effective since API version 8. This method is deprecated because the duration
parameter is an integer and does not need to be represented by a floating point number.
Replaced by TransitionRotation.setDuration(long).
This change is effective since API version 8. This method is deprecated because the duration
parameter is an integer and does not need to be represented by a floating point number.
Replaced by TransitionZoomingMove.setDuration(long).
This change is effective since API version 8.
The position set by this method will be overwritten by that set by Canvas#drawText.
Therefore, this API is deprecated. Use Canvas#drawText instead.
This change is effective since API version 2. A notification displays the time when it is delivered,
rather than the time when it is created. Use NotificationRequest.setShowDeliveryTime(boolean) instead.
This method is inherently unsafe. Stopping a thread with
Thread.stop causes it to unlock all of the monitors that it
has locked (as a natural consequence of the unchecked
ThreadDeath exception propagating up the stack). If
any of the objects previously protected by these monitors were in
an inconsistent state, the damaged objects become visible to
other threads, potentially resulting in arbitrary behavior. Many
uses of stop should be replaced by code that simply
modifies some variable to indicate that the target thread should
stop running. The target thread should check this variable
regularly, and return from its run method in an orderly fashion
if the variable indicates that it is to stop running. If the
target thread waits for long periods (on a condition variable,
for example), the interrupt method should be used to
interrupt the wait.
For more information, see
Why are Thread.stop, Thread.suspend and Thread.resume Deprecated?.
This method was originally designed to force a thread to stop
and throw a given Throwable as an exception. It was
inherently unsafe (see Thread.stop() for details), and furthermore
could be used to generate exceptions that the target thread was
not prepared to handle.
For more information, see
Why are Thread.stop, Thread.suspend and Thread.resume Deprecated?.
This method has been deprecated, as it is
inherently deadlock-prone. If the target thread holds a lock on the
monitor protecting a critical system resource when it is suspended, no
thread can access this resource until the target thread is resumed. If
the thread that would resume the target thread attempts to lock this
monitor prior to calling resume, deadlock results. Such
deadlocks typically manifest themselves as "frozen" processes.
For more information, see
Why
are Thread.stop, Thread.suspend and Thread.resume Deprecated?.
This method does not properly convert bytes into characters.
As of JDK 1.1, the preferred way to do this is via the
toString(String enc) method, which takes an encoding-name
argument, or the toString() method, which uses the
platform's default character encoding.
This method does not automatically escape characters that
are illegal in URLs. It is recommended that new code convert an
abstract pathname into a URL by first converting it into a URI, via the
toURI method, and then converting the URI into a URL
via the URI.toURL method.
As of JDK version 1.1,
replaced by Calendar.set(year + 1900, month, date,
hrs, min, sec) or GregorianCalendar(year + 1900,
month, date, hrs, min, sec), using a UTC
TimeZone, followed by Calendar.getTime().getTime().
This method does not write the values contained by this
PutField object in a proper format, and may
result in corruption of the serialization stream. The
correct way to write PutField data is by
calling the ObjectOutputStream.writeFields()
method.
As of JDK version 1.1,
replaced by Calendar.set(year + 1900, month, date,
hrs, min, sec) or GregorianCalendar(year + 1900,
month, date, hrs, min, sec).
This method does not properly convert bytes into
characters. As of JDK 1.1, the preferred way to do this is via the
String constructors that take a Charset, charset name, or that use the platform's
default charset.
This method does not properly convert bytes into characters.
As of JDK 1.1, the preferred way to do this is via the
String constructors that take a Charset, charset name, or that use the platform's
default charset.