Java Programing laungage

Java Platform, Standard Edition (J2SE) or Java SE is widely used platform for programming in the Java language. It consists Java Virtual Machine (JVM), which is used to debug and run a java programs, with with a set of Packages (or binary libraries), needed to allow the use of Graphical User Interface (GUI), networking (socket or RMI), file systems, database communication, and so on.

Such operation can be divided into different packages, one of them is java.lang.*; package, provided fundamental classes and interfaces closely bound to the language and runtime system. The most important class are Object, which is the root of the class hierarchy, and Class, instances of which represent classes at run time.

This package contains threading, math functions, security functions, array function, string function, runtime binding, basic error and exceptions as well as some information on the underlying native system.

This package also represent wrapper classes like Boolean, Character, Double, Float, Integer, and Long. It also capable to manage the dynamic loading of classes like ClassLoader, Process, Runtime, SecurityManager, and System (in, out, err), created for external processes or host environment inquiries.

java.lang package

Annotation	Description
Deprecated	Indicates compilers warning, when a deprecated program element is used or overridden in non-deprecated code.
Override	Indicates that a method declaration is intended to override a method which already declaration in a superclass.
SuppressWarnings	Indicates that the named compiler warnings should be suppressed in the annotated element.

Interface	Description
Appendable	An object to which char sequences and values can be appended. The Appendable interface must be implemented by any class whose instances are intended to receive formatted output from a Formatter.
CharSequence	A CharSequence is a readable sequence of char values. This interface provides uniform, read-only access to many different kinds of char sequences. A char value represents a character in the Basic Multilingual Plane (BMP) or a surrogate.
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.
Comparable<T>	This interface imposes a total ordering on the objects of each class that implements it. This ordering is referred to as the class's natural ordering, and the class's compareTo method is referred to as its natural comparison method.
Iterable<T>	Implementing this interface allows an object to be the target of the "foreach" statement.
Readable	A Readable is a source of characters. Characters from a Readable are made available to callers of the read method via a CharBuffer.
Runnable	The Runnable 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 run.

Class	Description
Boolean	The Boolean class wraps a value of the primitive type boolean in an object. An object of type Boolean contains a single field whose type is boolean. This class provides many methods for converting a boolean to a String and a String to a boolean, as well as other constants and methods useful when dealing with a boolean.
Byte	The Byte class wraps a value of primitive type byte in an object. An object of type Byte contains a single field whose type is byte . This class provides several methods for converting a byte to a String and a String to a byte , as well as other constants and methods useful when dealing with a byte .
Character	The Character class wraps a value of the primitive type char in an object. An object of type Character contains a single field whose type is char. This class provides several methods for determining a character's category (lowercase letter, digit, etc.) and for converting characters from uppercase to lowercase and vice versa.
Class<T>	Instances of the class Class represent classes and interfaces in a running Java application. An enum is a kind of class and an annotation is a kind of interface. The primitive Java types (boolean, byte, char, short, int, long, float, and double), and the keyword void are also represented as Class objects. Important, Class has no public constructor.
ClassLoader	A classloader is an object that is responsible for loading classes. The class ClassLoader is an abstract Class. Every Class object contains a reference to the ClassLoader that defined it.
Compiler	The Compiler class is provided to support Java-to-native-code compilers and related services. It determines if the system property java.compiler exists.
Double	The Double class wraps a value of the primitive type double in an object. An object of type Double contains a single field whose type is double. This class provides several methods for converting a double to a String and a String to a double , as well as other constants and methods useful when dealing with a double.
Float	The Float class wraps a value of primitive type float in an object. An object of type Float contains a single field whose type is float. This class provides several methods for converting a float to a String and a String to a float, as well as other constants and methods useful when dealing with a float.
InheritableThreadLocal<T>	This class extends ThreadLocal to provide inheritance of values from parent thread to child thread: when a child thread is created, the child receives initial values for all inheritable thread-local variables for which the parent has values.
Integer	The Integer class wraps a value of the primitive type int in an object. An object of type Integer contains a single field whose type is int. This class provides several methods for converting an int to a String and a String to an int, as well as other constants and methods useful when dealing with an int.
Long	The Long class wraps a value of the primitive type long in an object. An object of type Long contains a single field whose type is long. This class provides several methods for converting a long to a String and a String to a long, as well as other constants and methods useful when dealing with a long.
Math	The class Math contains methods for performing basic numeric operations such as the elementary exponential, logarithm, square root, and trigonometric functions.
Number	The abstract class Number is the superclass of classes BigDecimal, BigInteger, Byte, Double, Float, Integer, Long, and Short. Subclasses of Number must provide methods to convert the represented numeric value to byte, double, float, int, long, and short.
Object	Class Object is the root of the class hierarchy. Every class has Object as a superclass. All objects, including arrays, implement the methods of this class.
Package	Package objects contain version information about the implementation and specification of a Java package. The set of classes that make up the package may implement a particular specification and if so the specification title, version number, and vendor strings identify that specification.
Process	The ProcessBuilder.start() and Runtime.exec methods create a native process and return an instance of a subclass of Process that can be used to control the process and obtain information about it. The class Process provides methods for performing input from the process, performing output to the process, waiting for the process to complete, checking the exit status of the process, and destroying (killing) the process.
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.
RuntimePermission	This class is for runtime permissions. A RuntimePermission contains a name (also referred to as a "target name") but no actions list.
SecurityManager	The security manager is a class that allows applications to implement a security policy. It allows an application to determine, before performing a possibly unsafe or sensitive operation, what the operation is and whether it is being attempted in a security context that allows the operation to be performed.
Short	The Short class wraps a value of primitive type short in an object. An object of type Short contains a single field whose type is short. This class provides several methods for converting a short to a String and a String to a short, as well as other constants and methods useful when dealing with a short.
StackTraceElement	An element in a stack trace, as returned by Throwable.getStackTrace(). Each element represents a single stack frame. All stack frames except for the one at the top of the stack represent a method invocation.
StrictMath	The class StrictMath contains methods for performing basic numeric operations such as the elementary exponential, logarithm, square root, and trigonometric functions.
String	The String class represents character strings. All string literals in Java programs, such as "abc", are implemented as instances of this class.
StringBuffer	A thread-safe, mutable sequence of characters. A string buffer is like a String, but can be modified.
StringBuilder	A mutable sequence of characters. This class provides an API compatible with StringBuffer, but with no guarantee of synchronization.
System	The System class contains several useful class fields and methods. It cannot be instantiated.
Thread	A Thread is a thread of execution in a program. The Java Virtual Machine (JVM) allows an application to have multiple threads of execution running concurrently.
ThreadDeath	An instance of ThreadDeath is thrown in the victim thread when the stop method with zero arguments in class Thread is called.
ThreadGroup	A thread group represents a set of threads. The thread groups form a tree in which every thread group except the initial thread group has a parent.
ThreadLocal<T>	This class provides thread-local variables. These variables differ from their normal counterparts in that each thread that accesses one (via its get or set method) has its own, independently initialized copy of the variable
Throwable	The Throwable class is the superclass of all errors and exceptions in the Java language.
Void	The Void class is an uninstantiable placeholder class to hold a reference to the Class object representing the Java keyword void.

