<p> A callback abstraction that handles completed/failed events of asynchronous operations. </p> <p> <p> Semantically this is equivalent to an optimise Promise<Void>, but callback is a more meaningful name than EmptyPromise </p>
An object to which {@code char} sequences and values can be appended. The {@code Appendable} interface must be implemented by any class whose instances are intended to receive formatted output from a {@link java.util.Formatter}.
An object that may hold resources (such as file or socket handles) until it is closed. The {@link #close()} method of an {@code AutoCloseable} object is called automatically when exiting a {@code try}-with-resources block for which the object has been declared in the resource specification header. This construction ensures prompt release, avoiding resource exhaustion exceptions and errors that may otherwise occur.
A task that returns a result and may throw an exception. Implementors define a single method with no arguments called {@code call}.
<p> A callback abstraction that handles completed/failed events of asynchronous operations. </p> <p> <p> Semantically this is equivalent to an optimise Promise<Void>, but callback is a more meaningful name than EmptyPromise </p>
A class implements the <code>Cloneable</code> interface to indicate to the {@link java.lang.Object#clone()} method that it is legal for that method to make a field-for-field copy of instances of that class. <p> Invoking Object's clone method on an instance that does not implement the <code>Cloneable</code> interface results in the exception <code>CloneNotSupportedException</code> being thrown. <p> By convention, classes that implement this interface should override <tt>Object.clone</tt> (which is protected) with a method. See {@link java.lang.Object#clone()} for details on overriding this method. <p> Note that this interface does <i>not</i> contain the <tt>clone</tt> method. Therefore, it is not possible to clone an object merely by virtue of the fact that it implements this interface. Even if the clone method is invoked reflectively, there is no guarantee that it will succeed.
A tagging interface that all event listener interfaces must extend.
An object that executes submitted {@link Runnable} tasks. This interface provides a way of decoupling task submission from the mechanics of how each task will be run, including details of thread use, scheduling, etc. An {@code Executor} is normally used instead of explicitly creating threads. For example, rather than invoking {@code new Thread(new RunnableTask()).start()} for each of a set of tasks, you might use:
Implementing this interface allows an object to be the target of the "for-each loop" statement. @param (T) the type of elements returned by the iterator
The <code>Runnable</code> interface should be implemented by any class whose instances are intended to be executed by a thread. The class must define a method of no arguments called <code>run</code>. <p> This interface is designed to provide a common protocol for objects that wish to execute code while they are active. For example, <code>Runnable</code> is implemented by class <code>Thread</code>. Being active simply means that a thread has been started and has not yet been stopped. <p> In addition, <code>Runnable</code> provides the means for a class to be active while not subclassing <code>Thread</code>. A class that implements <code>Runnable</code> can run without subclassing <code>Thread</code> by instantiating a <code>Thread</code> instance and passing itself in as the target. In most cases, the <code>Runnable</code> interface should be used if you are only planning to override the <code>run()</code> method and no other <code>Thread</code> methods. This is important because classes should not be subclassed unless the programmer intends on modifying or enhancing the fundamental behavior of the class.