# All Classes

- All Classes Interface Summary Class Summary Enum Summary Exception Summary Error Summary Annotation Types Summary
  Class | Description
  --- | ---
  AbstractCollection<E> |
  AbstractList<E> |
  AbstractMap<K,​V> | This class provides a skeletal implementation of the `Map` interface, to minimize the effort required to implement this interface.
  AbstractMap.SimpleEntry<K,​V> | An Entry maintaining a key and a value.
  AbstractMap.SimpleImmutableEntry<K,​V> | An Entry maintaining an immutable key and value.
  AbstractMethodError | Thrown when an application tries to call an abstract method.
  AbstractSet<E> |
  Activity | Represents an activity.
  AdjacentSiblingCombinator | An adjacent sibling combinator selects by checking the widget immediate sibling.
  Alignment | Provides constants and utility methods in order to position a graphical object considering its alignment within an area or with an anchor point.
  AndCombinator | An 'and' combinator selects the widgets selected by both selectors.
  Animation | An animation is responsible for animating a element (usually a visual one).
  Animator | An animator executes animations as fast as possible.
  Animator.AnimatorListener | Listener for animator events.
  AnnotatedElement | This interface is only defined for hierarchy compatibility.
  Annotation | The common interface extended by all annotation types.
  Appendable | An object to which `char` sequences and values can be appended.
  ArithmeticException | Thrown when an exceptional arithmetic condition has occurred.
  ArrayIndexOutOfBoundsException | Thrown to indicate that an array has been accessed with an illegal index.
  ArrayList<E> |
  ArrayStoreException | Thrown to indicate that an attempt has been made to store the wrong type of object into an array of objects.
  AssertionError | Thrown to indicate that an assertion has failed.
  AutoCloseable | A resource that must be closed when it is no longer needed.
  Background | Represents the background of the widgets.
  BasicPermission |
  BlendMode | Enum for the ways a path is blend.
  BluetoothAdapter | The `BluetoothAdapter` class represents a Bluetooth adapter.
  BluetoothAddress | The `BluetoothAddress` class represents the address of a Bluetooth device.
  BluetoothAttribute | The `BluetoothAttribute` class represents a remote or a local GATT attribute.
  BluetoothCharacteristic | The `BluetoothCharacteristic` class represents a remote or a local GATT characteristic.
  BluetoothConnection | The `BluetoothConnection` class represents a connection with a remote Bluetooth device.
  BluetoothDataTypes | The `BluetoothDataTypes` class enumerates the values for advertising data types.
  BluetoothDescriptor | The `BluetoothDescriptor` class represents a remote or a local GATT descriptor.
  BluetoothPermissions | The `BluetoothPermissions` class enumerates the values for attribute permissions.
  BluetoothProperties | The `BluetoothProperties` class enumerates the values for characteristic properties.
  BluetoothScanFilter | The `BluetoothScanFilter` class represents a scan filter which may be used in order to filter scan results during a scan.
  BluetoothService | The `BluetoothService` class represents a remote or a local GATT service.
  BluetoothServiceDefinition | The `BluetoothServiceDefinition` class represents the structure of a GATT service.
  BluetoothStatus | The `BluetoothStatus` class enumerates the values for error codes of ATT requests.
  BluetoothUuid | The `BluetoothUuid` class represents the UUID of a service or attribute.
  Boolean | The Boolean class wraps a value of the primitive type `boolean` in an object.
  BorderHelper | Provides utility methods to draw borders.
  BufferedImage | A `BufferedImage` represents a mutable image backed by a pixel buffer.
  BufferedVectorImage | A buffered vector image is a vector image that can be built dynamically.
  Buttons | A Buttons event generator is usually associated to a group of physical buttons and allow to generate events relating to them.
  Byte | The `Byte` class wraps a value of primitive type `byte` in an object.
  ByteArray | This class provides some utilities to manage I/O on a byte array.
  ByteArrayInputStream | A `ByteArrayInputStream` contains an internal buffer that contains bytes that may be read from the stream.
  ByteArrayOutputStream | This class implements an output stream in which the data is written into a byte array.
  CachedStylesheet | Wraps a stylesheet and provides a cache to avoid having several instances of the same style.
  Calendar | The `Calendar` class is an abstract class that provides methods for converting between a specific instant in time and a set of `calendar fields` such as `YEAR` , `MONTH` , `DAY_OF_MONTH`, `HOUR`, and so on, and for manipulating the calendar fields, such as getting the date of the next week.
  CascadingStylesheet | Cascading stylesheet implementation strongly inspired by CSS.
  Character | The `Character` class wraps a value of the primitive type `char` in an object.
  CharSequence |
  ChildCombinator | A child combinator selects by checking the widget direct hierarchy.
  Class<T> | Instances of the class `Class` represent classes and interfaces in a running Java application.
  ClassCastException | Thrown to indicate that the code has attempted to cast an object to a subclass of which it is not an instance.
  ClassCircularityError | Thrown when the Java Virtual Machine detects a circularity in the superclass hierarchy of a class being loaded.
  ClassFormatError | Thrown when the Java Virtual Machine attempts to read a class file and determines that the file is malformed or otherwise cannot be interpreted as a class file.
  ClassNotFoundException | Thrown when an application tries to load in a class through its string name using: The `forName` method in class `Class`.
  ClassSelector | A class selector selects from a class.
  Cloneable | A class implements the `Cloneable` interface to indicate to the `Object.clone()` method that it is legal for that method to make a field-for-field copy of instances of that class.
  CloneNotSupportedException |
  Closeable | A `Closeable` is a source or destination of data that can be closed.
  Collection<E> |
  Colors | The interface `Colors` provides useful constants to handle RGB colors format.
  Combinator | A combinator is a selector that aggregates two selectors.
  Command |
  Comparable<T> |
  Comparator<T> |
  ComplicationDataSource | Represents a source of data that can be displayed on a watchface complication.
  ComponentService | This service allows Features to register activities, watchfaces and complication data sources.
  ConcurrentModificationException | This exception may be thrown by methods that have detected concurrent modification of an object when such modification is not permissible.
  ConnectionListener | The `ConnectionListener` interface provides callbacks related to advertising, scanning and connections.
  Constants | This class provides access to compile-time constants.
  Container | A container is a widget that can contain other `Widget` instances, following the composite pattern.
  DataInput | The `DataInput` interface provides for reading bytes from a binary stream and reconstructing from them data in any of the Java primitive types.
  DataInputStream | A data input stream lets an application read primitive Java data types from an underlying input stream in a machine-independent way.
  DataOutput | The `DataOutput` interface provides for converting data from any of the Java primitive types to a series of bytes and writing these bytes to a binary stream.
  DataOutputStream | A data output stream lets an application write primitive Java data types to an output stream in a portable way.
  Date | The class `Date` represents a specific instant in time, with millisecond precision.
  DefaultConnectionListener | The `DefaultConnectionListener` class provides a default implementation of the `ConnectionListener` interface.
  DefaultLocalServiceListener | The `DefaultLocalServiceListener` class provides a default implementation of the `LocalServiceListener` interface.
  DefaultRemoteServiceListener | The `DefaultRemoteServiceListener` class provides a default implementation of the `RemoteServiceListener` interface.
  DefaultRenderPolicy | This render policy renders the requested widget or its parent if transparent.
  DefaultStyle | Defines the value of each field of the default style.
  Deprecated | A program element annotated @Deprecated is one that programmers are discouraged from using, typically because it is dangerous, or because a better alternative exists.
  DescendantCombinator | A descendant combinator selects by checking the widget hierarchy.
  Desktop | A desktop is the top-level object that can be displayed on a `Display`.
  DesktopEventGenerator | This event generator is used by the `event dispatcher` of the desktop in order to send additional events to the widgets.
  DeviceService | This service allows Features to get device information.
  Dictionary<K,​V> | The `Dictionary` class is the abstract parent of any class, such as `Hashtable`, which maps keys to values.
  Dimension | Represents a dimension constraint for a widget.
  DimensionHelper | Helps the dimensions to lay out a widget with a specific size.
  DisabledSelector | A disabled selector selects by checking if the widget is disabled.
  Display | The `Display` object represents the pixelated screen in the platform. The display of the system may be retrieved by calling `Display.getDisplay()`. The display is able to render a `Displayable` on its implementation screen.
  Displayable | `Displayable` is an abstract class which defines the very objects that can be shown on the `Display`. A `Displayable` may be shown or hidden, but at most one `Displayable` is shown on the `Display`. Subclasses should define the `Displayable` contents and their possible interactions with the user. By default, a new `Displayable` object is not visible on the display.
  DisplayPermission | This class is for display permissions.
  Documented | Indicates that annotations with a type are to be documented by javadoc and similar tools by default.
  Double | The `Double` class wraps a value of the primitive type `double` in an object.
  EditableStyle | An editable style is a simple implementation of a style.
  ElementType | A program element type.
  EmptyStackException | Thrown by methods in the `Stack` class to indicate that the stack is empty.
  EnabledSelector | An enabled selector selects by checking if the widget is enabled.
  EnqueuedWeakReference<T> | EnqueuedWeakReference are objects that are queued in an ReferenceQueue by the system when the object they point at (see `Reference.get()`) is set to `null` by the system.
  Enum<E extends Enum<E>> | This is the common base class of all Java language enumeration types.
  Enumeration<E> | An object that implements the Enumeration interface generates a series of elements, one at a time.
  EOFException | Signals that an end of file or end of stream has been reached unexpectedly during input.
  Error | An `Error` is a subclass of `Throwable` that indicates serious problems that a reasonable application should not try to catch.
  EvenChildSelector | An even child selector selects by checking if a widget is at an even position in its parent (1, 3, 5,…).
  Event | MicroUI features int-based events, allowing for a rich event mechanism compatible with scare resources.
  EventDispatcher | Dispatches the events received on a desktop to its children.
  EventGenerator |
  EventHandler | An event handler is intended to receive and handle events.
  EventListener | A tagging interface that all event listener interfaces must extend.
  EventObject | The root class from which all event state objects shall be derived.
  EventPermission | This class is for event generator permissions.
  Exception | The class `Exception` and its subclasses are a form of `Throwable` that indicates conditions that a reasonable application might want to catch.
  ExceptionInInitializerError | Signals that an unexpected exception has occurred in a static initializer.
  ExternalResourceService | This service allows Features to create and delete external resources.
  ExternalResourceService.ImageFormat | Enumerates supported image formats.
  ExternalResourceService.Writer | Represents a writer to an external resource.
  FeatureEntryPoint | Each Feature shall define one entry point that implements this interface.
  FilterInputStream | A `FilterInputStream` contains some other input stream, which it uses as its basic source of data, possibly transforming the data along the way or providing additional functionality.
  FilterOutputStream | This class is the superclass of all classes that filter output streams.
  FirstChildSelector | A first child selector selects by checking if a widget is the first child of its parent.
  FixedDimension | Dimension with fixed width and/or height.
  FlexibleOutline | Flexible outline that has a different thickness for each edge.
  FlexibleRectangularBorder | Represents and draw a rectangular colored border with one color.
  FlexibleRectangularMulticoloredBorder | Represents and draw a rectangular border with different thicknesses and colors.
  Float | The `Float` class wraps a value of primitive type `float` in an object.
  Flushable | A `Flushable` is a destination of data that can be flushed.
  Font | A `Font` defines how characters are drawn on a `GraphicsContext`.
  FontIdentifiers | Available list of `Font` built-in identifiers.
  FontPermission | This class is for font permissions.
  FontService | This service allows Features to get fonts.
  Format | Contains all the available buffer formats.
  GeneralSiblingCombinator | A general sibling combinator selects by checking the widget sibling.
  GenericDeclaration | This interface is only defined for hierarchy compatibility.
  GenericEventGenerator | Generic event generator.
  GraphicsContext | A `GraphicsContext` provides access to a modifiable pixel buffer.
  Guard | This interface is only defined for hierarchy compatibility.
  HashMap<K,​V> | Hash table based implementation of the `Map` interface.
  Hashtable<K,​V> | This class implements a hash table, which maps keys to values.
  HealthService | This service allows Features to get health information.
  IllegalAccessError | Thrown if an application attempts to access or modify a field, or to call a method that it does not have access to.
  IllegalAccessException | An IllegalAccessException is thrown when an application tries to reflectively create an instance (other than an array), set or get a field, or invoke a method, but the currently executing method does not have access to the definition of the specified class, field, method or constructor.
  IllegalArgumentException | Thrown to indicate that a method has been passed an illegal or inappropriate argument.
  IllegalMonitorStateException | Thrown to indicate that a thread has attempted to wait on an object's monitor or to notify other threads waiting on an object's monitor without owning the specified monitor.
  IllegalStateException | Signals that a method has been invoked at an illegal or inappropriate time.
  IllegalStateException | Signals that a method has been invoked at an illegal or inappropriate time.
  IllegalThreadStateException | Thrown to indicate that a thread is not in an appropriate state for the requested operation.
  Image | An `Image` represents a graphical two-dimensional object.
  ImageBackground | Draws an image on the background.
  ImagePermission | This class is for image permissions.
  Immutables | This class gives access to the global immutable objects pool.
  ImmutablesError | Indicates an error accessing immutables data.
  IncompatibleClassChangeError | Thrown when an incompatible class change has occurred to some class definition.
  IndexOutOfBoundsException | Thrown to indicate that an index of some sort (such as to an array, to a string, or to a vector) is out of range.
  Inherited | Indicates that an annotation type is automatically inherited.
  InputStream | This abstract class is the superclass of all classes representing an input stream of bytes.
  InputStreamReader | An InputStreamReader is a bridge from byte streams to character streams: It reads bytes and decodes them into characters using a specified `charset`.
  InstantiationError | Thrown when an application tries to use the Java `new` construct to instantiate an abstract class or an interface.
  InstantiationException | Thrown when an application tries to create an instance of a class using the `newInstance` method in class `Class`, but the specified class object cannot be instantiated.
  Integer | The `Integer` class wraps a value of the primitive type `int` in an object.
  InternalError | Thrown to indicate some unexpected internal error has occurred in the Java Virtual Machine.
  InterruptedException | Thrown when a thread is waiting, sleeping, or otherwise occupied, and the thread is interrupted, either before or during the activity.
  InterruptedIOException | Signals that an I/O operation has been interrupted.
  IOException | Signals that an I/O exception of some sort has occurred.
  Iterable<T> | Implementing this interface allows an object to be the target of the "foreach" statement.
  Iterator<E> | An iterator over a collection.
  KernelServiceProvider | Provides the instance of every Kernel service to the Features.
  LastChildSelector | A last child selector selects by checking if a widget is the last child of its parent.
  Leds | This class is used to manage all LEDs available on the platform.
  LinearGradient | Represents a linear gradient on a vector.
  LinkageError | Subclasses of `LinkageError` indicate that a class has some dependency on another class; however, the latter class has incompatibly changed after the compilation of the former class.
  List<E> | An ordered collection (also known as a sequence).
  ListIterator<E> | An iterator for lists that allows the programmer to traverse the list in either direction, modify the list during iteration, and obtain the iterator's current position in the list.
  LocalServiceListener | The `LocalServiceListener` interface provides callbacks related to local services.
  Long | The `Long` class wraps a value of the primitive type `long` in an object.
  Map<K,​V> | An object that maps keys to values.
  Map.Entry<K,​V> | A map entry (key-value pair).
  Math |
  Matrix | Represents a 3x3 matrix for transforming coordinates.
  MicroUI | The `MicroUI` class offers basic services in the MicroUI implementation. MicroUI is started explicitly by calling `MicroUI.start()`.
  MicroUIException | Thrown to indicate that a method has caused an internal MicroUI error.
  MicroUIPermission | This class is for MicroUI permissions.
  Navigator | Navigates across the UI.
  Navigator.Gesture | Enumerates gestures.
  NegativeArraySizeException | Thrown if an application tries to create an array with negative size.
  NoBackground | A transparent background.
  NoClassDefFoundError | Thrown if the Java Virtual Machine or a `ClassLoader` instance tries to load in the definition of a class (as part of a normal method call or as part of creating a new instance using the `new` expression) and no definition of the class could be found.
  NoDimension | Dimension without constraint.
  NonNull | Indicates that a field, local variable, method return value or parameter can never be `null`.
  NonNullByDefault | Indicates that all fields, method return values or parameters can never be `null` in the annotated package or type.
  NoOutline | An outline that is empty.
  NoSuchElementException | Thrown by the `nextElement` method of an `Enumeration` to indicate that there are no more elements in the enumeration.
  NoSuchFieldError | Thrown if an application tries to access or modify a specified field of an object, and that object no longer has that field.
  NoSuchFieldException | Signals that the class doesn't have a field of a specified name.
  NoSuchMethodError | Thrown if an application tries to call a specified method of a class (either static or instance), and that class no longer has a definition of that method.
  NoSuchMethodException | Thrown when a particular method cannot be found.
  NotSelector | A not selector selects every widget that is not selected by its wrapped selector.
  NthChildSelector | A nth child selector selects by checking if a widget is the nth child of its parent.
  Nullable | Indicates that a field, local variable, method return value or parameter can be `null`.
  NullPointerException | Thrown when an application attempts to use `null` in a case where an object is required.
  Number | The abstract class `Number` is the superclass of classes `BigDecimal`, `BigInteger`, `Byte`, `Double`, `Float`, `Integer`, `Long`, and `Short`.
  NumberFormatException | Thrown to indicate that the application has attempted to convert a string to one of the numeric types, but that the string does not have the appropriate format.
  Object | Class `Object` is the root of the class hierarchy.
  Observable | This class represents an observable object, or "data" in the model-view paradigm.
  Observer | A class can implement the `Observer` interface when it wants to be informed of changes in observable objects.
  OddChildSelector | An odd child selector selects by checking if a widget is at an odd position in its parent (0, 2, 4,…).
  OptimalDimension | Dimension which fits the optimal size of the widget.
  Outline | Represents an outline that wraps a rectangle.
  Outlineable | Represents a two-dimensional object to which outlines can be added or removed.
  OutlineHelper | Provides utility methods to apply outlines and backgrounds.
  OutOfMemoryError | Thrown when the Java Virtual Machine cannot allocate an object because it is out of memory, and no more memory could be made available by the garbage collector.
  OutputStream | This abstract class is the superclass of all classes representing an output stream of bytes.
  OutputStreamWriter | An OutputStreamWriter is a bridge from character streams to byte streams: Characters written to it are encoded into bytes using a specified `charset`.
  OverlapRenderPolicy | This render policy keeps the initial order of the widgets.
  Override | Indicates that a method declaration is intended to override a method declaration in a supertype.
  Package | `Package` represent a Java package.
  Painter | The `Painter` class provides static methods to draw basic shapes such as lines, rectangles, circles, characters and images.
  Path | Represents a geometric paths consisting of straight line segments, quadratic curves, and cubic curves.
  Permission |
  Pointer | A pointer event generator represents a pointing device that is usually associated to a group of physical buttons.
  PointerEventDispatcher | Dispatches the pointer events received on a desktop to its children.
  PrintStream | A `PrintStream` adds functionality to another output stream, namely the ability to print representations of various data values conveniently.
  PropertyPermission |
  Proxy<T> | The superclass of proxy classes.
  Random | An instance of this class is used to generate a stream of pseudorandom numbers.
  RandomAccess | Marker interface used by `List` implementations to indicate that they support fast (generally constant time) random access.
  Readable | This interface is only defined for hierarchy compatibility.
  Reader | Abstract class for reading character streams.
  Rectangle | Represents a rectangle with a position and a size.
  RectangularBackground | Draws a plain color on the background with a rectangular border.
  RectangularBorder | Represents and draw a rectangular colored border.
  Reference<T> | Abstract base class for reference objects.
  ReferenceQueue<T> | ReferenceQueue represents a queue of EnqueuedWeakReference.
  ReferenceQueue<T> | Reference queues, to which registered reference objects are appended by the garbage collector after the appropriate reachability changes are detected.
  ReflectiveOperationException | Common superclass of exceptions thrown by reflective operations in core reflection.
  RelativeDimension | Dimension with constraint relative to the parent.
  RemoteServiceListener | The `RemoteServiceListener` interface provides callbacks related to remote services.
  Renderable | Represents a UI that can be rendered on a graphics context and that can be shown on the display.
  RenderableString | Represents graphical information related to the drawing of a string with a font.
  RenderPolicy | A render policy is responsible of rendering the widgets of a desktop on the display.
  RenderPolicy.RenderListener | Listener for render events (when it is requested and when it is actually executed).
  ResourceArray | A resource array is an element of `ResourceBuffer`.
  ResourceBuffer | A resource buffer contains a set of data which is compacted to obtain a minimal footprint.
  ResourceImage | A `ResourceImage` represents an image which may require dynamic allocation in order to be created.
  ResourceImage.OutputFormat | Enumerates the different formats in which a resource image can store pixel colors.
  ResourceService | This service allows Features to load resources.
  ResourceVectorImage | Represents a vector image which requires dynamic allocation in order to be created.
  Retention | Indicates how long annotations with the annotated type are to be retained.
  RetentionPolicy | Annotation retention policy.
  RootSelector | A root selector selects by checking if a widget is the root widget of its hierarchy (i.e.
  RoundedBackground | Draws a plain color on the background with a round corner.
  RoundedBorder | Draws a uniform border with round corners.
  Runnable | The `Runnable` interface should be implemented by any class whose instances are intended to be executed by a thread.
  Runtime | Every Java application has a single instance of class `Runtime` that allows the application to interface with the environment in which the application is running.
  RuntimeException | `RuntimeException` is the superclass of those exceptions that can be thrown during the normal operation of the Java Virtual Machine.
  RuntimePermission |
  SafeVarargs | A programmer assertion that the body of the annotated method or constructor does not perform potentially unsafe operations on its varargs parameter.
  SecurityException | Thrown by the security manager to indicate a security violation.
  SecurityManager | The security manager is a class that allows applications to implement a security policy.
  Selector | Represents a selector.
  SelectorHelper | Provides utility methods related to selectors.
  Serializable | This interface is only defined for hierarchy compatibility.
  Set<E> |
  ShapePainter | The `ShapePainter` class offers a set of static methods to render thick shapes (with or without anti-aliasing) and polygons.
  ShapePainter.Cap | Defines the cap representation when drawing a line or a circle arc.
  Short | The `Short` class wraps a value of primitive type `short` in an object.
  Size | Represents a size (width and height).
  Stack<E> | The `Stack` class represents a last-in-first-out (LIFO) stack of objects.
  StackOverflowError | Thrown when a stack overflow occurs because an application recurses too deeply.
  StackTraceElement | An element in a stack trace.
  States | A states event generator is usually associated to a group of physical devices holding a position (switch, rotary wheel encoder, ...) and allows to generate events relating to them.
  StateSelector | A state selector selects from a state.
  StrictTypeSelector | A type selector selects by checking the widget type (Java class).
  String |
  StringBuffer | A thread-safe, mutable sequence of characters.
  StringBuilder | A mutable sequence of characters.
  StringIndexOutOfBoundsException | Thrown by `String` methods to indicate that an index is either negative or greater than the size of the string.
  Style | A style describes how widgets must be rendered on screen.
  Stylesheet | Represents a stylesheet.
  SuppressWarnings | Indicates that the named compiler warnings should be suppressed in the annotated element (and in all program elements contained in the annotated element).
  System | The `System` class contains several useful class fields and methods.
  Target | Indicates the kinds of program element to which an annotation type is applicable.
  Thread | A thread is a thread of execution in a program.
  Thread.State | A thread state.
  Thread.UncaughtExceptionHandler | Interface for handlers invoked when a `Thread` abruptly terminates due to an uncaught exception.
  Throwable | The `Throwable` class is the superclass of all errors and exceptions in the Java language.
  TiledImageBackground | Draws a repeated image on the background.
  TimeConfigurationListener | The listener interface for receiving notifications when the time configuration of the device has changed (date, time, time zone).
  Timer | A facility for threads to schedule tasks for future execution in a background thread.
  Timer | Deprecated. Please consider `ej.bon.Timer` from BON specification instead.
  TimerTask | A task that can be scheduled for one-time or repeated execution by a Timer.
  TimerTask | Deprecated. Please consider `ej.bon.TimerTask` from BON specification instead.
  TimeService | This service allows Features to get time information.
  TimeZone | `TimeZone` represents a time zone offset, and also figures out daylight savings.
  Tracer | A `Tracer` object is used to trace events for debug or monitoring.
  TransformedImagePainter | The `TransformedImagePainter` class provides static methods to draw an image with a transformation defined by a `Matrix`.
  TransformPainter | The `TransformPainter` class offers a set of static methods to render elements (image, renderable character) with a transformation.
  TransformPainter.Flip | Specify the flip to apply when drawing an image.
  Type |
  TypeSelector | A type or subtype selector selects by checking the widget type hierarchy (Java class).
  UniformOutline | Outline that have the same thickness for all edges.
  UniversalSelector | An universal selector selects all widgets.
  UnknownError | Thrown when an unknown but serious exception has occurred in the Java Virtual Machine.
  UnsatisfiedLinkError | Thrown if the Java Virtual Machine cannot find an appropriate native-language definition of a method declared `native`.
  UnsupportedClassVersionError | Thrown when the Java Virtual Machine attempts to read a class file and determines that the major and minor version numbers in the file are not supported.
  UnsupportedEncodingException | The Character Encoding is not supported.
  UnsupportedOperationException | Thrown to indicate that the requested operation is not supported.
  UTFDataFormatException | Signals that a malformed string in modified UTF-8 format has been read in a data input stream or by any class that implements the data input interface.
  Util | This class offers basic services for B-ON implementation.
  Vector<E> | The `Vector` class implements a growable array of objects.
  VectorFont | Represents a vector font.
  VectorGraphicsException | Thrown to indicate that a method has caused an internal VectorGraphics error.
  VectorGraphicsPainter | Provides static methods to draw paths, texts and images.
  VectorGraphicsPainter.Direction | Enum for specifying the direction in which a rotation can occur.
  VectorGraphicsPainter.FillType | Enum for the ways a path may be filled.
  VectorImage | Represents a vector image.
  VectorImageBuilder | Deprecated. Use a `BufferedVectorImage` instead.
  VerifyError | Thrown when the "verifier" detects that a class file, though well formed, contains some sort of internal inconsistency or security problem.
  VirtualMachineError | Thrown to indicate that the Java Virtual Machine is broken or has run out of resources necessary for it to continue operating.
  VoidStylesheet | Stylesheet that always returns the default style.
  Watchface | Represents a watchface.
  WeakHashMap<K,​V> | Hash table based implementation of the `Map` interface, with weak keys.
  WeakHashtable | A `Hashtable` implementation with weak keys.
  WeakReference<T> | Weak reference objects, which do not prevent their referents from being made finalizable, finalized, and then reclaimed.
  Widget | Widget is the superclass of all the user interface objects.
  Writer | Abstract class for writing to character streams.
  XMath | This class provides advanced mathematical functions.