Exception	Description
ArithmeticException	Thrown when an exceptional arithmetic condition has occurred.
ArrayIndexOutOfBoundsException	Thrown to indicate that an array has been accessed with an illegal index.
ArrayStoreException	Thrown to indicate that an attempt has been made to store the wrong type of object into an array of objects.
ClassCastException	Thrown to indicate that the code has attempted to cast an object to a subclass of which it is not an instance.
ClassNotFoundException	Thrown when an application tries to load in a class through its string name using: The forName method in class Class.
CloneNotSupportedException	Thrown to indicate that the clone method in class Object has been called to clone an object, but that the object's class does not implement the Cloneable interface.
Exception	The class Exception and its subclasses are a form of Throwable that indicates conditions that a reasonable application might want to catch.
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.
IllegalThreadStateException	Thrown to indicate that a thread is not in an appropriate state for the requested operation.
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.
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 because it is an interface or is an abstract class.
InterruptedException	Thrown when a thread is waiting, sleeping, or otherwise paused for a long time and another thread interrupts it using the interrupt method in class Thread.
NegativeArraySizeException	Thrown if an application tries to create an array with negative size.
NoSuchFieldException	Signals that the class doesn't have a field of a specified name.
NoSuchMethodException	Thrown when a particular method cannot be found.
NullPointerException	Thrown when an application attempts to use null in a case where an object is required.
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.
RuntimeException	RuntimeException is the superclass of those exceptions that can be thrown during the normal operation of the Java Virtual Machine.
SecurityException	Thrown by the security manager to indicate a security violation.
StringIndexOutOfBoundsException	Thrown by String methods to indicate that an index is either negative or greater than the size of the string.
UnsupportedOperationException	Thrown to indicate that the requested operation is not supported.

Error	Description
AbstractMethodError	Thrown when an application tries to call an abstract method.
AssertionError	Thrown to indicate that an assertion has failed.
ClassCircularityError	Thrown when a circularity has been detected while initializing a class.
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.
Error	An Error is a subclass of Throwable that indicates serious problems that a reasonable application should not try to catch.
ExceptionInInitializerError	Signals that an unexpected exception has occurred in a static initializer. An ExceptionInInitializerError is thrown to indicate that an exception occurred during evaluation of a static initializer or the initializer for a static variable.
IllegalAccessError	Thrown if an application attempts to access or modify a field, or to call a method that it does not have access to. Normally, this error is caught by the compiler.
IncompatibleClassChangeError	Thrown when an incompatible class change has occurred to some class definition. The definition of some class, on which the currently executing method depends, has since changed.
InstantiationError	Thrown when an application tries to use the Java new construct to instantiate an abstract class or an interface.
InternalError	Thrown to indicate some unexpected internal error has occurred in the Java Virtual Machine.
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.
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.
NoSuchFieldError	Thrown if an application tries to access or modify a specified field of an object, and that object no longer has that field.
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.
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.
StackOverflowError	Thrown when a stack overflow occurs because an application recurses too deeply.
ThreadDeath	An instance of ThreadDeath is thrown in the victim thread when the stop method with zero arguments in class Thread is called.
UnknownError	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.
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.