Java syntax

Program structure

Java applications consist of collections of classes. Classes exist in packages but can also be nested inside other classes.

main method

Every Java application must have an entry point. This is true of both graphical interface applications and console applications. The entry point is the main method. There can be more than one class with a main method, but the main class is always defined externally (for example, in a manifest file). The main method along with the main class must be declared public. The method must be static and is passed command-line arguments as an array of strings. Unlike C++ or C#, it never returns a value and must return void. However, a return code can be specified to the operating system by calling System.exit().

<span id="mwAoc"></span><span class="kd" id="mwAog">public</span><span class="w" id="mwAok"> </span><span class="kd" id="mwAoo">static</span><span class="w" id="mwAos"> </span><span class="kt" id="mwAow">void</span><span class="w" id="mwAo0"> </span><span class="nf" id="mwAo4">main</span><span class="p" id="mwAo8">(</span><span class="n" id="mwApA">String</span><span class="o" id="mwApE">[]</span><span class="w" id="mwApI"> </span><span class="n" id="mwApM">args</span><span class="p" id="mwApQ">)</span><span class="w" id="mwApU"> </span><span class="p" id="mwApY">{</span> <span class="w" id="mwApc"> </span><span class="c1" id="mwApg">// ...</span> <span class="p" id="mwApk">}</span>

Packages

Packages are a part of a class name and they are used to group and/or distinguish named entities from other ones. Another purpose of packages is to govern code access together with access modifiers. For example, java.io.InputStream is a fully qualified class name for the class InputStream which is located in the package java.io.

A package is essentially a namespace. Packages do not have hierarchies, even though the periods may suggest so. A package can be controlled whether it is accessible externally or internally of a project using modules.

A package is declared at the start of the file with the package declaration:

<span id="mwAqY"></span><span class="kn" id="mwAqc">package</span><span class="w" id="mwAqg"> </span><span class="nn" id="mwAqk">org.wikipedia.examples</span><span class="p" id="mwAqo">;</span> <span class="kd" id="mwAqs">public</span><span class="w" id="mwAqw"> </span><span class="kd" id="mwAq0">class</span> <span class="nc" id="mwAq4">Foo</span><span class="w" id="mwAq8"> </span><span class="p" id="mwArA">{</span> <span class="w" id="mwArE"> </span><span class="c1" id="mwArI">// ...</span> <span class="p" id="mwArM">}</span>

Classes with the public modifier must be placed in the files with the same name and .java extension and put into nested folders corresponding to the package name. The above class org.wikipedia.examples.Foo will have the following path: org/wikipedia/examples/Foo.java.

Modules

Modular programming (modules) is used to group packages and tightly control what packages belong to the public API. Contrary to JAR files, modules explicitly declare which modules they depend on, and what packages they export. Explicit dependency declarations improve the integrity of the code, by making it easier to reason about large applications and the dependencies between software components.

The module declaration is placed in a file named module-info.java at the root of the module's source-file hierarchy. The JDK will verify dependencies and interactions between modules both at compile-time and runtime.

For example, the following module declaration declares that the module org.wikipedia.bar depends on another org.wikipedia.baz module, and exports the following packages: org.wikipedia.bar.alpha and org.wikipedia.bar.beta:

<span id="mwAs4"></span><span class="kd" id="mwAs8">module</span> <span class="nc" id="mwAtA">org</span><span class="p" id="mwAtE">.</span><span class="na" id="mwAtI">wikipedia</span><span class="p" id="mwAtM">.</span><span class="na" id="mwAtQ">bar</span><span class="w" id="mwAtU"> </span><span class="p" id="mwAtY">{</span> <span class="w" id="mwAtc"> </span><span class="kd" id="mwAtg">requires</span><span class="w" id="mwAtk"> </span><span class="n" id="mwAto">org</span><span class="p" id="mwAts">.</span><span class="na" id="mwAtw">wikipedia</span><span class="p" id="mwAt0">.</span><span class="na" id="mwAt4">baz</span><span class="p" id="mwAt8">;</span> <span class="w" id="mwAuA"> </span><span class="kd" id="mwAuE">exports</span><span class="w" id="mwAuI"> </span><span class="n" id="mwAuM">org</span><span class="p" id="mwAuQ">.</span><span class="na" id="mwAuU">wikipedia</span><span class="p" id="mwAuY">.</span><span class="na" id="mwAuc">bar</span><span class="p" id="mwAug">.</span><span class="na" id="mwAuk">alpha</span><span class="p" id="mwAuo">;</span> <span class="w" id="mwAus"> </span><span class="kd" id="mwAuw">exports</span><span class="w" id="mwAu0"> </span><span class="n" id="mwAu4">org</span><span class="p" id="mwAu8">.</span><span class="na" id="mwAvA">wikipedia</span><span class="p" id="mwAvE">.</span><span class="na" id="mwAvI">bar</span><span class="p" id="mwAvM">.</span><span class="na" id="mwAvQ">beta</span><span class="p" id="mwAvU">;</span> <span class="p" id="mwAvY">}</span>

The public members of org.wikipedia.bar.alpha and org.wikipedia.bar.beta packages will be accessible by dependent modules. Private members are inaccessible even through a means such as reflective programming (reflection). In Java versions 9 through 16, whether such 'illegal access' is de facto permitted depends on a command line setting.

The JDK became modularized in Java 9. For example, the majority of the Java standard library is exported by the module java.base.

Import declaration

An import statement is used to resolve a type belonging to another package (namespace). It can be seen as similar to using in C++.

Type import declaration

A type import declaration allows a named type to be referred to by a simple name rather than the full name that includes the package. Import declarations can be single type import declarations or import-on-demand declarations. Import declarations must be placed at the top of a code file after the package declaration.

<span id="mwAxI"></span><span class="kn" id="mwAxM">package</span><span class="w" id="mwAxQ"> </span><span class="nn" id="mwAxU">org.wikipedia.examples</span><span class="p" id="mwAxY">;</span> <span class="kn" id="mwAxc">import</span><span class="w" id="mwAxg"> </span><span class="nn" id="mwAxk">java.util.Random</span><span class="p" id="mwAxo">;</span><span class="w" id="mwAxs"> </span><span class="c1" id="mwAxw">// Single type declaration</span> <span class="kd" id="mwAx0">public</span><span class="w" id="mwAx4"> </span><span class="kd" id="mwAx8">class</span> <span class="nc" id="mwAyA">ImportsTest</span><span class="w" id="mwAyE"> </span><span class="p" id="mwAyI">{</span> <span class="w" id="mwAyM"> </span><span class="kd" id="mwAyQ">public</span><span class="w" id="mwAyU"> </span><span class="kd" id="mwAyY">static</span><span class="w" id="mwAyc"> </span><span class="kt" id="mwAyg">void</span><span class="w" id="mwAyk"> </span><span class="nf" id="mwAyo">main</span><span class="p" id="mwAys">(</span><span class="n" id="mwAyw">String</span><span class="o" id="mwAy0">[]</span><span class="w" id="mwAy4"> </span><span class="n" id="mwAy8">args</span><span class="p" id="mwAzA">)</span><span class="w" id="mwAzE"> </span><span class="p" id="mwAzI">{</span> <span class="w" id="mwAzM"> </span><span class="cm" id="mwAzQ">/* The following line is equivalent to</span> <span class="cm" id="mwAzU"> * java.util.Random random = new java.util.Random();</span> <span class="cm" id="mwAzY"> * It would have been incorrect without the import.</span> <span class="cm" id="mwAzc"> */</span> <span class="w" id="mwAzg"> </span><span class="n" id="mwAzk">Random</span><span class="w" id="mwAzo"> </span><span class="n" id="mwAzs">random</span><span class="w" id="mwAzw"> </span><span class="o" id="mwAz0">=</span><span class="w" id="mwAz4"> </span><span class="k" id="mwAz8">new</span><span class="w" id="mwA0A"> </span><span class="n" id="mwA0E">Random</span><span class="p" id="mwA0I">();</span> <span class="w" id="mwA0M"> </span><span class="p" id="mwA0Q">}</span> <span class="p" id="mwA0U">}</span>

Import-on-demand declarations are mentioned in the code. A "wildcard import" (or "glob import") imports all the types of the package. A "static import" imports members of the package.

<span id="mwA0k"></span><span class="cm" id="mwA0o">/**</span> <span class="cm" id="mwA0s"> * This form of importing classes makes all classes</span> <span class="cm" id="mwA0w"> * in package java.util available by name, could be used instead of the</span> <span class="cm" id="mwA00"> * import declaration in the previous example.</span> <span class="cm" id="mwA04"> */</span> <span class="kn" id="mwA08">import</span><span class="w" id="mwA1A"> </span><span class="nn" id="mwA1E">java.util.*</span><span class="p" id="mwA1I">;</span>

A wildcard import may possibly import nothing, if no symbols exist in that package. For example, statements like import java.*; are legal, but do nothing, as all classes reside in packages within package java; such an import would not import all classes in the package recursively.

Static import declaration

This type of declaration has been available since J2SE 5.0. Static import declarations allow access to static members defined in another class, interface, annotation, or enum; without specifying the class name:

<span id="mwA2I"></span><span class="kn" id="mwA2M">import static</span><span class="w" id="mwA2Q"> </span><span class="nn" id="mwA2U">java.lang.System.out</span><span class="p" id="mwA2Y">;</span><span class="w" id="mwA2c"> </span><span class="c1" id="mwA2g">// 'out' is a static field in java.lang.System</span> <span class="kd" id="mwA2k">public</span><span class="w" id="mwA2o"> </span><span class="kd" id="mwA2s">class</span> <span class="nc" id="mwA2w">HelloWorld</span><span class="w" id="mwA20"> </span><span class="p" id="mwA24">{</span> <span class="w" id="mwA28"> </span><span class="kd" id="mwA3A">public</span><span class="w" id="mwA3E"> </span><span class="kd" id="mwA3I">static</span><span class="w" id="mwA3M"> </span><span class="kt" id="mwA3Q">void</span><span class="w" id="mwA3U"> </span><span class="nf" id="mwA3Y">main</span><span class="p" id="mwA3c">(</span><span class="n" id="mwA3g">String</span><span class="o" id="mwA3k">[]</span><span class="w" id="mwA3o"> </span><span class="n" id="mwA3s">args</span><span class="p" id="mwA3w">)</span><span class="w" id="mwA30"> </span><span class="p" id="mwA34">{</span> <span class="w" id="mwA38"> </span><span class="cm" id="mwA4A">/* The following line is equivalent to</span> <span class="cm" id="mwA4E"> System.out.println("Hi World!");</span> <span class="cm" id="mwA4I"> and would have been incorrect without the import declaration. */</span> <span class="w" id="mwA4M"> </span><span class="n" id="mwA4Q">out</span><span class="p" id="mwA4U">.</span><span class="na" id="mwA4Y">println</span><span class="p" id="mwA4c">(</span><span class="s" id="mwA4g">"Hello World!"</span><span class="p" id="mwA4k">);</span> <span class="w" id="mwA4o"> </span><span class="p" id="mwA4s">}</span> <span class="p" id="mwA4w">}</span>

Import-on-demand declarations allow to import all the fields of the type:

<span id="mwA5A"></span><span class="cm" id="mwA5E">/**</span> <span class="cm" id="mwA5I"> * This form of declaration makes all</span> <span class="cm" id="mwA5M"> * fields in the java.lang.System class available by name, and may be used instead</span> <span class="cm" id="mwA5Q"> * of the import declaration in the previous example.</span> <span class="cm" id="mwA5U"> */</span> <span class="kn" id="mwA5Y">import static</span><span class="w" id="mwA5c"> </span><span class="nn" id="mwA5g">java.lang.System.*</span><span class="p" id="mwA5k">;</span>

Enum constants may also be used with static import. For example, this enum is in the package called screen:

<span id="mwA54"></span><span class="kd" id="mwA58">public</span><span class="w" id="mwA6A"> </span><span class="kd" id="mwA6E">enum</span><span class="w" id="mwA6I"> </span><span class="n" id="mwA6M">Colors</span><span class="w" id="mwA6Q"> </span><span class="p" id="mwA6U">{</span> <span class="w" id="mwA6Y"> </span><span class="n" id="mwA6c">RED</span><span class="p" id="mwA6g">,</span><span class="w" id="mwA6k"> </span><span class="n" id="mwA6o">BLUE</span><span class="p" id="mwA6s">,</span><span class="w" id="mwA6w"> </span><span class="n" id="mwA60">GREEN</span> <span class="p" id="mwA64">};</span>

It is possible to use static import declarations in another class to retrieve the enum constants:

<span id="mwA7I"></span><span class="kn" id="mwA7M">import</span><span class="w" id="mwA7Q"> </span><span class="nn" id="mwA7U">org.wikipedia.screen.ColorName</span><span class="p" id="mwA7Y">;</span> <span class="kn" id="mwA7c">import static</span><span class="w" id="mwA7g"> </span><span class="nn" id="mwA7k">org.wikipedia.screen.ColorName.*</span><span class="p" id="mwA7o">;</span> <span class="kd" id="mwA7s">public</span><span class="w" id="mwA7w"> </span><span class="kd" id="mwA70">class</span> <span class="nc" id="mwA74">Dots</span><span class="w" id="mwA78"> </span><span class="p" id="mwA8A">{</span> <span class="w" id="mwA8E"> </span><span class="cm" id="mwA8I">/* The following line is equivalent to 'ColorName foo = ColorName.RED',</span> <span class="cm" id="mwA8M"> and it would have been incorrect without the static import. */</span> <span class="w" id="mwA8Q"> </span><span class="n" id="mwA8U">ColorName</span><span class="w" id="mwA8Y"> </span><span class="n" id="mwA8c">foo</span><span class="w" id="mwA8g"> </span><span class="o" id="mwA8k">=</span><span class="w" id="mwA8o"> </span><span class="n" id="mwA8s">RED</span><span class="p" id="mwA8w">;</span> <span class="w" id="mwA80"> </span><span class="kt" id="mwA84">void</span><span class="w" id="mwA88"> </span><span class="nf" id="mwA9A">shift</span><span class="p" id="mwA9E">()</span><span class="w" id="mwA9I"> </span><span class="p" id="mwA9M">{</span> <span class="w" id="mwA9Q"> </span><span class="cm" id="mwA9U">/* The following line is equivalent to</span> <span class="cm" id="mwA9Y"> if (foo == ColorName.RED) foo = ColorName.BLUE; */</span> <span class="w" id="mwA9c"> </span><span class="k" id="mwA9g">if</span><span class="w" id="mwA9k"> </span><span class="p" id="mwA9o">(</span><span class="n" id="mwA9s">foo</span><span class="w" id="mwA9w"> </span><span class="o" id="mwA90">==</span><span class="w" id="mwA94"> </span><span class="n" id="mwA98">RED</span><span class="p" id="mwA-A">)</span><span class="w" id="mwA-E"> </span><span class="p" id="mwA-I">{</span> <span class="w" id="mwA-M"> </span><span class="n" id="mwA-Q">foo</span><span class="w" id="mwA-U"> </span><span class="o" id="mwA-Y">=</span><span class="w" id="mwA-c"> </span><span class="n" id="mwA-g">BLUE</span><span class="p" id="mwA-k">;</span> <span class="w" id="mwA-o"> </span><span class="p" id="mwA-s">}</span> <span class="w" id="mwA-w"> </span><span class="p" id="mwA-0">}</span> <span class="p" id="mwA-4">}</span>

Module import declaration

Since Java 25, modules can be used in import statements to automatically import all the packages exported by the module. This is done using import module. For example, import module java.sql; is equivalent to

<span id="mwA_0"></span><span class="kn" id="mwA_4">import</span><span class="w" id="mwA_8"> </span><span class="nn" id="mwBAA">java.sql.*</span><span class="p" id="mwBAE">;</span> <span class="kn" id="mwBAI">import</span><span class="w" id="mwBAM"> </span><span class="nn" id="mwBAQ">javax.sql.*</span><span class="p" id="mwBAU">;</span> <span class="c1" id="mwBAY">// Remaining indirect exports from java.logging, java.transaction.xa, and java.xml</span>

Similarly, import module java.base;, similarly, imports all 54 packages belonging to java.base.

<span id="mwBBA"></span><span class="kn" id="mwBBE">import module</span><span class="w" id="mwBBI"> </span><span class="nn" id="mwBBM">java.base</span><span class="p" id="mwBBQ">;</span> <span class="cm" id="mwBBU">/**</span> <span class="cm" id="mwBBY"> * importing module java.base allows us to avoid manually importing most classes</span> <span class="cm" id="mwBBc"> * the following classes (outside of java.lang) are used:</span> <span class="cm" id="mwBBg"> * java.text.MessageFormat</span> <span class="cm" id="mwBBk"> * java.util.Date</span> <span class="cm" id="mwBBo"> * java.util.List</span> <span class="cm" id="mwBBs"> * java.util.concurrent.ThreadLocalRandom</span> <span class="cm" id="mwBBw"> */</span> <span class="kd" id="mwBB0">public</span><span class="w" id="mwBB4"> </span><span class="kd" id="mwBB8">class</span> <span class="nc" id="mwBCA">Example</span><span class="w" id="mwBCE"> </span><span class="p" id="mwBCI">{</span> <span class="w" id="mwBCM"> </span><span class="kd" id="mwBCQ">public</span><span class="w" id="mwBCU"> </span><span class="kd" id="mwBCY">static</span><span class="w" id="mwBCc"> </span><span class="kt" id="mwBCg">void</span><span class="w" id="mwBCk"> </span><span class="nf" id="mwBCo">main</span><span class="p" id="mwBCs">(</span><span class="n" id="mwBCw">String</span><span class="o" id="mwBC0">[]</span><span class="w" id="mwBC4"> </span><span class="n" id="mwBC8">args</span><span class="p" id="mwBDA">)</span><span class="w" id="mwBDE"> </span><span class="p" id="mwBDI">{</span> <span class="w" id="mwBDM"> </span><span class="n" id="mwBDQ">List</span><span class="o" id="mwBDU"><</span><span class="n" id="mwBDY">String</span><span class="o" id="mwBDc">></span><span class="w" id="mwBDg"> </span><span class="n" id="mwBDk">colours</span><span class="w" id="mwBDo"> </span><span class="o" id="mwBDs">=</span><span class="w" id="mwBDw"> </span><span class="n" id="mwBD0">List</span><span class="p" id="mwBD4">.</span><span class="na" id="mwBD8">of</span><span class="p" id="mwBEA">(</span><span class="s" id="mwBEE">"Red"</span><span class="p" id="mwBEI">,</span><span class="w" id="mwBEM"> </span><span class="s" id="mwBEQ">"Orange"</span><span class="p" id="mwBEU">,</span><span class="w" id="mwBEY"> </span><span class="s" id="mwBEc">"Yellow"</span><span class="p" id="mwBEg">,</span><span class="w" id="mwBEk"> </span><span class="s" id="mwBEo">"Green"</span><span class="p" id="mwBEs">,</span><span class="w" id="mwBEw"> </span><span class="s" id="mwBE0">"Blue"</span><span class="p" id="mwBE4">,</span><span class="w" id="mwBE8"> </span><span class="s" id="mwBFA">"Indigo"</span><span class="p" id="mwBFE">,</span><span class="w" id="mwBFI"> </span><span class="s" id="mwBFM">"Violet"</span><span class="p" id="mwBFQ">);</span> <span class="w" id="mwBFU"> </span><span class="n" id="mwBFY">IO</span><span class="p" id="mwBFc">.</span><span class="na" id="mwBFg">println</span><span class="p" id="mwBFk">(</span><span class="n" id="mwBFo">MessageFormat</span><span class="p" id="mwBFs">.</span><span class="na" id="mwBFw">format</span><span class="p" id="mwBF0">(</span><span class="s" id="mwBF4">"My favourite colour is {0} and today is {1,date,long}"</span><span class="p" id="mwBF8">,</span> <span class="w" id="mwBGA"> </span><span class="n" id="mwBGE">colours</span><span class="p" id="mwBGI">.</span><span class="na" id="mwBGM">get</span><span class="p" id="mwBGQ">(</span><span class="n" id="mwBGU">ThreadLocalRandom</span><span class="p" id="mwBGY">.</span><span class="na" id="mwBGc">current</span><span class="p" id="mwBGg">().</span><span class="na" id="mwBGk">nextInt</span><span class="p" id="mwBGo">(</span><span class="n" id="mwBGs">colours</span><span class="p" id="mwBGw">.</span><span class="na" id="mwBG0">size</span><span class="p" id="mwBG4">())),</span> <span class="w" id="mwBG8"> </span><span class="k" id="mwBHA">new</span><span class="w" id="mwBHE"> </span><span class="n" id="mwBHI">Date</span><span class="p" id="mwBHM">()</span> <span class="w" id="mwBHQ"> </span><span class="p" id="mwBHU">));</span> <span class="w" id="mwBHY"> </span><span class="p" id="mwBHc">}</span> <span class="p" id="mwBHg">}</span>

Operators

Operators in Java are similar to those in C++. However, there is no delete operator due to garbage collection mechanisms in Java, and there are no operations on pointers since Java does not support them. Another difference is that Java has an unsigned right shift operator (>>>), while C's right shift operator's signedness is type-dependent. Operators in Java cannot be overloaded. The only overloaded operator is operator+ for string concatenation.

Control structures

Conditional statements

if statement

if statements in Java are similar to those in C and use the same syntax:

<span id="mwBVA"></span><span class="k" id="mwBVE">if</span><span class="w" id="mwBVI"> </span><span class="p" id="mwBVM">(</span><span class="n" id="mwBVQ">i</span><span class="w" id="mwBVU"> </span><span class="o" id="mwBVY">==</span><span class="w" id="mwBVc"> </span><span class="mi" id="mwBVg">3</span><span class="p" id="mwBVk">)</span><span class="w" id="mwBVo"> </span><span class="p" id="mwBVs">{</span> <span class="w" id="mwBVw"> </span><span class="n" id="mwBV0">doSomething</span><span class="p" id="mwBV4">();</span> <span class="p" id="mwBV8">}</span>

if statement may include optional else block, in which case it becomes an if-then-else statement:

<span id="mwBWU"></span><span class="k" id="mwBWY">if</span><span class="w" id="mwBWc"> </span><span class="p" id="mwBWg">(</span><span class="n" id="mwBWk">i</span><span class="w" id="mwBWo"> </span><span class="o" id="mwBWs">==</span><span class="w" id="mwBWw"> </span><span class="mi" id="mwBW0">3</span><span class="p" id="mwBW4">)</span><span class="w" id="mwBW8"> </span><span class="p" id="mwBXA">{</span> <span class="w" id="mwBXE"> </span><span class="n" id="mwBXI">doSomething</span><span class="p" id="mwBXM">();</span> <span class="p" id="mwBXQ">}</span><span class="w" id="mwBXU"> </span><span class="k" id="mwBXY">else</span><span class="w" id="mwBXc"> </span><span class="p" id="mwBXg">{</span> <span class="w" id="mwBXk"> </span><span class="n" id="mwBXo">doSomethingElse</span><span class="p" id="mwBXs">();</span> <span class="p" id="mwBXw">}</span>

Like C, else-if construction does not involve any special keywords, it is formed as a sequence of separate if-then-else statements:

<span id="mwBYA"></span><span class="k" id="mwBYE">if</span><span class="w" id="mwBYI"> </span><span class="p" id="mwBYM">(</span><span class="n" id="mwBYQ">i</span><span class="w" id="mwBYU"> </span><span class="o" id="mwBYY">==</span><span class="w" id="mwBYc"> </span><span class="mi" id="mwBYg">3</span><span class="p" id="mwBYk">)</span><span class="w" id="mwBYo"> </span><span class="p" id="mwBYs">{</span> <span class="w" id="mwBYw"> </span><span class="n" id="mwBY0">doSomething</span><span class="p" id="mwBY4">();</span> <span class="p" id="mwBY8">}</span><span class="w" id="mwBZA"> </span><span class="k" id="mwBZE">else</span><span class="w" id="mwBZI"> </span><span class="k" id="mwBZM">if</span><span class="w" id="mwBZQ"> </span><span class="p" id="mwBZU">(</span><span class="n" id="mwBZY">i</span><span class="w" id="mwBZc"> </span><span class="o" id="mwBZg">==</span><span class="w" id="mwBZk"> </span><span class="mi" id="mwBZo">2</span><span class="p" id="mwBZs">)</span><span class="w" id="mwBZw"> </span><span class="p" id="mwBZ0">{</span> <span class="w" id="mwBZ4"> </span><span class="n" id="mwBZ8">doSomethingElse</span><span class="p" id="mwBaA">();</span> <span class="p" id="mwBaE">}</span><span class="w" id="mwBaI"> </span><span class="k" id="mwBaM">else</span><span class="w" id="mwBaQ"> </span><span class="p" id="mwBaU">{</span> <span class="w" id="mwBaY"> </span><span class="n" id="mwBac">doSomethingDifferent</span><span class="p" id="mwBag">();</span> <span class="p" id="mwBak">}</span>

Also, a ?: operator can be used in place of simple if statement, for example

<span id="mwBa4"></span><span class="kt" id="mwBa8">int</span><span class="w" id="mwBbA"> </span><span class="n" id="mwBbE">a</span><span class="w" id="mwBbI"> </span><span class="o" id="mwBbM">=</span><span class="w" id="mwBbQ"> </span><span class="mi" id="mwBbU">1</span><span class="p" id="mwBbY">;</span> <span class="kt" id="mwBbc">int</span><span class="w" id="mwBbg"> </span><span class="n" id="mwBbk">b</span><span class="w" id="mwBbo"> </span><span class="o" id="mwBbs">=</span><span class="w" id="mwBbw"> </span><span class="mi" id="mwBb0">2</span><span class="p" id="mwBb4">;</span> <span class="kt" id="mwBb8">int</span><span class="w" id="mwBcA"> </span><span class="n" id="mwBcE">minVal</span><span class="w" id="mwBcI"> </span><span class="o" id="mwBcM">=</span><span class="w" id="mwBcQ"> </span><span class="p" id="mwBcU">(</span><span class="n" id="mwBcY">a</span><span class="w" id="mwBcc"> </span><span class="o" id="mwBcg"><</span><span class="w" id="mwBck"> </span><span class="n" id="mwBco">b</span><span class="p" id="mwBcs">)</span><span class="w" id="mwBcw"> </span><span class="o" id="mwBc0">?</span><span class="w" id="mwBc4"> </span><span class="n" id="mwBc8">a</span><span class="w" id="mwBdA"> </span><span class="p" id="mwBdE">:</span><span class="w" id="mwBdI"> </span><span class="n" id="mwBdM">b</span><span class="p" id="mwBdQ">;</span>

switch statement

Switch statements in Java can use byte, short, char, and int (not long) primitive data types or their corresponding wrapper types. Starting with J2SE 5.0, it is possible to use enum types. Starting with Java SE 7, it is possible to use Strings. Other reference types cannot be used in switch statements.

Possible values are listed using case labels. These labels in Java may contain only constants (including enum constants and string constants). Execution will start after the label corresponding to the expression inside the brackets. An optional default label may be present to declare that the code following it will be executed if none of the case labels correspond to the expression.

Code for each label ends with the break keyword. It is possible to omit it causing the execution to proceed to the next label, however, a warning will usually be reported during compilation.

<span id="mwBew"></span><span class="k" id="mwBe0">switch</span><span class="w" id="mwBe4"> </span><span class="p" id="mwBe8">(</span><span class="n" id="mwBfA">ch</span><span class="p" id="mwBfE">)</span><span class="w" id="mwBfI"> </span><span class="p" id="mwBfM">{</span> <span class="w" id="mwBfQ"> </span><span class="k" id="mwBfU">case</span><span class="w" id="mwBfY"> </span><span class="sc" id="mwBfc">'A'</span><span class="p" id="mwBfg">:</span> <span class="w" id="mwBfk"> </span><span class="n" id="mwBfo">doSomething</span><span class="p" id="mwBfs">();</span><span class="w" id="mwBfw"> </span><span class="c1" id="mwBf0">// Triggered if ch == 'A'</span> <span class="w" id="mwBf4"> </span><span class="k" id="mwBf8">break</span><span class="p" id="mwBgA">;</span> <span class="w" id="mwBgE"> </span><span class="k" id="mwBgI">case</span><span class="w" id="mwBgM"> </span><span class="sc" id="mwBgQ">'B'</span><span class="p" id="mwBgU">:</span> <span class="w" id="mwBgY"> </span><span class="k" id="mwBgc">case</span><span class="w" id="mwBgg"> </span><span class="sc" id="mwBgk">'C'</span><span class="p" id="mwBgo">:</span> <span class="w" id="mwBgs"> </span><span class="n" id="mwBgw">doSomethingElse</span><span class="p" id="mwBg0">();</span><span class="w" id="mwBg4"> </span><span class="c1" id="mwBg8">// Triggered if ch == 'B' or ch == 'C'</span> <span class="w" id="mwBhA"> </span><span class="k" id="mwBhE">break</span><span class="p" id="mwBhI">;</span> <span class="w" id="mwBhM"> </span><span class="k" id="mwBhQ">default</span><span class="p" id="mwBhU">:</span> <span class="w" id="mwBhY"> </span><span class="n" id="mwBhc">doSomethingDifferent</span><span class="p" id="mwBhg">();</span><span class="w" id="mwBhk"> </span><span class="c1" id="mwBho">// Triggered in any other case</span> <span class="w" id="mwBhs"> </span><span class="k" id="mwBhw">break</span><span class="p" id="mwBh0">;</span> <span class="p" id="mwBh4">}</span>

switch expressions

Since Java 14 it has become possible to use switch expressions, which use the new arrow syntax:

<span id="mwBiQ"></span><span class="kd" id="mwBiU">enum</span><span class="w" id="mwBiY"> </span><span class="n" id="mwBic">Result</span><span class="w" id="mwBig"> </span><span class="p" id="mwBik">{</span> <span class="w" id="mwBio"> </span><span class="n" id="mwBis">GREAT</span><span class="p" id="mwBiw">,</span> <span class="w" id="mwBi0"> </span><span class="n" id="mwBi4">FINE</span><span class="p" id="mwBi8">,</span> <span class="w" id="mwBjA"> </span><span class="c1" id="mwBjE">// more enum values</span> <span class="p" id="mwBjI">}</span> <span class="n" id="mwBjM">Result</span><span class="w" id="mwBjQ"> </span><span class="n" id="mwBjU">result</span><span class="w" id="mwBjY"> </span><span class="o" id="mwBjc">=</span><span class="w" id="mwBjg"> </span><span class="k" id="mwBjk">switch</span><span class="w" id="mwBjo"> </span><span class="p" id="mwBjs">(</span><span class="n" id="mwBjw">ch</span><span class="p" id="mwBj0">)</span><span class="w" id="mwBj4"> </span><span class="p" id="mwBj8">{</span> <span class="w" id="mwBkA"> </span><span class="k" id="mwBkE">case</span><span class="w" id="mwBkI"> </span><span class="sc" id="mwBkM">'A'</span><span class="w" id="mwBkQ"> </span><span class="o" id="mwBkU">-></span><span class="w" id="mwBkY"> </span><span class="n" id="mwBkc">Result</span><span class="p" id="mwBkg">.</span><span class="na" id="mwBkk">GREAT</span><span class="p" id="mwBko">;</span> <span class="w" id="mwBks"> </span><span class="k" id="mwBkw">case</span><span class="w" id="mwBk0"> </span><span class="sc" id="mwBk4">'B'</span><span class="p" id="mwBk8">,</span><span class="w" id="mwBlA"> </span><span class="sc" id="mwBlE">'C'</span><span class="w" id="mwBlI"> </span><span class="o" id="mwBlM">-></span><span class="w" id="mwBlQ"> </span><span class="n" id="mwBlU">Result</span><span class="p" id="mwBlY">.</span><span class="na" id="mwBlc">FINE</span><span class="p" id="mwBlg">;</span> <span class="w" id="mwBlk"> </span><span class="k" id="mwBlo">default</span><span class="w" id="mwBls"> </span><span class="o" id="mwBlw">-></span><span class="w" id="mwBl0"> </span><span class="k" id="mwBl4">throw</span><span class="w" id="mwBl8"> </span><span class="k" id="mwBmA">new</span><span class="w" id="mwBmE"> </span><span class="n" id="mwBmI">Exception</span><span class="p" id="mwBmM">();</span> <span class="p" id="mwBmQ">};</span>

Alternatively, there is a possibility to express the same with the yield statement, although it is recommended to prefer the arrow syntax because it avoids the problem of accidental fall throughs.

<span id="mwBmk"></span><span class="n" id="mwBmo">Result</span><span class="w" id="mwBms"> </span><span class="n" id="mwBmw">result</span><span class="w" id="mwBm0"> </span><span class="o" id="mwBm4">=</span><span class="w" id="mwBm8"> </span><span class="k" id="mwBnA">switch</span><span class="w" id="mwBnE"> </span><span class="p" id="mwBnI">(</span><span class="n" id="mwBnM">ch</span><span class="p" id="mwBnQ">)</span><span class="w" id="mwBnU"> </span><span class="p" id="mwBnY">{</span> <span class="w" id="mwBnc"> </span><span class="k" id="mwBng">case</span><span class="w" id="mwBnk"> </span><span class="sc" id="mwBno">'A'</span><span class="p" id="mwBns">:</span> <span class="w" id="mwBnw"> </span><span class="kd" id="mwBn0">yield</span><span class="w" id="mwBn4"> </span><span class="n" id="mwBn8">Result</span><span class="p" id="mwBoA">.</span><span class="na" id="mwBoE">GREAT</span><span class="p" id="mwBoI">;</span> <span class="w" id="mwBoM"> </span><span class="k" id="mwBoQ">case</span><span class="w" id="mwBoU"> </span><span class="sc" id="mwBoY">'B'</span><span class="p" id="mwBoc">:</span> <span class="w" id="mwBog"> </span><span class="k" id="mwBok">case</span><span class="w" id="mwBoo"> </span><span class="sc" id="mwBos">'C'</span><span class="p" id="mwBow">:</span> <span class="w" id="mwBo0"> </span><span class="kd" id="mwBo4">yield</span><span class="w" id="mwBo8"> </span><span class="n" id="mwBpA">Result</span><span class="p" id="mwBpE">.</span><span class="na" id="mwBpI">FINE</span><span class="p" id="mwBpM">;</span> <span class="w" id="mwBpQ"> </span><span class="k" id="mwBpU">default</span><span class="p" id="mwBpY">:</span> <span class="w" id="mwBpc"> </span><span class="k" id="mwBpg">throw</span><span class="w" id="mwBpk"> </span><span class="k" id="mwBpo">new</span><span class="w" id="mwBps"> </span><span class="n" id="mwBpw">Exception</span><span class="p" id="mwBp0">();</span> <span class="p" id="mwBp4">};</span>

Iteration statements

Iteration statements are statements that are repeatedly executed when a given condition is evaluated as true. Since J2SE 5.0, Java has four forms of such statements. The condition must have type boolean or java.lang.Boolean. Java does not implicitly convert integers or class types to Boolean values.

For example, the following code is valid in C but results in a compilation error in Java.

<span id="mwBqg"></span><span class="k" id="mwBqk">while</span><span class="w" id="mwBqo"> </span><span class="p" id="mwBqs">(</span><span class="mi" id="mwBqw">1</span><span class="p" id="mwBq0">)</span><span class="w" id="mwBq4"> </span><span class="p" id="mwBq8">{</span> <span class="w" id="mwBrA"> </span><span class="n" id="mwBrE">doSomething</span><span class="p" id="mwBrI">();</span> <span class="p" id="mwBrM">}</span>

while loop

In the while loop, the test is done before each iteration.

<span id="mwBrw"></span><span class="k" id="mwBr0">while</span><span class="w" id="mwBr4"> </span><span class="p" id="mwBr8">(</span><span class="n" id="mwBsA">i</span><span class="w" id="mwBsE"> </span><span class="o" id="mwBsI"><</span><span class="w" id="mwBsM"> </span><span class="mi" id="mwBsQ">10</span><span class="p" id="mwBsU">)</span><span class="w" id="mwBsY"> </span><span class="p" id="mwBsc">{</span> <span class="w" id="mwBsg"> </span><span class="n" id="mwBsk">doSomething</span><span class="p" id="mwBso">();</span> <span class="p" id="mwBss">}</span>

do-while loop

In the do-while loop, the test is done after each iteration. Consequently, the code is always executed at least once.

<span id="mwBtQ"></span><span class="c1" id="mwBtU">// doSomething() is called at least once</span> <span class="k" id="mwBtY">do</span><span class="w" id="mwBtc"> </span><span class="p" id="mwBtg">{</span> <span class="w" id="mwBtk"> </span><span class="n" id="mwBto">doSomething</span><span class="p" id="mwBts">();</span> <span class="p" id="mwBtw">}</span><span class="w" id="mwBt0"> </span><span class="k" id="mwBt4">while</span><span class="w" id="mwBt8"> </span><span class="p" id="mwBuA">(</span><span class="n" id="mwBuE">i</span><span class="w" id="mwBuI"> </span><span class="o" id="mwBuM"><</span><span class="w" id="mwBuQ"> </span><span class="mi" id="mwBuU">10</span><span class="p" id="mwBuY">);</span>

for loop

for loops in Java include an initializer, a condition and a counter expression. It is possible to include several expressions of the same kind using comma as delimiter (except in the condition). However, unlike C, the comma is just a delimiter and not an operator.

<span id="mwBu0"></span><span class="k" id="mwBu4">for</span><span class="w" id="mwBu8"> </span><span class="p" id="mwBvA">(</span><span class="kt" id="mwBvE">int</span><span class="w" id="mwBvI"> </span><span class="n" id="mwBvM">i</span><span class="w" id="mwBvQ"> </span><span class="o" id="mwBvU">=</span><span class="w" id="mwBvY"> </span><span class="mi" id="mwBvc">0</span><span class="p" id="mwBvg">;</span><span class="w" id="mwBvk"> </span><span class="n" id="mwBvo">i</span><span class="w" id="mwBvs"> </span><span class="o" id="mwBvw"><</span><span class="w" id="mwBv0"> </span><span class="mi" id="mwBv4">10</span><span class="p" id="mwBv8">;</span><span class="w" id="mwBwA"> </span><span class="n" id="mwBwE">i</span><span class="o" id="mwBwI">++</span><span class="p" id="mwBwM">)</span><span class="w" id="mwBwQ"> </span><span class="p" id="mwBwU">{</span> <span class="w" id="mwBwY"> </span><span class="n" id="mwBwc">doSomething</span><span class="p" id="mwBwg">();</span> <span class="p" id="mwBwk">}</span> <span class="w" id="mwBwo"> </span> <span class="c1" id="mwBws">// A more complex loop using two variables</span> <span class="k" id="mwBww">for</span><span class="w" id="mwBw0"> </span><span class="p" id="mwBw4">(</span><span class="kt" id="mwBw8">int</span><span class="w" id="mwBxA"> </span><span class="n" id="mwBxE">i</span><span class="w" id="mwBxI"> </span><span class="o" id="mwBxM">=</span><span class="w" id="mwBxQ"> </span><span class="mi" id="mwBxU">0</span><span class="p" id="mwBxY">,</span><span class="w" id="mwBxc"> </span><span class="n" id="mwBxg">j</span><span class="w" id="mwBxk"> </span><span class="o" id="mwBxo">=</span><span class="w" id="mwBxs"> </span><span class="mi" id="mwBxw">9</span><span class="p" id="mwBx0">;</span><span class="w" id="mwBx4"> </span><span class="n" id="mwBx8">i</span><span class="w" id="mwByA"> </span><span class="o" id="mwByE"><</span><span class="w" id="mwByI"> </span><span class="mi" id="mwByM">10</span><span class="p" id="mwByQ">;</span><span class="w" id="mwByU"> </span><span class="n" id="mwByY">i</span><span class="o" id="mwByc">++</span><span class="p" id="mwByg">,</span><span class="w" id="mwByk"> </span><span class="n" id="mwByo">j</span><span class="w" id="mwBys"> </span><span class="o" id="mwByw">-=</span><span class="w" id="mwBy0"> </span><span class="mi" id="mwBy4">3</span><span class="p" id="mwBy8">)</span><span class="w" id="mwBzA"> </span><span class="p" id="mwBzE">{</span> <span class="w" id="mwBzI"> </span><span class="n" id="mwBzM">doSomething</span><span class="p" id="mwBzQ">();</span> <span class="p" id="mwBzU">}</span>

Like C, all three expressions are optional. The following loop never terminates:

<span id="mwBzk"></span><span class="k" id="mwBzo">for</span><span class="w" id="mwBzs"> </span><span class="p" id="mwBzw">(;;)</span><span class="w" id="mwBz0"> </span><span class="p" id="mwBz4">{</span> <span class="w" id="mwBz8"> </span><span class="n" id="mwB0A">doSomething</span><span class="p" id="mwB0E">();</span> <span class="p" id="mwB0I">}</span>

Foreach loop

Foreach loops have been available since J2SE 5.0. This type of loop uses built-in iterators over arrays and collections to return each item in the given collection. Every element is returned and reachable in the context of the code block. When the block is executed, the next item is returned until there are no items remaining. This for loop from Java was later added to C++11. Unlike C#, this kind of loop does not involve a special keyword, but instead uses a different notation style.

<span id="mwB04"></span><span class="k" id="mwB08">for</span><span class="w" id="mwB1A"> </span><span class="p" id="mwB1E">(</span><span class="kt" id="mwB1I">int</span><span class="w" id="mwB1M"> </span><span class="n" id="mwB1Q">i</span><span class="w" id="mwB1U"> </span><span class="p" id="mwB1Y">:</span><span class="w" id="mwB1c"> </span><span class="n" id="mwB1g">intArray</span><span class="p" id="mwB1k">)</span><span class="w" id="mwB1o"> </span><span class="p" id="mwB1s">{</span> <span class="w" id="mwB1w"> </span><span class="n" id="mwB10">doSomething</span><span class="p" id="mwB14">(</span><span class="n" id="mwB18">i</span><span class="p" id="mwB2A">);</span> <span class="p" id="mwB2E">}</span>

Jump statements

Labels

Labels are given points in code used by break and continue statements. While goto is a reserved keyword in Java, it cannot be used to jump to specific points in code (in fact, it has no use at all).

<span id="mwB2o"></span><span class="nl" id="mwB2s">start</span><span class="p" id="mwB2w">:</span> <span class="n" id="mwB20">someMethod</span><span class="p" id="mwB24">();</span>

break statement

The break statement breaks out of the closest loop or switch statement. Execution continues in the statement after the terminated statement, if any.

<span id="mwB3Y"></span><span class="k" id="mwB3c">for</span><span class="w" id="mwB3g"> </span><span class="p" id="mwB3k">(</span><span class="kt" id="mwB3o">int</span><span class="w" id="mwB3s"> </span><span class="n" id="mwB3w">i</span><span class="w" id="mwB30"> </span><span class="o" id="mwB34">=</span><span class="w" id="mwB38"> </span><span class="mi" id="mwB4A">0</span><span class="p" id="mwB4E">;</span><span class="w" id="mwB4I"> </span><span class="n" id="mwB4M">i</span><span class="w" id="mwB4Q"> </span><span class="o" id="mwB4U"><</span><span class="w" id="mwB4Y"> </span><span class="mi" id="mwB4c">10</span><span class="p" id="mwB4g">;</span><span class="w" id="mwB4k"> </span><span class="n" id="mwB4o">i</span><span class="o" id="mwB4s">++</span><span class="p" id="mwB4w">)</span><span class="w" id="mwB40"> </span><span class="p" id="mwB44">{</span> <span class="w" id="mwB48"> </span><span class="k" id="mwB5A">while</span><span class="w" id="mwB5E"> </span><span class="p" id="mwB5I">(</span><span class="kc" id="mwB5M">true</span><span class="p" id="mwB5Q">)</span><span class="w" id="mwB5U"> </span><span class="p" id="mwB5Y">{</span> <span class="w" id="mwB5c"> </span><span class="k" id="mwB5g">break</span><span class="p" id="mwB5k">;</span> <span class="w" id="mwB5o"> </span><span class="p" id="mwB5s">}</span> <span class="w" id="mwB5w"> </span><span class="c1" id="mwB50">// Will break to this point</span> <span class="p" id="mwB54">}</span>

It is possible to break out of the outer loop using labels:

<span id="mwB6I"></span><span class="nl" id="mwB6M">outer</span><span class="p" id="mwB6Q">:</span> <span class="k" id="mwB6U">for</span><span class="w" id="mwB6Y"> </span><span class="p" id="mwB6c">(</span><span class="kt" id="mwB6g">int</span><span class="w" id="mwB6k"> </span><span class="n" id="mwB6o">i</span><span class="w" id="mwB6s"> </span><span class="o" id="mwB6w">=</span><span class="w" id="mwB60"> </span><span class="mi" id="mwB64">0</span><span class="p" id="mwB68">;</span><span class="w" id="mwB7A"> </span><span class="n" id="mwB7E">i</span><span class="w" id="mwB7I"> </span><span class="o" id="mwB7M"><</span><span class="w" id="mwB7Q"> </span><span class="mi" id="mwB7U">10</span><span class="p" id="mwB7Y">;</span><span class="w" id="mwB7c"> </span><span class="n" id="mwB7g">i</span><span class="o" id="mwB7k">++</span><span class="p" id="mwB7o">)</span><span class="w" id="mwB7s"> </span><span class="p" id="mwB7w">{</span> <span class="w" id="mwB70"> </span><span class="k" id="mwB74">while</span><span class="w" id="mwB78"> </span><span class="p" id="mwB8A">(</span><span class="kc" id="mwB8E">true</span><span class="p" id="mwB8I">)</span><span class="w" id="mwB8M"> </span><span class="p" id="mwB8Q">{</span> <span class="w" id="mwB8U"> </span><span class="k" id="mwB8Y">break</span><span class="w" id="mwB8c"> </span><span class="n" id="mwB8g">outer</span><span class="p" id="mwB8k">;</span> <span class="w" id="mwB8o"> </span><span class="p" id="mwB8s">}</span> <span class="p" id="mwB8w">}</span> <span class="c1" id="mwB80">// Will break to this point</span>

continue statement

The continue statement discontinues the current iteration of the current control statement and begins the next iteration. The following while loop in the code below reads characters by calling getChar(), skipping the statements in the body of the loop if the characters are spaces:

<span id="mwB9Y"></span><span class="kt" id="mwB9c">int</span><span class="w" id="mwB9g"> </span><span class="n" id="mwB9k">ch</span><span class="p" id="mwB9o">;</span> <span class="k" id="mwB9s">while</span><span class="w" id="mwB9w"> </span><span class="p" id="mwB90">(</span><span class="n" id="mwB94">ch</span><span class="w" id="mwB98"> </span><span class="o" id="mwB-A">==</span><span class="w" id="mwB-E"> </span><span class="n" id="mwB-I">getChar</span><span class="p" id="mwB-M">())</span><span class="w" id="mwB-Q"> </span><span class="p" id="mwB-U">{</span> <span class="w" id="mwB-Y"> </span><span class="k" id="mwB-c">if</span><span class="w" id="mwB-g"> </span><span class="p" id="mwB-k">(</span><span class="n" id="mwB-o">ch</span><span class="w" id="mwB-s"> </span><span class="o" id="mwB-w">==</span><span class="w" id="mwB-0"> </span><span class="sc" id="mwB-4">' '</span><span class="p" id="mwB-8">)</span><span class="w" id="mwB_A"> </span><span class="p" id="mwB_E">{</span> <span class="w" id="mwB_I"> </span><span class="k" id="mwB_M">continue</span><span class="p" id="mwB_Q">;</span><span class="w" id="mwB_U"> </span><span class="c1" id="mwB_Y">// Skips the rest of the while-loop</span> <span class="w" id="mwB_c"> </span><span class="p" id="mwB_g">}</span> <span class="w" id="mwB_k"> </span><span class="c1" id="mwB_o">// Rest of the while-loop, will not be reached if ch == ' '</span> <span class="w" id="mwB_s"> </span><span class="n" id="mwB_w">doSomething</span><span class="p" id="mwB_0">();</span> <span class="p" id="mwB_4">}</span>

Labels can be specified in continue statements and break statements:

<span id="mwCAQ"></span><span class="nl" id="mwCAU">outer</span><span class="p" id="mwCAY">:</span> <span class="k" id="mwCAc">for</span><span class="w" id="mwCAg"> </span><span class="p" id="mwCAk">(</span><span class="n" id="mwCAo">String</span><span class="w" id="mwCAs"> </span><span class="n" id="mwCAw">str</span><span class="w" id="mwCA0"> </span><span class="p" id="mwCA4">:</span><span class="w" id="mwCA8"> </span><span class="n" id="mwCBA">stringsArr</span><span class="p" id="mwCBE">)</span><span class="w" id="mwCBI"> </span><span class="p" id="mwCBM">{</span> <span class="w" id="mwCBQ"> </span><span class="kt" id="mwCBU">char</span><span class="o" id="mwCBY">[]</span><span class="w" id="mwCBc"> </span><span class="n" id="mwCBg">strChars</span><span class="w" id="mwCBk"> </span><span class="o" id="mwCBo">=</span><span class="w" id="mwCBs"> </span><span class="n" id="mwCBw">str</span><span class="p" id="mwCB0">.</span><span class="na" id="mwCB4">toCharArray</span><span class="p" id="mwCB8">();</span> <span class="w" id="mwCCA"> </span><span class="k" id="mwCCE">for</span><span class="w" id="mwCCI"> </span><span class="p" id="mwCCM">(</span><span class="kt" id="mwCCQ">char</span><span class="w" id="mwCCU"> </span><span class="n" id="mwCCY">ch</span><span class="w" id="mwCCc"> </span><span class="p" id="mwCCg">:</span><span class="w" id="mwCCk"> </span><span class="n" id="mwCCo">strChars</span><span class="p" id="mwCCs">)</span><span class="w" id="mwCCw"> </span><span class="p" id="mwCC0">{</span> <span class="w" id="mwCC4"> </span><span class="k" id="mwCC8">if</span><span class="w" id="mwCDA"> </span><span class="p" id="mwCDE">(</span><span class="n" id="mwCDI">ch</span><span class="w" id="mwCDM"> </span><span class="o" id="mwCDQ">==</span><span class="w" id="mwCDU"> </span><span class="sc" id="mwCDY">' '</span><span class="p" id="mwCDc">)</span><span class="w" id="mwCDg"> </span><span class="p" id="mwCDk">{</span> <span class="w" id="mwCDo"> </span><span class="cm" id="mwCDs">/* Continues the outer cycle and the next</span> <span class="cm" id="mwCDw"> string is retrieved from stringsArr */</span> <span class="w" id="mwCD0"> </span><span class="k" id="mwCD4">continue</span><span class="w" id="mwCD8"> </span><span class="n" id="mwCEA">outer</span><span class="p" id="mwCEE">;</span> <span class="w" id="mwCEI"> </span><span class="p" id="mwCEM">}</span> <span class="w" id="mwCEQ"> </span><span class="n" id="mwCEU">doSomething</span><span class="p" id="mwCEY">(</span><span class="n" id="mwCEc">ch</span><span class="p" id="mwCEg">);</span> <span class="w" id="mwCEk"> </span><span class="p" id="mwCEo">}</span> <span class="p" id="mwCEs">}</span>

return statement

The return statement is used to end method execution and to return a value. A value returned by the method is written after the return keyword. If the method returns anything but void, it must use the return statement to return some value.

<span id="mwCFU"></span><span class="kt" id="mwCFY">void</span><span class="w" id="mwCFc"> </span><span class="nf" id="mwCFg">doSomething</span><span class="p" id="mwCFk">(</span><span class="kt" id="mwCFo">boolean</span><span class="w" id="mwCFs"> </span><span class="n" id="mwCFw">streamClosed</span><span class="p" id="mwCF0">)</span><span class="w" id="mwCF4"> </span><span class="p" id="mwCF8">{</span> <span class="w" id="mwCGA"> </span><span class="c1" id="mwCGE">// If streamClosed is true, execution is stopped</span> <span class="w" id="mwCGI"> </span><span class="k" id="mwCGM">if</span><span class="w" id="mwCGQ"> </span><span class="p" id="mwCGU">(</span><span class="n" id="mwCGY">streamClosed</span><span class="p" id="mwCGc">)</span><span class="w" id="mwCGg"> </span><span class="p" id="mwCGk">{</span> <span class="w" id="mwCGo"> </span><span class="k" id="mwCGs">return</span><span class="p" id="mwCGw">;</span> <span class="w" id="mwCG0"> </span><span class="p" id="mwCG4">}</span> <span class="w" id="mwCG8"> </span><span class="n" id="mwCHA">readFromStream</span><span class="p" id="mwCHE">();</span> <span class="p" id="mwCHI">}</span> <span class="kt" id="mwCHM">int</span><span class="w" id="mwCHQ"> </span><span class="nf" id="mwCHU">calculateSum</span><span class="p" id="mwCHY">(</span><span class="kt" id="mwCHc">int</span><span class="w" id="mwCHg"> </span><span class="n" id="mwCHk">a</span><span class="p" id="mwCHo">,</span><span class="w" id="mwCHs"> </span><span class="kt" id="mwCHw">int</span><span class="w" id="mwCH0"> </span><span class="n" id="mwCH4">b</span><span class="p" id="mwCH8">)</span><span class="w" id="mwCIA"> </span><span class="p" id="mwCIE">{</span> <span class="w" id="mwCII"> </span><span class="kt" id="mwCIM">int</span><span class="w" id="mwCIQ"> </span><span class="n" id="mwCIU">result</span><span class="w" id="mwCIY"> </span><span class="o" id="mwCIc">=</span><span class="w" id="mwCIg"> </span><span class="n" id="mwCIk">a</span><span class="w" id="mwCIo"> </span><span class="o" id="mwCIs">+</span><span class="w" id="mwCIw"> </span><span class="n" id="mwCI0">b</span><span class="p" id="mwCI4">;</span> <span class="w" id="mwCI8"> </span><span class="k" id="mwCJA">return</span><span class="w" id="mwCJE"> </span><span class="n" id="mwCJI">result</span><span class="p" id="mwCJM">;</span> <span class="p" id="mwCJQ">}</span>

return statement ends execution immediately, except for one case: if the statement is encountered within a try block and it is complemented by a finally, control is passed to the finally block.

<span id="mwCJw"></span><span class="kt" id="mwCJ0">void</span><span class="w" id="mwCJ4"> </span><span class="nf" id="mwCJ8">doSomething</span><span class="p" id="mwCKA">(</span><span class="kt" id="mwCKE">boolean</span><span class="w" id="mwCKI"> </span><span class="n" id="mwCKM">streamClosed</span><span class="p" id="mwCKQ">)</span><span class="w" id="mwCKU"> </span><span class="p" id="mwCKY">{</span> <span class="w" id="mwCKc"> </span><span class="k" id="mwCKg">try</span><span class="w" id="mwCKk"> </span><span class="p" id="mwCKo">{</span> <span class="w" id="mwCKs"> </span><span class="k" id="mwCKw">if</span><span class="w" id="mwCK0"> </span><span class="p" id="mwCK4">(</span><span class="n" id="mwCK8">streamClosed</span><span class="p" id="mwCLA">)</span><span class="w" id="mwCLE"> </span><span class="p" id="mwCLI">{</span> <span class="w" id="mwCLM"> </span><span class="k" id="mwCLQ">return</span><span class="p" id="mwCLU">;</span> <span class="w" id="mwCLY"> </span><span class="p" id="mwCLc">}</span> <span class="w" id="mwCLg"> </span><span class="n" id="mwCLk">readFromStream</span><span class="p" id="mwCLo">();</span> <span class="w" id="mwCLs"> </span><span class="p" id="mwCLw">}</span><span class="w" id="mwCL0"> </span><span class="k" id="mwCL4">finally</span><span class="w" id="mwCL8"> </span><span class="p" id="mwCMA">{</span> <span class="w" id="mwCME"> </span><span class="c1" id="mwCMI">// Will be called last even if readFromStream() was not called</span> <span class="w" id="mwCMM"> </span><span class="n" id="mwCMQ">freeResources</span><span class="p" id="mwCMU">();</span> <span class="w" id="mwCMY"> </span><span class="p" id="mwCMc">}</span> <span class="p" id="mwCMg">}</span>

Exception handling statements

try-catch-finally statements

Exceptions are managed within try-catch blocks.

<span id="mwCNM"></span><span class="k" id="mwCNQ">try</span><span class="w" id="mwCNU"> </span><span class="p" id="mwCNY">{</span> <span class="w" id="mwCNc"> </span><span class="c1" id="mwCNg">// Statements that may throw exceptions</span> <span class="w" id="mwCNk"> </span><span class="n" id="mwCNo">methodThrowingExceptions</span><span class="p" id="mwCNs">();</span> <span class="p" id="mwCNw">}</span><span class="w" id="mwCN0"> </span><span class="k" id="mwCN4">catch</span><span class="w" id="mwCN8"> </span><span class="p" id="mwCOA">(</span><span class="n" id="mwCOE">Exception</span><span class="w" id="mwCOI"> </span><span class="n" id="mwCOM">e</span><span class="p" id="mwCOQ">)</span><span class="w" id="mwCOU"> </span><span class="p" id="mwCOY">{</span> <span class="w" id="mwCOc"> </span><span class="c1" id="mwCOg">// Exception caught and handled here</span> <span class="w" id="mwCOk"> </span><span class="n" id="mwCOo">reportException</span><span class="p" id="mwCOs">(</span><span class="n" id="mwCOw">e</span><span class="p" id="mwCO0">);</span> <span class="p" id="mwCO4">}</span><span class="w" id="mwCO8"> </span><span class="k" id="mwCPA">finally</span><span class="w" id="mwCPE"> </span><span class="p" id="mwCPI">{</span> <span class="w" id="mwCPM"> </span><span class="c1" id="mwCPQ">// Statements always executed after the try/catch blocks</span> <span class="w" id="mwCPU"> </span><span class="n" id="mwCPY">freeResources</span><span class="p" id="mwCPc">();</span> <span class="p" id="mwCPg">}</span>

The statements within the try block are executed, and if any of them throws an exception, execution of the block is discontinued and the exception is handled by the catch block. There may be multiple catch blocks, in which case the first block with an exception variable whose type matches the type of the thrown exception is executed.

Java SE 7 also introduced multi-catch clauses besides uni-catch clauses. This type of catch clauses allows Java to handle different types of exceptions in a single block provided they are not subclasses of each other. While it appears to resemble a union type, it is actually in fact the most specific common supertype of the alternatives.

<span id="mwCQE"></span><span class="kn" id="mwCQI">import</span><span class="w" id="mwCQM"> </span><span class="nn" id="mwCQQ">java.net.HttpRetryException</span><span class="p" id="mwCQU">;</span> <span class="kn" id="mwCQY">import</span><span class="w" id="mwCQc"> </span><span class="nn" id="mwCQg">java.net.http.HttpTimeoutException</span><span class="p" id="mwCQk">;</span> <span class="kt" id="mwCQo">void</span><span class="w" id="mwCQs"> </span><span class="nf" id="mwCQw">makeRequest</span><span class="p" id="mwCQ0">()</span><span class="w" id="mwCQ4"> </span><span class="kd" id="mwCQ8">throws</span><span class="w" id="mwCRA"> </span><span class="n" id="mwCRE">HttpRetryException</span><span class="p" id="mwCRI">,</span><span class="w" id="mwCRM"> </span><span class="n" id="mwCRQ">HttpTimeoutException</span><span class="w" id="mwCRU"> </span><span class="p" id="mwCRY">{</span> <span class="w" id="mwCRc"> </span><span class="c1" id="mwCRg">// ...</span> <span class="p" id="mwCRk">}</span> <span class="kt" id="mwCRo">void</span><span class="w" id="mwCRs"> </span><span class="nf" id="mwCRw">main</span><span class="p" id="mwCR0">(</span><span class="n" id="mwCR4">String</span><span class="o" id="mwCR8">[]</span><span class="w" id="mwCSA"> </span><span class="n" id="mwCSE">args</span><span class="p" id="mwCSI">)</span><span class="w" id="mwCSM"> </span><span class="p" id="mwCSQ">{</span> <span class="w" id="mwCSU"> </span><span class="k" id="mwCSY">try</span><span class="w" id="mwCSc"> </span><span class="p" id="mwCSg">{</span> <span class="w" id="mwCSk"> </span><span class="n" id="mwCSo">methodThrowingExceptions</span><span class="p" id="mwCSs">();</span> <span class="w" id="mwCSw"> </span><span class="p" id="mwCS0">}</span><span class="w" id="mwCS4"> </span><span class="k" id="mwCS8">catch</span><span class="w" id="mwCTA"> </span><span class="p" id="mwCTE">(</span><span class="n" id="mwCTI">HttpRetryException</span><span class="w" id="mwCTM"> </span><span class="o" id="mwCTQ">|</span><span class="w" id="mwCTU"> </span><span class="n" id="mwCTY">HttpTimeoutException</span><span class="w" id="mwCTc"> </span><span class="n" id="mwCTg">e</span><span class="p" id="mwCTk">)</span><span class="w" id="mwCTo"> </span><span class="p" id="mwCTs">{</span> <span class="w" id="mwCTw"> </span><span class="c1" id="mwCT0">// Both HttpRetryException and HttpTimeoutException will be caught and handled here</span> <span class="w" id="mwCT4"> </span><span class="c1" id="mwCT8">// This in fact reduces to just java.io.IOException.</span> <span class="w" id="mwCUA"> </span><span class="n" id="mwCUE">reportException</span><span class="p" id="mwCUI">(</span><span class="n" id="mwCUM">e</span><span class="p" id="mwCUQ">);</span> <span class="w" id="mwCUU"> </span><span class="p" id="mwCUY">}</span> <span class="p" id="mwCUc">}</span>

If no catch block matches the type of the thrown exception, the execution of the outer block (or method) containing the try-catch statement is discontinued, and the exception is passed up and outside the containing block (or method). The exception is propagated upwards through the call stack until a matching catch block is found within one of the currently active methods. If the exception propagates all the way up to the top-most main method without a matching catch block being found, a textual description of the exception is written to the standard output stream.

The statements within the finally block are always executed after the try and catch blocks, whether or not an exception was thrown and even if a return statement was reached. Such blocks are useful for providing cleanup code that is guaranteed to always be executed.

The catch and finally blocks are optional, but at least one or the other must be present following the try block.

try-with-resources statements

try-with-resources statements are a special type of try-catch-finally statements introduced as an implementation of the dispose pattern in Java SE 7. In a try-with-resources statement the try keyword is followed by initialization of one or more resources that are released automatically when the try block execution is finished. Resources must implement java.lang.AutoCloseable. try-with-resources statements are not required to have a catch or finally block unlike normal try-catch-finally statements.

<span id="mwCW0"></span><span class="kn" id="mwCW4">import</span><span class="w" id="mwCW8"> </span><span class="nn" id="mwCXA">java.beans.XMLEncoder</span><span class="p" id="mwCXE">;</span> <span class="kn" id="mwCXI">import</span><span class="w" id="mwCXM"> </span><span class="nn" id="mwCXQ">java.io.FileOutputStream</span><span class="p" id="mwCXU">;</span> <span class="kn" id="mwCXY">import</span><span class="w" id="mwCXc"> </span><span class="nn" id="mwCXg">java.io.IOException</span><span class="p" id="mwCXk">;</span> <span class="kn" id="mwCXo">import</span><span class="w" id="mwCXs"> </span><span class="nn" id="mwCXw">java.util.logging.Level</span><span class="p" id="mwCX0">;</span> <span class="kn" id="mwCX4">import</span><span class="w" id="mwCX8"> </span><span class="nn" id="mwCYA">java.util.logging.Logger</span><span class="p" id="mwCYE">;</span> <span class="k" id="mwCYI">try</span><span class="w" id="mwCYM"> </span><span class="p" id="mwCYQ">(</span><span class="n" id="mwCYU">FileOutputStream</span><span class="w" id="mwCYY"> </span><span class="n" id="mwCYc">fos</span><span class="w" id="mwCYg"> </span><span class="o" id="mwCYk">=</span><span class="w" id="mwCYo"> </span><span class="k" id="mwCYs">new</span><span class="w" id="mwCYw"> </span><span class="n" id="mwCY0">FileOutputStream</span><span class="p" id="mwCY4">(</span><span class="s" id="mwCY8">"filename"</span><span class="p" id="mwCZA">);</span> <span class="w" id="mwCZE"> </span><span class="n" id="mwCZI">XMLEncoder</span><span class="w" id="mwCZM"> </span><span class="n" id="mwCZQ">xEnc</span><span class="w" id="mwCZU"> </span><span class="o" id="mwCZY">=</span><span class="w" id="mwCZc"> </span><span class="k" id="mwCZg">new</span><span class="w" id="mwCZk"> </span><span class="n" id="mwCZo">XMLEncoder</span><span class="p" id="mwCZs">(</span><span class="n" id="mwCZw">fos</span><span class="p" id="mwCZ0">))</span><span class="w" id="mwCZ4"> </span><span class="p" id="mwCZ8">{</span> <span class="w" id="mwCaA"> </span><span class="n" id="mwCaE">xEnc</span><span class="p" id="mwCaI">.</span><span class="na" id="mwCaM">writeObject</span><span class="p" id="mwCaQ">(</span><span class="n" id="mwCaU">object</span><span class="p" id="mwCaY">);</span> <span class="p" id="mwCac">}</span><span class="w" id="mwCag"> </span><span class="k" id="mwCak">catch</span><span class="w" id="mwCao"> </span><span class="p" id="mwCas">(</span><span class="n" id="mwCaw">IOException</span><span class="w" id="mwCa0"> </span><span class="n" id="mwCa4">e</span><span class="p" id="mwCa8">)</span><span class="w" id="mwCbA"> </span><span class="p" id="mwCbE">{</span> <span class="w" id="mwCbI"> </span><span class="n" id="mwCbM">Logger</span><span class="p" id="mwCbQ">.</span><span class="na" id="mwCbU">getLogger</span><span class="p" id="mwCbY">(</span><span class="n" id="mwCbc">Serializer</span><span class="p" id="mwCbg">.</span><span class="na" id="mwCbk">class</span><span class="p" id="mwCbo">.</span><span class="na" id="mwCbs">getName</span><span class="p" id="mwCbw">()).</span><span class="na" id="mwCb0">log</span><span class="p" id="mwCb4">(</span><span class="n" id="mwCb8">Level</span><span class="p" id="mwCcA">.</span><span class="na" id="mwCcE">SEVERE</span><span class="p" id="mwCcI">,</span><span class="w" id="mwCcM"> </span><span class="kc" id="mwCcQ">null</span><span class="p" id="mwCcU">,</span><span class="w" id="mwCcY"> </span><span class="n" id="mwCcc">e</span><span class="p" id="mwCcg">);</span> <span class="p" id="mwCck">}</span>

Since Java 9 it is possible to use already declared variables:

<span id="mwCc0"></span><span class="kn" id="mwCc4">import</span><span class="w" id="mwCc8"> </span><span class="nn" id="mwCdA">java.beans.XMLEncoder</span><span class="p" id="mwCdE">;</span> <span class="kn" id="mwCdI">import</span><span class="w" id="mwCdM"> </span><span class="nn" id="mwCdQ">java.io.FileOutputStream</span><span class="p" id="mwCdU">;</span> <span class="kn" id="mwCdY">import</span><span class="w" id="mwCdc"> </span><span class="nn" id="mwCdg">java.io.IOException</span><span class="p" id="mwCdk">;</span> <span class="kn" id="mwCdo">import</span><span class="w" id="mwCds"> </span><span class="nn" id="mwCdw">java.util.logging.Level</span><span class="p" id="mwCd0">;</span> <span class="kn" id="mwCd4">import</span><span class="w" id="mwCd8"> </span><span class="nn" id="mwCeA">java.util.logging.Logger</span><span class="p" id="mwCeE">;</span> <span class="n" id="mwCeI">FileOutputStream</span><span class="w" id="mwCeM"> </span><span class="n" id="mwCeQ">fos</span><span class="w" id="mwCeU"> </span><span class="o" id="mwCeY">=</span><span class="w" id="mwCec"> </span><span class="k" id="mwCeg">new</span><span class="w" id="mwCek"> </span><span class="n" id="mwCeo">FileOutputStream</span><span class="p" id="mwCes">(</span><span class="s" id="mwCew">"filename"</span><span class="p" id="mwCe0">);</span> <span class="n" id="mwCe4">XMLEncoder</span><span class="w" id="mwCe8"> </span><span class="n" id="mwCfA">xEnc</span><span class="w" id="mwCfE"> </span><span class="o" id="mwCfI">=</span><span class="w" id="mwCfM"> </span><span class="k" id="mwCfQ">new</span><span class="w" id="mwCfU"> </span><span class="n" id="mwCfY">XMLEncoder</span><span class="p" id="mwCfc">(</span><span class="n" id="mwCfg">fos</span><span class="p" id="mwCfk">);</span> <span class="k" id="mwCfo">try</span><span class="w" id="mwCfs"> </span><span class="p" id="mwCfw">(</span><span class="n" id="mwCf0">fos</span><span class="p" id="mwCf4">;</span><span class="w" id="mwCf8"> </span><span class="n" id="mwCgA">xEnc</span><span class="p" id="mwCgE">)</span><span class="w" id="mwCgI"> </span><span class="p" id="mwCgM">{</span> <span class="w" id="mwCgQ"> </span><span class="n" id="mwCgU">xEnc</span><span class="p" id="mwCgY">.</span><span class="na" id="mwCgc">writeObject</span><span class="p" id="mwCgg">(</span><span class="n" id="mwCgk">object</span><span class="p" id="mwCgo">);</span> <span class="p" id="mwCgs">}</span><span class="w" id="mwCgw"> </span><span class="k" id="mwCg0">catch</span><span class="w" id="mwCg4"> </span><span class="p" id="mwCg8">(</span><span class="n" id="mwChA">IOException</span><span class="w" id="mwChE"> </span><span class="n" id="mwChI">e</span><span class="p" id="mwChM">)</span><span class="w" id="mwChQ"> </span><span class="p" id="mwChU">{</span> <span class="w" id="mwChY"> </span><span class="n" id="mwChc">Logger</span><span class="p" id="mwChg">.</span><span class="na" id="mwChk">getLogger</span><span class="p" id="mwCho">(</span><span class="n" id="mwChs">Serializer</span><span class="p" id="mwChw">.</span><span class="na" id="mwCh0">class</span><span class="p" id="mwCh4">.</span><span class="na" id="mwCh8">getName</span><span class="p" id="mwCiA">()).</span><span class="na" id="mwCiE">log</span><span class="p" id="mwCiI">(</span><span class="n" id="mwCiM">Level</span><span class="p" id="mwCiQ">.</span><span class="na" id="mwCiU">SEVERE</span><span class="p" id="mwCiY">,</span><span class="w" id="mwCic"> </span><span class="kc" id="mwCig">null</span><span class="p" id="mwCik">,</span><span class="w" id="mwCio"> </span><span class="n" id="mwCis">e</span><span class="p" id="mwCiw">);</span> <span class="p" id="mwCi0">}</span>

throw statement

The throw statement is used to throw an exception and end the execution of the block or method. The thrown exception instance is written after the throw statement.

<span id="mwCjU"></span><span class="kt" id="mwCjY">void</span><span class="w" id="mwCjc"> </span><span class="nf" id="mwCjg">methodThrowingExceptions</span><span class="p" id="mwCjk">(</span><span class="n" id="mwCjo">Object</span><span class="w" id="mwCjs"> </span><span class="n" id="mwCjw">obj</span><span class="p" id="mwCj0">)</span><span class="w" id="mwCj4"> </span><span class="p" id="mwCj8">{</span> <span class="w" id="mwCkA"> </span><span class="k" id="mwCkE">if</span><span class="w" id="mwCkI"> </span><span class="p" id="mwCkM">(</span><span class="n" id="mwCkQ">obj</span><span class="w" id="mwCkU"> </span><span class="o" id="mwCkY">==</span><span class="w" id="mwCkc"> </span><span class="kc" id="mwCkg">null</span><span class="p" id="mwCkk">)</span><span class="w" id="mwCko"> </span><span class="p" id="mwCks">{</span> <span class="w" id="mwCkw"> </span><span class="c1" id="mwCk0">// Throws exception of NullPointerException type</span> <span class="w" id="mwCk4"> </span><span class="k" id="mwCk8">throw</span><span class="w" id="mwClA"> </span><span class="k" id="mwClE">new</span><span class="w" id="mwClI"> </span><span class="n" id="mwClM">NullPointerException</span><span class="p" id="mwClQ">();</span> <span class="w" id="mwClU"> </span><span class="p" id="mwClY">}</span> <span class="w" id="mwClc"> </span><span class="c1" id="mwClg">// Will not be called, if object is null</span> <span class="w" id="mwClk"> </span><span class="n" id="mwClo">doSomethingWithObject</span><span class="p" id="mwCls">(</span><span class="n" id="mwClw">obj</span><span class="p" id="mwCl0">);</span> <span class="p" id="mwCl4">}</span>

assert statement

assert statements have been available since J2SE 1.4. These types of statements are used to make assertions in the source code, which can be turned on and off during execution for specific classes or packages. To declare an assertion the assert keyword is used followed by a conditional expression. If it evaluates to false when the statement is executed, an error java.lang.AssertionError. This statement can include a colon followed by another expression, which will act as the error's detail message.

<span id="mwCmo"></span><span class="c1" id="mwCms">// If n equals 0, java.lang.AssertionError is thrown</span> <span class="k" id="mwCmw">assert</span><span class="w" id="mwCm0"> </span><span class="n" id="mwCm4">n</span><span class="w" id="mwCm8"> </span><span class="o" id="mwCnA">!=</span><span class="w" id="mwCnE"> </span><span class="mi" id="mwCnI">0</span><span class="p" id="mwCnM">;</span> <span class="cm" id="mwCnQ">/* If n equals 0, java.lang.AssertionError will be thrown</span> <span class="cm" id="mwCnU">with the message after the colon */</span> <span class="k" id="mwCnY">assert</span><span class="w" id="mwCnc"> </span><span class="n" id="mwCng">n</span><span class="w" id="mwCnk"> </span><span class="o" id="mwCno">!=</span><span class="w" id="mwCns"> </span><span class="mi" id="mwCnw">0</span><span class="w" id="mwCn0"> </span><span class="p" id="mwCn4">:</span><span class="w" id="mwCn8"> </span><span class="s" id="mwCoA">"n was equal to zero"</span><span class="p" id="mwCoE">;</span>

Threading

Java offers threads of execution through the class java.lang.Thread. This class takes a java.lang.Runnable (such as a lambda), and are started using the start() method, and paused/blocked using sleep(). For notifying other threads, wait() releases the object lock and pauses the thread until another thread calls notify() or notifyAll().

<span id="mwCpA"></span><span class="n" id="mwCpE">Thread</span><span class="w" id="mwCpI"> </span><span class="n" id="mwCpM">t</span><span class="w" id="mwCpQ"> </span><span class="o" id="mwCpU">=</span><span class="w" id="mwCpY"> </span><span class="k" id="mwCpc">new</span><span class="w" id="mwCpg"> </span><span class="n" id="mwCpk">Thread</span><span class="p" id="mwCpo">(()</span><span class="w" id="mwCps"> </span><span class="o" id="mwCpw">-></span><span class="w" id="mwCp0"> </span><span class="p" id="mwCp4">{</span> <span class="w" id="mwCp8"> </span><span class="n" id="mwCqA">System</span><span class="p" id="mwCqE">.</span><span class="na" id="mwCqI">out</span><span class="p" id="mwCqM">.</span><span class="na" id="mwCqQ">println</span><span class="p" id="mwCqU">(</span><span class="s" id="mwCqY">"Running"</span><span class="p" id="mwCqc">);</span> <span class="p" id="mwCqg">});</span> <span class="n" id="mwCqk">t</span><span class="p" id="mwCqo">.</span><span class="na" id="mwCqs">start</span><span class="p" id="mwCqw">();</span>

Daemon threads are threads which run in the background, for example garbage collectors or monitoring threads. The JVM exits when only daemon threads remain.

The current thread may be accessed with the currentThread() method.

Historically, an error java.lang.ThreadDeath would be thrown upon calling stop() on a thread, however stop() was removed since Java 20, and this error is no longer thrown. The idiomatic way to stop a thread now is with the interrupt() method, where a thread is allowed to finish gracefully rather than immediately stopped without cleanup.

Thread concurrency control

Java has built-in tools for multi-thread programming. For the purposes of thread synchronization the synchronized statement is included in Java language.

To make a code block synchronized, it is preceded by the synchronized keyword followed by the lock object inside the brackets. When the executing thread reaches the synchronized block, it acquires a mutual exclusion lock, executes the block, then releases the lock. No threads may enter this block until the lock is released. Any non-null reference type may be used as the lock.

<span id="mwCsY"></span><span class="cm" id="mwCsc">/* Acquires lock on someObject. It must be of</span> <span class="cm" id="mwCsg">a reference type and must be non-null */</span> <span class="kd" id="mwCsk">synchronized</span><span class="w" id="mwCso"> </span><span class="p" id="mwCss">(</span><span class="n" id="mwCsw">someObject</span><span class="p" id="mwCs0">)</span><span class="w" id="mwCs4"> </span><span class="p" id="mwCs8">{</span> <span class="w" id="mwCtA"> </span><span class="c1" id="mwCtE">// Synchronized statements</span> <span class="p" id="mwCtI">}</span>

Concurrency features

Java offers the library java.util.concurrent, as well as atomicity features (java.util.concurrent.atomic) and locking features (java.util.concurrent.locks).

Rather than java.lang.Thread, another class java.util.concurrent.CompletableFuture<T> is provided for asynchronous computation; this may be seen as similar to a System.Threading.Tasks.Task<T> in C#, even though Java lacks explicit coroutines like those of C#.

As part of Project Loom in Java 21, virtual threads were introduced, which allow for normal, blocking, synchronous code while scaling to millions of tasks. The classic Java thread is called a "platform thread", corresponding roughly to an OS thread, but Java virtual threads are lightweight and managed by the JVM, scheduled onto a small pool of real OS threads. Virtual threads are still java.lang.Thread, but are created with factory methods like ofVirtual(). Although the code is still synchronous and blocking, the physical OS threads are asynchronous; upon stopping to wait, the JVM detaches the code from the physical thread, running other tasks until the OS sends an asynchronous event notification to pick up the code where it left off to finish.

Primitive types

Primitive types in Java include integer types, floating-point numbers, UTF-16 code units and a Boolean type. Unlike C++ and C#, there are no unsigned types in Java except char type, which is used to represent UTF-16 code units. The lack of unsigned types is offset by introducing unsigned right shift operation (>>>), which is not present in C++, methods such as .toUnsignedInt(). Nevertheless, criticisms have been leveled about the lack of compatibility with C and C++ this causes.

null has no type, neither primitive nor class. Any object type may store null.

The class Void is used to hold a reference to the Class object representing the keyword void. It cannot be instantiated as void cannot be the type of any object. For example, CompletableFuture<Void> signifies that a java.util.concurrent.CompletableFuture<T> performs a task that does not return a value.

The class java.lang.Number represents all numeric values which can be converted to byte, double, float, int, long, and short.

char does not necessarily correspond to a single character. It may represent a part of a surrogate pair, in which case Unicode code point is represented by a sequence of two char values.

The wrapper classes contain additional static methods for operations on their primitive types, such as Integer.parseInt(), as well as static constants describing the type's information. The wrapper class java.lang.Character itself contains additional nested types:

• java.lang.Character.Subset, representing a subset of the Unicode character set
• java.lang.Character.UnicodeBlock, containing constants representing a Unicode block
• java.lang.Character.UnicodeScript, an enum of scripts in Unicode

Boxing and unboxing

This language feature was introduced in J2SE 5.0. Boxing is the operation of converting a value of a primitive type into a value of a corresponding reference type, which serves as a wrapper for this particular primitive type. Unboxing is the reverse operation of converting a value of a reference type (previously boxed) into a value of a corresponding primitive type. Neither operation requires an explicit conversion.

Example:

<span id="mwDAI"></span><span class="kt" id="mwDAM">int</span><span class="w" id="mwDAQ"> </span><span class="n" id="mwDAU">foo</span><span class="w" id="mwDAY"> </span><span class="o" id="mwDAc">=</span><span class="w" id="mwDAg"> </span><span class="mi" id="mwDAk">42</span><span class="p" id="mwDAo">;</span><span class="w" id="mwDAs"> </span><span class="c1" id="mwDAw">// Primitive type</span> <span class="n" id="mwDA0">Integer</span><span class="w" id="mwDA4"> </span><span class="n" id="mwDA8">bar</span><span class="w" id="mwDBA"> </span><span class="o" id="mwDBE">=</span><span class="w" id="mwDBI"> </span><span class="n" id="mwDBM">foo</span><span class="p" id="mwDBQ">;</span><span class="w" id="mwDBU"> </span><span class="cm" id="mwDBY">/* foo is boxed to bar, bar is of Integer type,</span> <span class="cm" id="mwDBc"> which serves as a wrapper for int */</span> <span class="kt" id="mwDBg">int</span><span class="w" id="mwDBk"> </span><span class="n" id="mwDBo">foo2</span><span class="w" id="mwDBs"> </span><span class="o" id="mwDBw">=</span><span class="w" id="mwDB0"> </span><span class="n" id="mwDB4">bar</span><span class="p" id="mwDB8">;</span><span class="w" id="mwDCA"> </span><span class="c1" id="mwDCE">// Unboxed back to primitive type</span>

Reference types

Reference types include class types, interface types, and array types. When the constructor is called, an object is created on the heap and a reference is assigned to the variable. When a variable of an object gets out of scope, the reference is broken and when there are no references left, the object gets marked as garbage. The garbage collector then collects and destroys it some time afterwards.

A reference variable is null when it does not reference any object.

Arrays

Arrays in Java are created at runtime, just like class instances. Array length is defined at creation and cannot be changed.

<span id="mwDCo"></span><span class="kt" id="mwDCs">int</span><span class="o" id="mwDCw">[]</span><span class="w" id="mwDC0"> </span><span class="n" id="mwDC4">numbers</span><span class="w" id="mwDC8"> </span><span class="o" id="mwDDA">=</span><span class="w" id="mwDDE"> </span><span class="k" id="mwDDI">new</span><span class="w" id="mwDDM"> </span><span class="kt" id="mwDDQ">int</span><span class="o" id="mwDDU">[</span><span class="mi" id="mwDDY">5</span><span class="o" id="mwDDc">]</span><span class="p" id="mwDDg">;</span> <span class="n" id="mwDDk">numbers</span><span class="o" id="mwDDo">[</span><span class="mi" id="mwDDs">0</span><span class="o" id="mwDDw">]</span><span class="w" id="mwDD0"> </span><span class="o" id="mwDD4">=</span><span class="w" id="mwDD8"> </span><span class="mi" id="mwDEA">2</span><span class="p" id="mwDEE">;</span> <span class="n" id="mwDEI">numbers</span><span class="o" id="mwDEM">[</span><span class="mi" id="mwDEQ">1</span><span class="o" id="mwDEU">]</span><span class="w" id="mwDEY"> </span><span class="o" id="mwDEc">=</span><span class="w" id="mwDEg"> </span><span class="mi" id="mwDEk">5</span><span class="p" id="mwDEo">;</span> <span class="kt" id="mwDEs">int</span><span class="w" id="mwDEw"> </span><span class="n" id="mwDE0">x</span><span class="w" id="mwDE4"> </span><span class="o" id="mwDE8">=</span><span class="w" id="mwDFA"> </span><span class="n" id="mwDFE">numbers</span><span class="o" id="mwDFI">[</span><span class="mi" id="mwDFM">0</span><span class="o" id="mwDFQ">]</span><span class="p" id="mwDFU">;</span> <span class="kt" id="mwDFY">int</span><span class="w" id="mwDFc"> </span><span class="n" id="mwDFg">len</span><span class="w" id="mwDFk"> </span><span class="o" id="mwDFo">=</span><span class="w" id="mwDFs"> </span><span class="n" id="mwDFw">numbers</span><span class="p" id="mwDF0">.</span><span class="na" id="mwDF4">length</span><span class="p" id="mwDF8">;</span><span class="w" id="mwDGA"> </span><span class="c1" id="mwDGE">// len = 5</span>

C-style declarations of arrays are also accepted in Java, but are not commonly used.

<span id="mwDGY"></span><span class="kt" id="mwDGc">int</span><span class="w" id="mwDGg"> </span><span class="n" id="mwDGk">arr</span><span class="o" id="mwDGo">[]</span><span class="w" id="mwDGs"> </span><span class="o" id="mwDGw">=</span><span class="w" id="mwDG0"> </span><span class="k" id="mwDG4">new</span><span class="w" id="mwDG8"> </span><span class="kt" id="mwDHA">int</span><span class="o" id="mwDHE">[</span><span class="mi" id="mwDHI">10</span><span class="o" id="mwDHM">]</span><span class="p" id="mwDHQ">;</span>

Arrays are represented in the JVM with an opening left squared bracket for every dimension of the array, with the following letters:

• B, for byte
• C, for char
• D, for double
• F, for float
• I, for int
• J, for long
• S, for short
• Z, for boolean
• L, for any reference (non-primitive) type, followed by the fully qualified class name and then a closing semicolon

For example, int[][] becomes [[I and String[] becomes [Ljava.lang.String;.

void does not exist as a type in memory, but it is represented internally with the letter V.

Arrays are limited to a maximum of 255 dimensions. The theoretical maximum length of an array is ${\displaystyle 2^{31}-1}$ (2,147,483,647, equivalent to Integer.MAX_VALUE), because arrays can only be addressed with 32-bit indices, but this limit is typically system and virtual machine dependent.

The classes java.util.Arrays and java.lang.reflect.Array are provided for array manipulation and reflective operations on arrays, respectively.

Arrays appear to have a field length, but it is not a real field; it is a built-in property evaluated natively by the arraylength bytecode instruction. Arrays have no declared members, methods or constructors (other than those inherited from java.lang.Object).

Arrays inherit the class java.lang.Object and implement the interfaces java.lang.Cloneable and java.io.Serializable. Arrays are implicitly final, and cannot be inherited from. Despite being classes, there are no .class file for arrays because they are created directly in memory during execution, have no physical bytecode representation, and are not loaded by a class loader.

Because arrays are reference types, they may be used directly in generic type parameters.

<span id="mwDM0"></span><span class="kn" id="mwDM4">import</span><span class="w" id="mwDM8"> </span><span class="nn" id="mwDNA">java.util.ArrayList</span><span class="p" id="mwDNE">;</span> <span class="kn" id="mwDNI">import</span><span class="w" id="mwDNM"> </span><span class="nn" id="mwDNQ">java.util.List</span><span class="p" id="mwDNU">;</span> <span class="n" id="mwDNY">List</span><span class="o" id="mwDNc"><</span><span class="kt" id="mwDNg">int</span><span class="o" id="mwDNk">[]></span><span class="w" id="mwDNo"> </span><span class="n" id="mwDNs">frequencies</span><span class="w" id="mwDNw"> </span><span class="o" id="mwDN0">=</span><span class="w" id="mwDN4"> </span><span class="k" id="mwDN8">new</span><span class="w" id="mwDOA"> </span><span class="n" id="mwDOE">ArrayList</span><span class="o" id="mwDOI"><></span><span class="p" id="mwDOM">();</span>

Initializers

<span id="mwDOc"></span><span class="c1" id="mwDOg">// Long syntax</span> <span class="kt" id="mwDOk">int</span><span class="o" id="mwDOo">[]</span><span class="w" id="mwDOs"> </span><span class="n" id="mwDOw">numbers</span><span class="w" id="mwDO0"> </span><span class="o" id="mwDO4">=</span><span class="w" id="mwDO8"> </span><span class="k" id="mwDPA">new</span><span class="w" id="mwDPE"> </span><span class="kt" id="mwDPI">int</span><span class="o" id="mwDPM">[]</span><span class="w" id="mwDPQ"> </span><span class="p" id="mwDPU">{</span><span class="mi" id="mwDPY">20</span><span class="p" id="mwDPc">,</span><span class="w" id="mwDPg"> </span><span class="mi" id="mwDPk">1</span><span class="p" id="mwDPo">,</span><span class="w" id="mwDPs"> </span><span class="mi" id="mwDPw">42</span><span class="p" id="mwDP0">,</span><span class="w" id="mwDP4"> </span><span class="mi" id="mwDP8">15</span><span class="p" id="mwDQA">,</span><span class="w" id="mwDQE"> </span><span class="mi" id="mwDQI">34</span><span class="p" id="mwDQM">};</span> <span class="c1" id="mwDQQ">// Short syntax</span> <span class="kt" id="mwDQU">int</span><span class="o" id="mwDQY">[]</span><span class="w" id="mwDQc"> </span><span class="n" id="mwDQg">numbers2</span><span class="w" id="mwDQk"> </span><span class="o" id="mwDQo">=</span><span class="w" id="mwDQs"> </span><span class="p" id="mwDQw">{</span><span class="mi" id="mwDQ0">20</span><span class="p" id="mwDQ4">,</span><span class="w" id="mwDQ8"> </span><span class="mi" id="mwDRA">1</span><span class="p" id="mwDRE">,</span><span class="w" id="mwDRI"> </span><span class="mi" id="mwDRM">42</span><span class="p" id="mwDRQ">,</span><span class="w" id="mwDRU"> </span><span class="mi" id="mwDRY">15</span><span class="p" id="mwDRc">,</span><span class="w" id="mwDRg"> </span><span class="mi" id="mwDRk">34</span><span class="p" id="mwDRo">};</span>

Multi-dimensional arrays

In Java, multi-dimensional arrays are represented as arrays of arrays. Technically, they are represented by arrays of references to other arrays.

<span id="mwDR8"></span><span class="kt" id="mwDSA">int</span><span class="o" id="mwDSE">[][]</span><span class="w" id="mwDSI"> </span><span class="n" id="mwDSM">numbers</span><span class="w" id="mwDSQ"> </span><span class="o" id="mwDSU">=</span><span class="w" id="mwDSY"> </span><span class="k" id="mwDSc">new</span><span class="w" id="mwDSg"> </span><span class="kt" id="mwDSk">int</span><span class="o" id="mwDSo">[</span><span class="mi" id="mwDSs">3</span><span class="o" id="mwDSw">][</span><span class="mi" id="mwDS0">3</span><span class="o" id="mwDS4">]</span><span class="p" id="mwDS8">;</span> <span class="n" id="mwDTA">numbers</span><span class="o" id="mwDTE">[</span><span class="mi" id="mwDTI">1</span><span class="o" id="mwDTM">][</span><span class="mi" id="mwDTQ">2</span><span class="o" id="mwDTU">]</span><span class="w" id="mwDTY"> </span><span class="o" id="mwDTc">=</span><span class="w" id="mwDTg"> </span><span class="mi" id="mwDTk">2</span><span class="p" id="mwDTo">;</span> <span class="kt" id="mwDTs">int</span><span class="o" id="mwDTw">[][]</span><span class="w" id="mwDT0"> </span><span class="n" id="mwDT4">numbers2</span><span class="w" id="mwDT8"> </span><span class="o" id="mwDUA">=</span><span class="w" id="mwDUE"> </span><span class="p" id="mwDUI">{{</span><span class="mi" id="mwDUM">2</span><span class="p" id="mwDUQ">,</span><span class="w" id="mwDUU"> </span><span class="mi" id="mwDUY">3</span><span class="p" id="mwDUc">,</span><span class="w" id="mwDUg"> </span><span class="mi" id="mwDUk">2</span><span class="p" id="mwDUo">},</span><span class="w" id="mwDUs"> </span><span class="p" id="mwDUw">{</span><span class="mi" id="mwDU0">1</span><span class="p" id="mwDU4">,</span><span class="w" id="mwDU8"> </span><span class="mi" id="mwDVA">2</span><span class="p" id="mwDVE">,</span><span class="w" id="mwDVI"> </span><span class="mi" id="mwDVM">6</span><span class="p" id="mwDVQ">},</span><span class="w" id="mwDVU"> </span><span class="p" id="mwDVY">{</span><span class="mi" id="mwDVc">2</span><span class="p" id="mwDVg">,</span><span class="w" id="mwDVk"> </span><span class="mi" id="mwDVo">4</span><span class="p" id="mwDVs">,</span><span class="w" id="mwDVw"> </span><span class="mi" id="mwDV0">5</span><span class="p" id="mwDV4">}};</span>

Due to the nature of the multi-dimensional arrays, sub-arrays can vary in length, so multi-dimensional arrays are not bound to be rectangular unlike C:

<span id="mwDWI"></span><span class="kt" id="mwDWM">int</span><span class="o" id="mwDWQ">[][]</span><span class="w" id="mwDWU"> </span><span class="n" id="mwDWY">numbers</span><span class="w" id="mwDWc"> </span><span class="o" id="mwDWg">=</span><span class="w" id="mwDWk"> </span><span class="k" id="mwDWo">new</span><span class="w" id="mwDWs"> </span><span class="kt" id="mwDWw">int</span><span class="o" id="mwDW0">[</span><span class="mi" id="mwDW4">2</span><span class="o" id="mwDW8">][]</span><span class="p" id="mwDXA">;</span><span class="w" id="mwDXE"> </span><span class="c1" id="mwDXI">// Initialization of the first dimension only</span> <span class="n" id="mwDXM">numbers</span><span class="o" id="mwDXQ">[</span><span class="mi" id="mwDXU">0</span><span class="o" id="mwDXY">]</span><span class="w" id="mwDXc"> </span><span class="o" id="mwDXg">=</span><span class="w" id="mwDXk"> </span><span class="k" id="mwDXo">new</span><span class="w" id="mwDXs"> </span><span class="kt" id="mwDXw">int</span><span class="o" id="mwDX0">[</span><span class="mi" id="mwDX4">3</span><span class="o" id="mwDX8">]</span><span class="p" id="mwDYA">;</span> <span class="n" id="mwDYE">numbers</span><span class="o" id="mwDYI">[</span><span class="mi" id="mwDYM">1</span><span class="o" id="mwDYQ">]</span><span class="w" id="mwDYU"> </span><span class="o" id="mwDYY">=</span><span class="w" id="mwDYc"> </span><span class="k" id="mwDYg">new</span><span class="w" id="mwDYk"> </span><span class="kt" id="mwDYo">int</span><span class="o" id="mwDYs">[</span><span class="mi" id="mwDYw">2</span><span class="o" id="mwDY0">]</span><span class="p" id="mwDY4">;</span>

Classes

Classes are fundamentals of an object-oriented language such as Java. They contain members that store and manipulate data. Classes are divided into top-level and nested. Nested classes are classes placed inside another class that may access the private members of the enclosing class. Nested classes include member classes (which may be defined with the static modifier for simple nesting or without it for inner classes), local classes and anonymous classes.

Declaration

Instantiation

Non-static members of a class define the types of the instance variables and methods, which are related to the objects created from that class. To create these objects, the class must be instantiated by using the new operator and calling the class constructor.

<span id="mwDhs"></span><span class="n" id="mwDhw">Foo</span><span class="w" id="mwDh0"> </span><span class="n" id="mwDh4">foo</span><span class="w" id="mwDh8"> </span><span class="o" id="mwDiA">=</span><span class="w" id="mwDiE"> </span><span class="k" id="mwDiI">new</span><span class="w" id="mwDiM"> </span><span class="n" id="mwDiQ">Foo</span><span class="p" id="mwDiU">();</span>

Accessing members

Members of both instances and static classes are accessed with the . (dot) operator.

Accessing an instance member
Instance members can be accessed through the name of a variable.

<span id="mwDi4"></span><span class="n" id="mwDi8">String</span><span class="w" id="mwDjA"> </span><span class="n" id="mwDjE">foo</span><span class="w" id="mwDjI"> </span><span class="o" id="mwDjM">=</span><span class="w" id="mwDjQ"> </span><span class="s" id="mwDjU">"Hello"</span><span class="p" id="mwDjY">;</span> <span class="n" id="mwDjc">String</span><span class="w" id="mwDjg"> </span><span class="n" id="mwDjk">bar</span><span class="w" id="mwDjo"> </span><span class="o" id="mwDjs">=</span><span class="w" id="mwDjw"> </span><span class="n" id="mwDj0">foo</span><span class="p" id="mwDj4">.</span><span class="na" id="mwDj8">toUpperCase</span><span class="p" id="mwDkA">();</span>

Accessing a static class member
Static members are accessed by using the name of the class or any other type. This does not require the creation of a class instance. Static members are declared using the static modifier.

<span id="mwDkc"></span><span class="kd" id="mwDkg">public</span><span class="w" id="mwDkk"> </span><span class="kd" id="mwDko">class</span> <span class="nc" id="mwDks">Foo</span><span class="w" id="mwDkw"> </span><span class="p" id="mwDk0">{</span> <span class="w" id="mwDk4"> </span><span class="kd" id="mwDk8">public</span><span class="w" id="mwDlA"> </span><span class="kd" id="mwDlE">static</span><span class="w" id="mwDlI"> </span><span class="kt" id="mwDlM">void</span><span class="w" id="mwDlQ"> </span><span class="nf" id="mwDlU">doSomething</span><span class="p" id="mwDlY">()</span><span class="w" id="mwDlc"> </span><span class="p" id="mwDlg">{</span> <span class="w" id="mwDlk"> </span><span class="c1" id="mwDlo">// ...</span> <span class="w" id="mwDls"> </span><span class="p" id="mwDlw">}</span> <span class="p" id="mwDl0">}</span> <span class="c1" id="mwDl4">// Calling the static method</span> <span class="n" id="mwDl8">Foo</span><span class="p" id="mwDmA">.</span><span class="na" id="mwDmE">doSomething</span><span class="p" id="mwDmI">();</span>

Modifiers

Modifiers are keywords used to modify declarations of types and type members. Most notably there is a sub-group containing the access modifiers.

• abstract - Specifies that a class only serves as a base class and cannot be instantiated.
• static - Used only for member classes, specifies that the member class does not belong to a specific instance of the containing class.
• final - Classes marked as final cannot be extended from and cannot have any subclasses.
• strictfp - Specifies that all floating-point operations must be carried out conforming to IEEE 754 and forbids using enhanced precision to store intermediate results.

Abstract class

By default, all methods in all classes are concrete, unless the abstract keyword is used. An abstract class may include abstract methods, which have no implementation. By default, all methods in all interfaces are abstract, unless the default keyword is used. The default keyword can be used to specify a concrete method in an interface.

<span id="mwDng"></span><span class="c1" id="mwDnk">// By default, all methods in all classes are concrete, unless the abstract keyword is used.</span> <span class="kd" id="mwDno">abstract</span><span class="w" id="mwDns"> </span><span class="kd" id="mwDnw">class</span> <span class="nc" id="mwDn0">Demo</span><span class="w" id="mwDn4"> </span><span class="p" id="mwDn8">{</span> <span class="w" id="mwDoA"> </span><span class="c1" id="mwDoE">// An abstract class may include abstract methods, which have no implementation.</span> <span class="w" id="mwDoI"> </span><span class="kd" id="mwDoM">public</span><span class="w" id="mwDoQ"> </span><span class="kd" id="mwDoU">abstract</span><span class="w" id="mwDoY"> </span><span class="kt" id="mwDoc">int</span><span class="w" id="mwDog"> </span><span class="nf" id="mwDok">sum</span><span class="p" id="mwDoo">(</span><span class="kt" id="mwDos">int</span><span class="w" id="mwDow"> </span><span class="n" id="mwDo0">x</span><span class="p" id="mwDo4">,</span><span class="w" id="mwDo8"> </span><span class="kt" id="mwDpA">int</span><span class="w" id="mwDpE"> </span><span class="n" id="mwDpI">y</span><span class="p" id="mwDpM">);</span> <span class="w" id="mwDpQ"> </span><span class="c1" id="mwDpU">// An abstract class may also include concrete methods.</span> <span class="w" id="mwDpY"> </span><span class="kd" id="mwDpc">public</span><span class="w" id="mwDpg"> </span><span class="kt" id="mwDpk">int</span><span class="w" id="mwDpo"> </span><span class="nf" id="mwDps">product</span><span class="p" id="mwDpw">(</span><span class="kt" id="mwDp0">int</span><span class="w" id="mwDp4"> </span><span class="n" id="mwDp8">x</span><span class="p" id="mwDqA">,</span><span class="w" id="mwDqE"> </span><span class="kt" id="mwDqI">int</span><span class="w" id="mwDqM"> </span><span class="n" id="mwDqQ">y</span><span class="p" id="mwDqU">)</span><span class="w" id="mwDqY"> </span><span class="p" id="mwDqc">{</span><span class="w" id="mwDqg"> </span> <span class="w" id="mwDqk"> </span><span class="k" id="mwDqo">return</span><span class="w" id="mwDqs"> </span><span class="n" id="mwDqw">x</span><span class="w" id="mwDq0"> </span><span class="o" id="mwDq4">*</span><span class="w" id="mwDq8"> </span><span class="n" id="mwDrA">y</span><span class="p" id="mwDrE">;</span><span class="w" id="mwDrI"> </span> <span class="w" id="mwDrM"> </span><span class="p" id="mwDrQ">}</span> <span class="p" id="mwDrU">}</span> <span class="c1" id="mwDrY">// By default, all methods in all interfaces are abstract, unless the default keyword is used.</span> <span class="kd" id="mwDrc">interface</span> <span class="nc" id="mwDrg">DemoInterface</span><span class="w" id="mwDrk"> </span><span class="p" id="mwDro">{</span> <span class="w" id="mwDrs"> </span><span class="kt" id="mwDrw">int</span><span class="w" id="mwDr0"> </span><span class="nf" id="mwDr4">getLength</span><span class="p" id="mwDr8">();</span><span class="w" id="mwDsA"> </span><span class="c1" id="mwDsE">// The abstract keyword can be used here, though is completely useless</span> <span class="w" id="mwDsI"> </span> <span class="w" id="mwDsM"> </span><span class="c1" id="mwDsQ">// The default keyword can be used in this context to specify a concrete method in an interface</span> <span class="w" id="mwDsU"> </span><span class="k" id="mwDsY">default</span><span class="w" id="mwDsc"> </span><span class="kt" id="mwDsg">int</span><span class="w" id="mwDsk"> </span><span class="nf" id="mwDso">product</span><span class="p" id="mwDss">(</span><span class="kt" id="mwDsw">int</span><span class="w" id="mwDs0"> </span><span class="n" id="mwDs4">x</span><span class="p" id="mwDs8">,</span><span class="w" id="mwDtA"> </span><span class="kt" id="mwDtE">int</span><span class="w" id="mwDtI"> </span><span class="n" id="mwDtM">y</span><span class="p" id="mwDtQ">)</span><span class="w" id="mwDtU"> </span><span class="p" id="mwDtY">{</span> <span class="w" id="mwDtc"> </span><span class="k" id="mwDtg">return</span><span class="w" id="mwDtk"> </span><span class="n" id="mwDto">x</span><span class="w" id="mwDts"> </span><span class="o" id="mwDtw">*</span><span class="w" id="mwDt0"> </span><span class="n" id="mwDt4">y</span><span class="p" id="mwDt8">;</span> <span class="w" id="mwDuA"> </span><span class="p" id="mwDuE">}</span> <span class="p" id="mwDuI">}</span>

Final class

A final class cannot be subclassed. As doing this can confer security and efficiency benefits, many of the Java standard library classes are final, such as java.lang.System and java.lang.String.

Example:

<span id="mwDuc"></span><span class="kd" id="mwDug">final</span><span class="w" id="mwDuk"> </span><span class="kd" id="mwDuo">class</span> <span class="nc" id="mwDus">Final</span><span class="w" id="mwDuw"> </span><span class="p" id="mwDu0">{</span> <span class="w" id="mwDu4"> </span><span class="c1" id="mwDu8">// ...</span> <span class="p" id="mwDvA">}</span> <span class="c1" id="mwDvE">// Forbidden</span> <span class="kd" id="mwDvI">class</span> <span class="nc" id="mwDvM">Derived</span><span class="w" id="mwDvQ"> </span><span class="kd" id="mwDvU">extends</span><span class="w" id="mwDvY"> </span><span class="n" id="mwDvc">Final</span><span class="w" id="mwDvg"> </span><span class="p" id="mwDvk">{</span> <span class="w" id="mwDvo"> </span><span class="c1" id="mwDvs">// ...</span> <span class="p" id="mwDvw">}</span>

Access modifiers

The access modifiers, or inheritance modifiers, set the accessibility of classes, methods, and other members. Members marked as public can be reached from anywhere. If a class or its member does not have any modifiers, default access is assumed.

<span id="mwDwQ"></span><span class="kd" id="mwDwU">public</span><span class="w" id="mwDwY"> </span><span class="kd" id="mwDwc">class</span> <span class="nc" id="mwDwg">Foo</span><span class="w" id="mwDwk"> </span><span class="p" id="mwDwo">{</span> <span class="w" id="mwDws"> </span><span class="kt" id="mwDww">int</span><span class="w" id="mwDw0"> </span><span class="nf" id="mwDw4">baz</span><span class="p" id="mwDw8">()</span><span class="w" id="mwDxA"> </span><span class="p" id="mwDxE">{</span> <span class="w" id="mwDxI"> </span><span class="k" id="mwDxM">return</span><span class="w" id="mwDxQ"> </span><span class="mi" id="mwDxU">0</span><span class="p" id="mwDxY">;</span> <span class="w" id="mwDxc"> </span><span class="p" id="mwDxg">}</span> <span class="w" id="mwDxk"> </span><span class="kd" id="mwDxo">private</span><span class="w" id="mwDxs"> </span><span class="kd" id="mwDxw">class</span> <span class="nc" id="mwDx0">Bar</span><span class="w" id="mwDx4"> </span><span class="p" id="mwDx8">{</span> <span class="w" id="mwDyA"> </span><span class="p" id="mwDyE">}</span> <span class="p" id="mwDyI">}</span>

The following table shows whether code within a class has access to the class or method depending on the accessing class location and the modifier for the accessed class or class member:

Constructors and initializers

A constructor is a special method-like block called when an object is initialized. Its purpose is to initialize the members of the object. The main differences between constructors and ordinary methods are that constructors are called only when an instance of the class is created and never return anything. Constructors are declared in such a way that resembles a method, but they are named after the class and no return type is specified; for a class X, a constructor is X(...); in particular, a default constructor has no parameters, X().

<span id="mwD1Q"></span><span class="kd" id="mwD1U">class</span> <span class="nc" id="mwD1Y">Foo</span><span class="w" id="mwD1c"> </span><span class="p" id="mwD1g">{</span> <span class="w" id="mwD1k"> </span><span class="n" id="mwD1o">String</span><span class="w" id="mwD1s"> </span><span class="n" id="mwD1w">str</span><span class="p" id="mwD10">;</span> <span class="w" id="mwD14"> </span><span class="c1" id="mwD18">// Constructor with no arguments</span> <span class="w" id="mwD2A"> </span><span class="n" id="mwD2E">Foo</span><span class="p" id="mwD2I">()</span><span class="w" id="mwD2M"> </span><span class="p" id="mwD2Q">{}</span> <span class="w" id="mwD2U"> </span><span class="c1" id="mwD2Y">// Constructor with one argument</span> <span class="w" id="mwD2c"> </span><span class="n" id="mwD2g">Foo</span><span class="p" id="mwD2k">(</span><span class="n" id="mwD2o">String</span><span class="w" id="mwD2s"> </span><span class="n" id="mwD2w">str</span><span class="p" id="mwD20">)</span><span class="w" id="mwD24"> </span><span class="p" id="mwD28">{</span> <span class="w" id="mwD3A"> </span><span class="k" id="mwD3E">this</span><span class="p" id="mwD3I">.</span><span class="na" id="mwD3M">str</span><span class="w" id="mwD3Q"> </span><span class="o" id="mwD3U">=</span><span class="w" id="mwD3Y"> </span><span class="n" id="mwD3c">str</span><span class="p" id="mwD3g">;</span> <span class="w" id="mwD3k"> </span><span class="p" id="mwD3o">}</span> <span class="p" id="mwD3s">}</span>

A constructor appears to resemble a method, but are in fact instance initialization blocks, and cannot be invoked directly by a method call (unlike in C++, where constructors are considered special member functions). Despite this, in the JVM bytecode, a constructor appears under the name <init> and is called an "instance initialization method", and are marked void (and therefore do not push any resulting object onto the JVM's operand stack upon completing execution).

Initializers are blocks of code that are executed when a class or an instance of a class is created. There are two kinds of initializers, static initializers and instance initializers.

Static initializers initialize static fields when the class is created. They are declared using the static keyword:

<span id="mwD5E"></span><span class="kd" id="mwD5I">class</span> <span class="nc" id="mwD5M">Foo</span><span class="w" id="mwD5Q"> </span><span class="p" id="mwD5U">{</span> <span class="w" id="mwD5Y"> </span><span class="kd" id="mwD5c">static</span><span class="w" id="mwD5g"> </span><span class="p" id="mwD5k">{</span> <span class="w" id="mwD5o"> </span><span class="c1" id="mwD5s">// Initialization</span> <span class="w" id="mwD5w"> </span><span class="p" id="mwD50">}</span> <span class="p" id="mwD54">}</span>

A class is created only once. Therefore, static initializers are not called more than once. On the contrary, instance initializers are automatically called before the call to a constructor every time an instance of the class is created. Unlike constructors instance initializers cannot take any arguments and generally they cannot throw any checked exceptions (except in several special cases). Instance initializers are declared in a block without any keywords:

<span id="mwD6M"></span><span class="kd" id="mwD6Q">class</span> <span class="nc" id="mwD6U">Foo</span><span class="w" id="mwD6Y"> </span><span class="p" id="mwD6c">{</span> <span class="w" id="mwD6g"> </span><span class="p" id="mwD6k">{</span> <span class="w" id="mwD6o"> </span><span class="c1" id="mwD6s">// Initialization</span> <span class="w" id="mwD6w"> </span><span class="p" id="mwD60">}</span> <span class="p" id="mwD64">}</span>

Since Java relies on a garbage collection mechanism, there are no destructors ~X() or delete operator. However, every object has a finalize() method called prior to garbage collection, which can be overridden to implement finalization. However, there are no guarantees which thread will invoke the finalize() method for any given object, or even that it will be invoked at all. Finalizers are non-deterministic (unlike destructors in C++), and releasing critical resources in a finalize() call may lead to unpredictable behavior. Another class, java.lang.ref.Cleaner, introduced in Java 9, is additionally provided for lower-level safety nets for reclaiming non-memory resources, such as native pointers, file descriptors, or sockets.

Methods

All the statements in Java must reside within methods. Methods are similar to functions except they belong to classes. A method has a return value, a name and usually some parameters initialized when it is called with some arguments. Similar to C++, methods returning nothing have return type declared as void. Unlike in C++, methods in Java are not allowed to have default argument values and methods are usually overloaded instead.

<span id="mwD8c"></span><span class="kd" id="mwD8g">class</span> <span class="nc" id="mwD8k">Foo</span><span class="w" id="mwD8o"> </span><span class="p" id="mwD8s">{</span> <span class="w" id="mwD8w"> </span><span class="kt" id="mwD80">int</span><span class="w" id="mwD84"> </span><span class="nf" id="mwD88">bar</span><span class="p" id="mwD9A">(</span><span class="kt" id="mwD9E">int</span><span class="w" id="mwD9I"> </span><span class="n" id="mwD9M">a</span><span class="p" id="mwD9Q">,</span><span class="w" id="mwD9U"> </span><span class="kt" id="mwD9Y">int</span><span class="w" id="mwD9c"> </span><span class="n" id="mwD9g">b</span><span class="p" id="mwD9k">)</span><span class="w" id="mwD9o"> </span><span class="p" id="mwD9s">{</span> <span class="w" id="mwD9w"> </span><span class="k" id="mwD90">return</span><span class="w" id="mwD94"> </span><span class="p" id="mwD98">(</span><span class="n" id="mwD-A">a</span><span class="w" id="mwD-E"> </span><span class="o" id="mwD-I">*</span><span class="w" id="mwD-M"> </span><span class="mi" id="mwD-Q">2</span><span class="p" id="mwD-U">)</span><span class="w" id="mwD-Y"> </span><span class="o" id="mwD-c">+</span><span class="w" id="mwD-g"> </span><span class="n" id="mwD-k">b</span><span class="p" id="mwD-o">;</span> <span class="w" id="mwD-s"> </span><span class="p" id="mwD-w">}</span> <span class="w" id="mwD-0"> </span><span class="c1" id="mwD-4">// Overloaded method with the same name but different set of arguments</span> <span class="w" id="mwD-8"> </span><span class="kt" id="mwD_A">int</span><span class="w" id="mwD_E"> </span><span class="nf" id="mwD_I">bar</span><span class="p" id="mwD_M">(</span><span class="kt" id="mwD_Q">int</span><span class="w" id="mwD_U"> </span><span class="n" id="mwD_Y">a</span><span class="p" id="mwD_c">)</span><span class="w" id="mwD_g"> </span><span class="p" id="mwD_k">{</span> <span class="w" id="mwD_o"> </span><span class="k" id="mwD_s">return</span><span class="w" id="mwD_w"> </span><span class="n" id="mwD_0">a</span><span class="w" id="mwD_4"> </span><span class="o" id="mwD_8">*</span><span class="w" id="mwEAA"> </span><span class="mi" id="mwEAE">2</span><span class="p" id="mwEAI">;</span> <span class="w" id="mwEAM"> </span><span class="p" id="mwEAQ">}</span> <span class="p" id="mwEAU">}</span>

A method is called using . notation on an object, or in the case of a static method, also on the name of a class.

<span id="mwEAo"></span><span class="n" id="mwEAs">Foo</span><span class="w" id="mwEAw"> </span><span class="n" id="mwEA0">foo</span><span class="w" id="mwEA4"> </span><span class="o" id="mwEA8">=</span><span class="w" id="mwEBA"> </span><span class="k" id="mwEBE">new</span><span class="w" id="mwEBI"> </span><span class="n" id="mwEBM">Foo</span><span class="p" id="mwEBQ">();</span> <span class="kt" id="mwEBU">int</span><span class="w" id="mwEBY"> </span><span class="n" id="mwEBc">result</span><span class="w" id="mwEBg"> </span><span class="o" id="mwEBk">=</span><span class="w" id="mwEBo"> </span><span class="n" id="mwEBs">foo</span><span class="p" id="mwEBw">.</span><span class="na" id="mwEB0">bar</span><span class="p" id="mwEB4">(</span><span class="mi" id="mwEB8">7</span><span class="p" id="mwECA">,</span><span class="w" id="mwECE"> </span><span class="mi" id="mwECI">2</span><span class="p" id="mwECM">);</span><span class="w" id="mwECQ"> </span><span class="c1" id="mwECU">// Non-static method is called on foo</span> <span class="kt" id="mwECY">int</span><span class="w" id="mwECc"> </span><span class="n" id="mwECg">finalResult</span><span class="w" id="mwECk"> </span><span class="o" id="mwECo">=</span><span class="w" id="mwECs"> </span><span class="n" id="mwECw">Math</span><span class="p" id="mwEC0">.</span><span class="na" id="mwEC4">abs</span><span class="p" id="mwEC8">(</span><span class="n" id="mwEDA">result</span><span class="p" id="mwEDE">);</span><span class="w" id="mwEDI"> </span><span class="c1" id="mwEDM">// Static method call</span>

The throws keyword indicates that a method throws an exception. All checked exceptions must be listed in a comma-separated list.

<span id="mwEDg"></span><span class="kn" id="mwEDk">import</span><span class="w" id="mwEDo"> </span><span class="nn" id="mwEDs">java.io.File</span><span class="p" id="mwEDw">;</span> <span class="kn" id="mwED0">import</span><span class="w" id="mwED4"> </span><span class="nn" id="mwED8">java.io.IOException</span><span class="p" id="mwEEA">;</span> <span class="kn" id="mwEEE">import</span><span class="w" id="mwEEI"> </span><span class="nn" id="mwEEM">java.util.zip.DataFormatException</span><span class="p" id="mwEEQ">;</span> <span class="c1" id="mwEEU">// Indicates that IOException and DataFormatException may be thrown</span> <span class="kt" id="mwEEY">void</span><span class="w" id="mwEEc"> </span><span class="nf" id="mwEEg">operateOnFile</span><span class="p" id="mwEEk">(</span><span class="n" id="mwEEo">File</span><span class="w" id="mwEEs"> </span><span class="n" id="mwEEw">f</span><span class="p" id="mwEE0">)</span><span class="w" id="mwEE4"> </span><span class="kd" id="mwEE8">throws</span><span class="w" id="mwEFA"> </span><span class="n" id="mwEFE">IOException</span><span class="p" id="mwEFI">,</span><span class="w" id="mwEFM"> </span><span class="n" id="mwEFQ">DataFormatException</span><span class="w" id="mwEFU"> </span><span class="p" id="mwEFY">{</span> <span class="w" id="mwEFc"> </span><span class="c1" id="mwEFg">// ...</span> <span class="p" id="mwEFk">}</span>

Modifiers

• abstract - Abstract methods can be present only in abstract classes, such methods have no body and must be overridden in a subclass unless it is abstract itself.
• static - Makes the method static and accessible without creation of a class instance. However static methods cannot access non-static members in the same class.
• final - Declares that the method cannot be overridden in a subclass.
• native - Indicates that this method is implemented through JNI in platform-dependent code. Actual implementation happens outside Java code, and such methods have no body.
• strictfp - Declares strict conformance to IEEE 754 in carrying out floating-point operations. Now obsolete.
• synchronized - Declares that a thread executing this method must acquire monitor. For synchronized methods the monitor is the class instance or java.lang.Class if the method is static.
• Access modifiers - Identical to those used with classes.

Final methods

A final method cannot be overridden or hidden by subclasses. This is used to prevent unexpected behavior from a subclass altering a method that may be crucial to the function or consistency of the class.

Example:

<span id="mwEIE"></span><span class="kd" id="mwEII">public</span><span class="w" id="mwEIM"> </span><span class="kd" id="mwEIQ">class</span> <span class="nc" id="mwEIU">Base</span><span class="w" id="mwEIY"> </span><span class="p" id="mwEIc">{</span> <span class="w" id="mwEIg"> </span><span class="kd" id="mwEIk">public</span><span class="w" id="mwEIo"> </span><span class="kt" id="mwEIs">void</span><span class="w" id="mwEIw"> </span><span class="nf" id="mwEI0">foo</span><span class="p" id="mwEI4">()</span><span class="w" id="mwEI8"> </span><span class="p" id="mwEJA">{</span> <span class="w" id="mwEJE"> </span><span class="c1" id="mwEJI">// ...</span> <span class="w" id="mwEJM"> </span><span class="p" id="mwEJQ">}</span> <span class="w" id="mwEJU"> </span><span class="kd" id="mwEJY">public</span><span class="w" id="mwEJc"> </span><span class="kd" id="mwEJg">final</span><span class="w" id="mwEJk"> </span><span class="kt" id="mwEJo">void</span><span class="w" id="mwEJs"> </span><span class="nf" id="mwEJw">bar</span><span class="p" id="mwEJ0">()</span><span class="w" id="mwEJ4"> </span><span class="p" id="mwEJ8">{</span> <span class="w" id="mwEKA"> </span><span class="c1" id="mwEKE">// ...</span> <span class="w" id="mwEKI"> </span><span class="p" id="mwEKM">}</span> <span class="w" id="mwEKQ"> </span><span class="kd" id="mwEKU">public</span><span class="w" id="mwEKY"> </span><span class="kd" id="mwEKc">static</span><span class="w" id="mwEKg"> </span><span class="kt" id="mwEKk">void</span><span class="w" id="mwEKo"> </span><span class="nf" id="mwEKs">baz</span><span class="p" id="mwEKw">()</span><span class="w" id="mwEK0"> </span><span class="p" id="mwEK4">{</span><span class="w" id="mwEK8"> </span> <span class="w" id="mwELA"> </span><span class="c1" id="mwELE">// ...</span> <span class="w" id="mwELI"> </span><span class="p" id="mwELM">}</span> <span class="w" id="mwELQ"> </span><span class="kd" id="mwELU">public</span><span class="w" id="mwELY"> </span><span class="kd" id="mwELc">static</span><span class="w" id="mwELg"> </span><span class="kd" id="mwELk">final</span><span class="w" id="mwELo"> </span><span class="kt" id="mwELs">void</span><span class="w" id="mwELw"> </span><span class="nf" id="mwEL0">qux</span><span class="p" id="mwEL4">()</span><span class="w" id="mwEL8"> </span><span class="p" id="mwEMA">{</span> <span class="w" id="mwEME"> </span><span class="c1" id="mwEMI">// ...</span> <span class="w" id="mwEMM"> </span><span class="p" id="mwEMQ">}</span> <span class="p" id="mwEMU">}</span> <span class="kd" id="mwEMY">public</span><span class="w" id="mwEMc"> </span><span class="kd" id="mwEMg">class</span> <span class="nc" id="mwEMk">Derived</span><span class="w" id="mwEMo"> </span><span class="kd" id="mwEMs">extends</span><span class="w" id="mwEMw"> </span><span class="n" id="mwEM0">Base</span><span class="w" id="mwEM4"> </span><span class="p" id="mwEM8">{</span> <span class="w" id="mwENA"> </span><span class="c1" id="mwENE">// OK, overriding Base::foo()</span> <span class="w" id="mwENI"> </span><span class="nd" id="mwENM">@Override</span> <span class="w" id="mwENQ"> </span><span class="kd" id="mwENU">public</span><span class="w" id="mwENY"> </span><span class="kt" id="mwENc">void</span><span class="w" id="mwENg"> </span><span class="nf" id="mwENk">foo</span><span class="p" id="mwENo">()</span><span class="w" id="mwENs"> </span><span class="p" id="mwENw">{</span> <span class="w" id="mwEN0"> </span><span class="c1" id="mwEN4">// ...</span> <span class="w" id="mwEN8"> </span><span class="p" id="mwEOA">}</span> <span class="w" id="mwEOE"> </span><span class="c1" id="mwEOI">// forbidden</span> <span class="w" id="mwEOM"> </span><span class="nd" id="mwEOQ">@Override</span> <span class="w" id="mwEOU"> </span><span class="kd" id="mwEOY">public</span><span class="w" id="mwEOc"> </span><span class="kt" id="mwEOg">void</span><span class="w" id="mwEOk"> </span><span class="nf" id="mwEOo">bar</span><span class="p" id="mwEOs">()</span><span class="w" id="mwEOw"> </span><span class="p" id="mwEO0">{</span> <span class="w" id="mwEO4"> </span><span class="c1" id="mwEO8">// ...</span> <span class="w" id="mwEPA"> </span><span class="p" id="mwEPE">}</span> <span class="w" id="mwEPI"> </span><span class="c1" id="mwEPM">// OK, overriding Base::baz()</span> <span class="w" id="mwEPQ"> </span><span class="nd" id="mwEPU">@Override</span> <span class="w" id="mwEPY"> </span><span class="kd" id="mwEPc">public</span><span class="w" id="mwEPg"> </span><span class="kd" id="mwEPk">static</span><span class="w" id="mwEPo"> </span><span class="kt" id="mwEPs">void</span><span class="w" id="mwEPw"> </span><span class="nf" id="mwEP0">baz</span><span class="p" id="mwEP4">()</span><span class="w" id="mwEP8"> </span><span class="p" id="mwEQA">{</span> <span class="w" id="mwEQE"> </span><span class="c1" id="mwEQI">// ...</span> <span class="w" id="mwEQM"> </span><span class="p" id="mwEQQ">}</span> <span class="w" id="mwEQU"> </span><span class="c1" id="mwEQY">// forbidden</span> <span class="w" id="mwEQc"> </span><span class="nd" id="mwEQg">@Override</span> <span class="w" id="mwEQk"> </span><span class="kd" id="mwEQo">public</span><span class="w" id="mwEQs"> </span><span class="kd" id="mwEQw">static</span><span class="w" id="mwEQ0"> </span><span class="kt" id="mwEQ4">void</span><span class="w" id="mwEQ8"> </span><span class="nf" id="mwERA">qux</span><span class="p" id="mwERE">()</span><span class="w" id="mwERI"> </span><span class="p" id="mwERM">{</span> <span class="w" id="mwERQ"> </span><span class="c1" id="mwERU">// ...</span> <span class="w" id="mwERY"> </span><span class="p" id="mwERc">}</span> <span class="p" id="mwERg">}</span>

A common misconception is that declaring a method as final improves efficiency by allowing the compiler to directly insert the method wherever it is called (see inline expansion). Because the method is loaded at runtime, compilers are unable to do this. Only the runtime environment and JIT compiler know exactly which classes have been loaded, and so only they are able to make decisions about when to inline, whether or not the method is final.

Machine code compilers that generate directly executable, platform-specific machine code, are an exception. When using static linking, the compiler can safely assume that methods and variables computable at compile-time may be inlined.

Variadic parameters

This language feature was introduced in J2SE 5.0. The last argument of the method may be declared as a variable arity parameter, in which case the method becomes a variable arity method (as opposed to fixed arity methods) or simply variadic method. This allows one to pass a (possibly zero) variable number of values, of the declared type, to the method as parameters. These values will be available inside the method as an array.

<span id="mwESY"></span><span class="c1" id="mwESc">// numbers represents varargs</span> <span class="kt" id="mwESg">void</span><span class="w" id="mwESk"> </span><span class="nf" id="mwESo">printReport</span><span class="p" id="mwESs">(</span><span class="n" id="mwESw">String</span><span class="w" id="mwES0"> </span><span class="n" id="mwES4">header</span><span class="p" id="mwES8">,</span><span class="w" id="mwETA"> </span><span class="kt" id="mwETE">int</span><span class="p" id="mwETI">...</span><span class="w" id="mwETM"> </span><span class="n" id="mwETQ">numbers</span><span class="p" id="mwETU">)</span><span class="w" id="mwETY"> </span><span class="p" id="mwETc">{</span> <span class="w" id="mwETg"> </span><span class="c1" id="mwETk">// numbers appears as int[]</span> <span class="w" id="mwETo"> </span><span class="n" id="mwETs">System</span><span class="p" id="mwETw">.</span><span class="na" id="mwET0">out</span><span class="p" id="mwET4">.</span><span class="na" id="mwET8">println</span><span class="p" id="mwEUA">(</span><span class="n" id="mwEUE">header</span><span class="p" id="mwEUI">);</span> <span class="w" id="mwEUM"> </span><span class="k" id="mwEUQ">for</span><span class="w" id="mwEUU"> </span><span class="p" id="mwEUY">(</span><span class="kt" id="mwEUc">int</span><span class="w" id="mwEUg"> </span><span class="n" id="mwEUk">num</span><span class="w" id="mwEUo"> </span><span class="p" id="mwEUs">:</span><span class="w" id="mwEUw"> </span><span class="n" id="mwEU0">numbers</span><span class="p" id="mwEU4">)</span><span class="w" id="mwEU8"> </span><span class="p" id="mwEVA">{</span> <span class="w" id="mwEVE"> </span><span class="n" id="mwEVI">System</span><span class="p" id="mwEVM">.</span><span class="na" id="mwEVQ">out</span><span class="p" id="mwEVU">.</span><span class="na" id="mwEVY">println</span><span class="p" id="mwEVc">(</span><span class="n" id="mwEVg">num</span><span class="p" id="mwEVk">);</span> <span class="w" id="mwEVo"> </span><span class="p" id="mwEVs">}</span> <span class="p" id="mwEVw">}</span> <span class="c1" id="mwEV0">// Calling varargs method</span> <span class="n" id="mwEV4">printReport</span><span class="p" id="mwEV8">(</span><span class="s" id="mwEWA">"Report data"</span><span class="p" id="mwEWE">,</span><span class="w" id="mwEWI"> </span><span class="mi" id="mwEWM">74</span><span class="p" id="mwEWQ">,</span><span class="w" id="mwEWU"> </span><span class="mi" id="mwEWY">83</span><span class="p" id="mwEWc">,</span><span class="w" id="mwEWg"> </span><span class="mi" id="mwEWk">25</span><span class="p" id="mwEWo">,</span><span class="w" id="mwEWs"> </span><span class="mi" id="mwEWw">96</span><span class="p" id="mwEW0">);</span>

Fields

Fields, or class variables, can be declared inside the class body to store data.

<span id="mwEXM"></span><span class="kd" id="mwEXQ">class</span> <span class="nc" id="mwEXU">Foo</span><span class="w" id="mwEXY"> </span><span class="p" id="mwEXc">{</span> <span class="w" id="mwEXg"> </span><span class="kt" id="mwEXk">double</span><span class="w" id="mwEXo"> </span><span class="n" id="mwEXs">bar</span><span class="p" id="mwEXw">;</span> <span class="p" id="mwEX0">}</span>

Fields can be initialized directly when declared.

<span id="mwEYE"></span><span class="kd" id="mwEYI">class</span> <span class="nc" id="mwEYM">Foo</span><span class="w" id="mwEYQ"> </span><span class="p" id="mwEYU">{</span> <span class="w" id="mwEYY"> </span><span class="kt" id="mwEYc">double</span><span class="w" id="mwEYg"> </span><span class="n" id="mwEYk">bar</span><span class="w" id="mwEYo"> </span><span class="o" id="mwEYs">=</span><span class="w" id="mwEYw"> </span><span class="mf" id="mwEY0">2.3</span><span class="p" id="mwEY4">;</span> <span class="p" id="mwEY8">}</span>

Modifiers

• static - Makes the field a static member.
• final - Allows the field to be initialized only once in a constructor or inside initialization block or during its declaration, whichever is earlier.
• transient - Indicates that this field will not be stored during serialization.
• volatile - If a field is declared volatile, it is ensured that all threads see a consistent value for the variable.

Inheritance

Classes in Java can only inherit from one class. A class can be derived from any class that is not marked as final. Inheritance is declared using the extends keyword. A class can reference itself using the this keyword and its direct superclass using the super keyword.

<span id="mwEao"></span><span class="kd" id="mwEas">class</span> <span class="nc" id="mwEaw">Foo</span><span class="w" id="mwEa0"> </span><span class="p" id="mwEa4">{</span> <span class="p" id="mwEa8">}</span> <span class="kd" id="mwEbA">class</span> <span class="nc" id="mwEbE">Foobar</span><span class="w" id="mwEbI"> </span><span class="kd" id="mwEbM">extends</span><span class="w" id="mwEbQ"> </span><span class="n" id="mwEbU">Foo</span><span class="w" id="mwEbY"> </span><span class="p" id="mwEbc">{</span> <span class="p" id="mwEbg">}</span>

If a class does not specify its superclass, it implicitly inherits from java.lang.Object class. Thus all classes in Java are subclasses of Object class.

If the superclass does not have a constructor without parameters the subclass must specify in its constructors what constructor of the superclass to use. For example:

<span id="mwEb8"></span><span class="kd" id="mwEcA">class</span> <span class="nc" id="mwEcE">Foo</span><span class="w" id="mwEcI"> </span><span class="p" id="mwEcM">{</span> <span class="w" id="mwEcQ"> </span><span class="kd" id="mwEcU">public</span><span class="w" id="mwEcY"> </span><span class="nf" id="mwEcc">Foo</span><span class="p" id="mwEcg">(</span><span class="kt" id="mwEck">int</span><span class="w" id="mwEco"> </span><span class="n" id="mwEcs">n</span><span class="p" id="mwEcw">)</span><span class="w" id="mwEc0"> </span><span class="p" id="mwEc4">{</span> <span class="w" id="mwEc8"> </span><span class="c1" id="mwEdA">// Do something with n</span> <span class="w" id="mwEdE"> </span><span class="p" id="mwEdI">}</span> <span class="p" id="mwEdM">}</span> <span class="kd" id="mwEdQ">class</span> <span class="nc" id="mwEdU">Foobar</span><span class="w" id="mwEdY"> </span><span class="kd" id="mwEdc">extends</span><span class="w" id="mwEdg"> </span><span class="n" id="mwEdk">Foo</span><span class="w" id="mwEdo"> </span><span class="p" id="mwEds">{</span> <span class="w" id="mwEdw"> </span><span class="kd" id="mwEd0">private</span><span class="w" id="mwEd4"> </span><span class="kt" id="mwEd8">int</span><span class="w" id="mwEeA"> </span><span class="n" id="mwEeE">number</span><span class="p" id="mwEeI">;</span> <span class="w" id="mwEeM"> </span><span class="c1" id="mwEeQ">// Superclass does not have constructor without parameters</span> <span class="w" id="mwEeU"> </span><span class="c1" id="mwEeY">// so we have to specify what constructor of our superclass to use and how</span> <span class="w" id="mwEec"> </span><span class="kd" id="mwEeg">public</span><span class="w" id="mwEek"> </span><span class="nf" id="mwEeo">Foobar</span><span class="p" id="mwEes">(</span><span class="kt" id="mwEew">int</span><span class="w" id="mwEe0"> </span><span class="n" id="mwEe4">number</span><span class="p" id="mwEe8">)</span><span class="w" id="mwEfA"> </span><span class="p" id="mwEfE">{</span> <span class="w" id="mwEfI"> </span><span class="kd" id="mwEfM">super</span><span class="p" id="mwEfQ">(</span><span class="n" id="mwEfU">number</span><span class="p" id="mwEfY">);</span> <span class="w" id="mwEfc"> </span><span class="k" id="mwEfg">this</span><span class="p" id="mwEfk">.</span><span class="na" id="mwEfo">number</span><span class="w" id="mwEfs"> </span><span class="o" id="mwEfw">=</span><span class="w" id="mwEf0"> </span><span class="n" id="mwEf4">number</span><span class="p" id="mwEf8">;</span> <span class="w" id="mwEgA"> </span><span class="p" id="mwEgE">}</span> <span class="p" id="mwEgI">}</span>

Overriding methods

Unlike C++, all non-final methods in Java are virtual and can be overridden by the inheriting classes.

<span id="mwEgk"></span><span class="kd" id="mwEgo">class</span> <span class="nc" id="mwEgs">Operation</span><span class="w" id="mwEgw"> </span><span class="p" id="mwEg0">{</span> <span class="w" id="mwEg4"> </span><span class="kd" id="mwEg8">public</span><span class="w" id="mwEhA"> </span><span class="kt" id="mwEhE">int</span><span class="w" id="mwEhI"> </span><span class="nf" id="mwEhM">doSomething</span><span class="p" id="mwEhQ">()</span><span class="w" id="mwEhU"> </span><span class="p" id="mwEhY">{</span> <span class="w" id="mwEhc"> </span><span class="k" id="mwEhg">return</span><span class="w" id="mwEhk"> </span><span class="mi" id="mwEho">0</span><span class="p" id="mwEhs">;</span> <span class="w" id="mwEhw"> </span><span class="p" id="mwEh0">}</span> <span class="p" id="mwEh4">}</span> <span class="kd" id="mwEh8">class</span> <span class="nc" id="mwEiA">NewOperation</span><span class="w" id="mwEiE"> </span><span class="kd" id="mwEiI">extends</span><span class="w" id="mwEiM"> </span><span class="n" id="mwEiQ">Operation</span><span class="w" id="mwEiU"> </span><span class="p" id="mwEiY">{</span> <span class="w" id="mwEic"> </span><span class="nd" id="mwEig">@Override</span> <span class="w" id="mwEik"> </span><span class="kd" id="mwEio">public</span><span class="w" id="mwEis"> </span><span class="kt" id="mwEiw">int</span><span class="w" id="mwEi0"> </span><span class="nf" id="mwEi4">doSomething</span><span class="p" id="mwEi8">()</span><span class="w" id="mwEjA"> </span><span class="p" id="mwEjE">{</span> <span class="w" id="mwEjI"> </span><span class="k" id="mwEjM">return</span><span class="w" id="mwEjQ"> </span><span class="mi" id="mwEjU">1</span><span class="p" id="mwEjY">;</span> <span class="w" id="mwEjc"> </span><span class="p" id="mwEjg">}</span> <span class="p" id="mwEjk">}</span>

Abstract classes

An abstract class is a class that is incomplete, or is to be considered incomplete, and cannot be instantiated (directly).

A class X has abstract methods if any of the following is true:

• X explicitly contains a declaration of an abstract method.
• Any of X's superclasses in the inheritance chain have an abstract method and X neither declares nor inherits a method that implements it.
• A direct superinterface of X declares or inherits a method (which is therefore necessarily abstract) and X neither declares nor inherits a method that implements it.
• A subclass of an abstract class that is not itself abstract may be instantiated, resulting in the execution of a constructor for the abstract class and, therefore, the execution of the field initializers for instance variables of that class.

<span id="mwEk8"></span><span class="kn" id="mwElA">package</span><span class="w" id="mwElE"> </span><span class="nn" id="mwElI">org.wikipedia.examples</span><span class="p" id="mwElM">;</span> <span class="kd" id="mwElQ">public</span><span class="w" id="mwElU"> </span><span class="kd" id="mwElY">class</span> <span class="nc" id="mwElc">MyAbstractClass</span><span class="w" id="mwElg"> </span><span class="p" id="mwElk">{</span> <span class="w" id="mwElo"> </span><span class="kd" id="mwEls">private</span><span class="w" id="mwElw"> </span><span class="kd" id="mwEl0">static</span><span class="w" id="mwEl4"> </span><span class="kd" id="mwEl8">final</span><span class="w" id="mwEmA"> </span><span class="n" id="mwEmE">String</span><span class="w" id="mwEmI"> </span><span class="n" id="mwEmM">hello</span><span class="p" id="mwEmQ">;</span> <span class="w" id="mwEmU"> </span><span class="kd" id="mwEmY">static</span><span class="w" id="mwEmc"> </span><span class="p" id="mwEmg">{</span> <span class="w" id="mwEmk"> </span><span class="n" id="mwEmo">System</span><span class="p" id="mwEms">.</span><span class="na" id="mwEmw">out</span><span class="p" id="mwEm0">.</span><span class="na" id="mwEm4">printf</span><span class="p" id="mwEm8">(</span><span class="s" id="mwEnA">"%s: static block runtime%n"</span><span class="p" id="mwEnE">,</span><span class="w" id="mwEnI"> </span><span class="n" id="mwEnM">MyAbstractClass</span><span class="p" id="mwEnQ">.</span><span class="na" id="mwEnU">class</span><span class="p" id="mwEnY">.</span><span class="na" id="mwEnc">getName</span><span class="p" id="mwEng">());</span> <span class="w" id="mwEnk"> </span><span class="n" id="mwEno">hello</span><span class="w" id="mwEns"> </span><span class="o" id="mwEnw">=</span><span class="w" id="mwEn0"> </span><span class="n" id="mwEn4">String</span><span class="p" id="mwEn8">.</span><span class="na" id="mwEoA">format</span><span class="p" id="mwEoE">(</span><span class="s" id="mwEoI">"hello from %s"</span><span class="p" id="mwEoM">,</span><span class="w" id="mwEoQ"> </span><span class="n" id="mwEoU">MyAbstractClass</span><span class="p" id="mwEoY">.</span><span class="na" id="mwEoc">class</span><span class="p" id="mwEog">.</span><span class="na" id="mwEok">getName</span><span class="p" id="mwEoo">());</span> <span class="w" id="mwEos"> </span><span class="p" id="mwEow">}</span> <span class="w" id="mwEo0"> </span><span class="p" id="mwEo4">{</span> <span class="w" id="mwEo8"> </span><span class="n" id="mwEpA">System</span><span class="p" id="mwEpE">.</span><span class="na" id="mwEpI">out</span><span class="p" id="mwEpM">.</span><span class="na" id="mwEpQ">printf</span><span class="p" id="mwEpU">(</span><span class="s" id="mwEpY">"%s: instance block runtime%n"</span><span class="p" id="mwEpc">,</span><span class="w" id="mwEpg"> </span><span class="n" id="mwEpk">MyAbstractClass</span><span class="p" id="mwEpo">.</span><span class="na" id="mwEps">class</span><span class="p" id="mwEpw">.</span><span class="na" id="mwEp0">getName</span><span class="p" id="mwEp4">());</span> <span class="w" id="mwEp8"> </span><span class="p" id="mwEqA">}</span> <span class="w" id="mwEqE"> </span><span class="kd" id="mwEqI">public</span><span class="w" id="mwEqM"> </span><span class="nf" id="mwEqQ">AbstractClass</span><span class="p" id="mwEqU">()</span><span class="w" id="mwEqY"> </span><span class="p" id="mwEqc">{</span> <span class="w" id="mwEqg"> </span><span class="n" id="mwEqk">System</span><span class="p" id="mwEqo">.</span><span class="na" id="mwEqs">out</span><span class="p" id="mwEqw">.</span><span class="na" id="mwEq0">printf</span><span class="p" id="mwEq4">(</span><span class="s" id="mwEq8">"%s: constructor runtime%n"</span><span class="p" id="mwErA">,</span><span class="w" id="mwErE"> </span><span class="n" id="mwErI">MyAbstractClass</span><span class="p" id="mwErM">.</span><span class="na" id="mwErQ">class</span><span class="p" id="mwErU">.</span><span class="na" id="mwErY">getName</span><span class="p" id="mwErc">());</span> <span class="w" id="mwErg"> </span><span class="p" id="mwErk">}</span> <span class="w" id="mwEro"> </span><span class="kd" id="mwErs">public</span><span class="w" id="mwErw"> </span><span class="kd" id="mwEr0">static</span><span class="w" id="mwEr4"> </span><span class="kt" id="mwEr8">void</span><span class="w" id="mwEsA"> </span><span class="nf" id="mwEsE">hello</span><span class="p" id="mwEsI">()</span><span class="w" id="mwEsM"> </span><span class="p" id="mwEsQ">{</span> <span class="w" id="mwEsU"> </span><span class="n" id="mwEsY">System</span><span class="p" id="mwEsc">.</span><span class="na" id="mwEsg">out</span><span class="p" id="mwEsk">.</span><span class="na" id="mwEso">println</span><span class="p" id="mwEss">(</span><span class="n" id="mwEsw">hello</span><span class="p" id="mwEs0">);</span> <span class="w" id="mwEs4"> </span><span class="p" id="mwEs8">}</span> <span class="p" id="mwEtA">}</span>

<span id="mwEtM"></span><span class="kn" id="mwEtQ">package</span><span class="w" id="mwEtU"> </span><span class="nn" id="mwEtY">org.wikipedia.examples</span><span class="p" id="mwEtc">;</span> <span class="kd" id="mwEtg">public</span><span class="w" id="mwEtk"> </span><span class="kd" id="mwEto">class</span> <span class="nc" id="mwEts">MyCustomClass</span><span class="w" id="mwEtw"> </span><span class="kd" id="mwEt0">extends</span><span class="w" id="mwEt4"> </span><span class="n" id="mwEt8">MyAbstractClass</span><span class="w" id="mwEuA"> </span><span class="p" id="mwEuE">{</span> <span class="w" id="mwEuI"> </span><span class="kd" id="mwEuM">static</span><span class="w" id="mwEuQ"> </span><span class="p" id="mwEuU">{</span> <span class="w" id="mwEuY"> </span><span class="n" id="mwEuc">System</span><span class="p" id="mwEug">.</span><span class="na" id="mwEuk">out</span><span class="p" id="mwEuo">.</span><span class="na" id="mwEus">printf</span><span class="p" id="mwEuw">(</span><span class="s" id="mwEu0">"%s: static block runtime%n"</span><span class="p" id="mwEu4">,</span><span class="w" id="mwEu8"> </span><span class="n" id="mwEvA">MyCustomClass</span><span class="p" id="mwEvE">.</span><span class="na" id="mwEvI">class</span><span class="p" id="mwEvM">.</span><span class="na" id="mwEvQ">getName</span><span class="p" id="mwEvU">());</span> <span class="w" id="mwEvY"> </span><span class="p" id="mwEvc">}</span> <span class="w" id="mwEvg"> </span><span class="p" id="mwEvk">{</span> <span class="w" id="mwEvo"> </span><span class="n" id="mwEvs">System</span><span class="p" id="mwEvw">.</span><span class="na" id="mwEv0">out</span><span class="p" id="mwEv4">.</span><span class="na" id="mwEv8">printf</span><span class="p" id="mwEwA">(</span><span class="s" id="mwEwE">"%s: instance block runtime%n"</span><span class="p" id="mwEwI">,</span><span class="w" id="mwEwM"> </span><span class="n" id="mwEwQ">MyCustomClass</span><span class="p" id="mwEwU">.</span><span class="na" id="mwEwY">class</span><span class="p" id="mwEwc">.</span><span class="na" id="mwEwg">getName</span><span class="p" id="mwEwk">());</span> <span class="w" id="mwEwo"> </span><span class="p" id="mwEws">}</span> <span class="w" id="mwEww"> </span><span class="kd" id="mwEw0">public</span><span class="w" id="mwEw4"> </span><span class="nf" id="mwEw8">CustomClass</span><span class="p" id="mwExA">()</span><span class="w" id="mwExE"> </span><span class="p" id="mwExI">{</span> <span class="w" id="mwExM"> </span><span class="n" id="mwExQ">System</span><span class="p" id="mwExU">.</span><span class="na" id="mwExY">out</span><span class="p" id="mwExc">.</span><span class="na" id="mwExg">printf</span><span class="p" id="mwExk">(</span><span class="s" id="mwExo">"%s: constructor runtime%n"</span><span class="p" id="mwExs">,</span><span class="w" id="mwExw"> </span><span class="n" id="mwEx0">MyCustomClass</span><span class="p" id="mwEx4">.</span><span class="na" id="mwEx8">class</span><span class="p" id="mwEyA">.</span><span class="na" id="mwEyE">getName</span><span class="p" id="mwEyI">());</span> <span class="w" id="mwEyM"> </span><span class="p" id="mwEyQ">}</span> <span class="w" id="mwEyU"> </span><span class="kd" id="mwEyY">public</span><span class="w" id="mwEyc"> </span><span class="kd" id="mwEyg">static</span><span class="w" id="mwEyk"> </span><span class="kt" id="mwEyo">void</span><span class="w" id="mwEys"> </span><span class="nf" id="mwEyw">main</span><span class="p" id="mwEy0">(</span><span class="n" id="mwEy4">String</span><span class="o" id="mwEy8">[]</span><span class="w" id="mwEzA"> </span><span class="n" id="mwEzE">args</span><span class="p" id="mwEzI">)</span><span class="w" id="mwEzM"> </span><span class="p" id="mwEzQ">{</span> <span class="w" id="mwEzU"> </span><span class="n" id="mwEzY">MyCustomClass</span><span class="w" id="mwEzc"> </span><span class="n" id="mwEzg">nc</span><span class="w" id="mwEzk"> </span><span class="o" id="mwEzo">=</span><span class="w" id="mwEzs"> </span><span class="k" id="mwEzw">new</span><span class="w" id="mwEz0"> </span><span class="n" id="mwEz4">MyCustomClass</span><span class="p" id="mwEz8">();</span> <span class="w" id="mwE0A"> </span><span class="n" id="mwE0E">hello</span><span class="p" id="mwE0I">();</span> <span class="w" id="mwE0M"> </span><span class="n" id="mwE0Q">MyAbstractClass</span><span class="p" id="mwE0U">.</span><span class="na" id="mwE0Y">hello</span><span class="p" id="mwE0c">();</span><span class="w" id="mwE0g"> </span><span class="c1" id="mwE0k">// also valid</span> <span class="w" id="mwE0o"> </span><span class="p" id="mwE0s">}</span> <span class="p" id="mwE0w">}</span>

Output:

<span id="mwE1A"></span>org.wikipedia.examples.MyAbstractClass: static block runtime org.wikipedia.examples.MyCustomClass: static block runtime org.wikipedia.examples.MyAbstractClass: instance block runtime org.wikipedia.examples.MyAbstractClass: constructor runtime org.wikipedia.examples.MyCustomClass: instance block runtime org.wikipedia.examples.MyCustomClass: constructor runtime hello from org.wikipedia.examples.MyAbstractClass

Enumerations

This language feature was introduced in J2SE 5.0. Technically enumerations are a kind of class containing enum constants in its body. Each enum constant defines an instance of the enum type. Enumeration classes cannot be instantiated anywhere except in the enumeration class itself.

<span id="mwE1Y"></span><span class="kd" id="mwE1c">enum</span><span class="w" id="mwE1g"> </span><span class="n" id="mwE1k">Season</span><span class="w" id="mwE1o"> </span><span class="p" id="mwE1s">{</span> <span class="w" id="mwE1w"> </span><span class="n" id="mwE10">WINTER</span><span class="p" id="mwE14">,</span> <span class="w" id="mwE18"> </span><span class="n" id="mwE2A">SPRING</span><span class="p" id="mwE2E">,</span> <span class="w" id="mwE2I"> </span><span class="n" id="mwE2M">SUMMER</span><span class="p" id="mwE2Q">,</span> <span class="w" id="mwE2U"> </span><span class="n" id="mwE2Y">AUTUMN</span><span class="p" id="mwE2c">,</span> <span class="p" id="mwE2g">}</span>

Enum constants are allowed to have constructors, which are called when the class is loaded:

<span id="mwE2w"></span><span class="kd" id="mwE20">public</span><span class="w" id="mwE24"> </span><span class="kd" id="mwE28">enum</span><span class="w" id="mwE3A"> </span><span class="n" id="mwE3E">Season</span><span class="w" id="mwE3I"> </span><span class="p" id="mwE3M">{</span> <span class="w" id="mwE3Q"> </span><span class="n" id="mwE3U">WINTER</span><span class="p" id="mwE3Y">(</span><span class="s" id="mwE3c">"Cold"</span><span class="p" id="mwE3g">),</span> <span class="w" id="mwE3k"> </span><span class="n" id="mwE3o">SPRING</span><span class="p" id="mwE3s">(</span><span class="s" id="mwE3w">"Warmer"</span><span class="p" id="mwE30">),</span> <span class="w" id="mwE34"> </span><span class="n" id="mwE38">SUMMER</span><span class="p" id="mwE4A">(</span><span class="s" id="mwE4E">"Hot"</span><span class="p" id="mwE4I">),</span> <span class="w" id="mwE4M"> </span><span class="n" id="mwE4Q">AUTUMN</span><span class="p" id="mwE4U">(</span><span class="s" id="mwE4Y">"Cooler"</span><span class="p" id="mwE4c">);</span> <span class="w" id="mwE4g"> </span><span class="n" id="mwE4k">Season</span><span class="p" id="mwE4o">(</span><span class="n" id="mwE4s">String</span><span class="w" id="mwE4w"> </span><span class="n" id="mwE40">description</span><span class="p" id="mwE44">)</span><span class="w" id="mwE48"> </span><span class="p" id="mwE5A">{</span> <span class="w" id="mwE5E"> </span><span class="k" id="mwE5I">this</span><span class="p" id="mwE5M">.</span><span class="na" id="mwE5Q">description</span><span class="w" id="mwE5U"> </span><span class="o" id="mwE5Y">=</span><span class="w" id="mwE5c"> </span><span class="n" id="mwE5g">description</span><span class="p" id="mwE5k">;</span> <span class="w" id="mwE5o"> </span><span class="p" id="mwE5s">}</span> <span class="w" id="mwE5w"> </span><span class="kd" id="mwE50">private</span><span class="w" id="mwE54"> </span><span class="kd" id="mwE58">final</span><span class="w" id="mwE6A"> </span><span class="n" id="mwE6E">String</span><span class="w" id="mwE6I"> </span><span class="n" id="mwE6M">description</span><span class="p" id="mwE6Q">;</span> <span class="w" id="mwE6U"> </span><span class="kd" id="mwE6Y">public</span><span class="w" id="mwE6c"> </span><span class="n" id="mwE6g">String</span><span class="w" id="mwE6k"> </span><span class="nf" id="mwE6o">getDescription</span><span class="p" id="mwE6s">()</span><span class="w" id="mwE6w"> </span><span class="p" id="mwE60">{</span> <span class="w" id="mwE64"> </span><span class="k" id="mwE68">return</span><span class="w" id="mwE7A"> </span><span class="n" id="mwE7E">description</span><span class="p" id="mwE7I">;</span> <span class="w" id="mwE7M"> </span><span class="p" id="mwE7Q">}</span> <span class="p" id="mwE7U">}</span>

Enumerations can have class bodies, in which case they are treated like anonymous classes extending the enum class:

<span id="mwE7k"></span><span class="kd" id="mwE7o">public</span><span class="w" id="mwE7s"> </span><span class="kd" id="mwE7w">enum</span><span class="w" id="mwE70"> </span><span class="n" id="mwE74">Season</span><span class="w" id="mwE78"> </span><span class="p" id="mwE8A">{</span> <span class="w" id="mwE8E"> </span><span class="n" id="mwE8I">WINTER</span><span class="w" id="mwE8M"> </span><span class="p" id="mwE8Q">{</span> <span class="w" id="mwE8U"> </span><span class="nd" id="mwE8Y">@Override</span> <span class="w" id="mwE8c"> </span><span class="n" id="mwE8g">String</span><span class="w" id="mwE8k"> </span><span class="nf" id="mwE8o">getDescription</span><span class="p" id="mwE8s">()</span><span class="w" id="mwE8w"> </span><span class="p" id="mwE80">{</span> <span class="w" id="mwE84"> </span><span class="k" id="mwE88">return</span><span class="w" id="mwE9A"> </span><span class="s" id="mwE9E">"cold"</span> <span class="w" id="mwE9I"> </span><span class="p" id="mwE9M">}</span> <span class="w" id="mwE9Q"> </span><span class="p" id="mwE9U">},</span> <span class="w" id="mwE9Y"> </span><span class="n" id="mwE9c">SPRING</span><span class="w" id="mwE9g"> </span><span class="p" id="mwE9k">{</span> <span class="w" id="mwE9o"> </span><span class="nd" id="mwE9s">@Override</span> <span class="w" id="mwE9w"> </span><span class="n" id="mwE90">String</span><span class="w" id="mwE94"> </span><span class="nf" id="mwE98">getDescription</span><span class="p" id="mwE-A">()</span><span class="w" id="mwE-E"> </span><span class="p" id="mwE-I">{</span> <span class="w" id="mwE-M"> </span><span class="k" id="mwE-Q">return</span><span class="w" id="mwE-U"> </span><span class="s" id="mwE-Y">"warmer"</span><span class="p" id="mwE-c">;</span> <span class="w" id="mwE-g"> </span><span class="p" id="mwE-k">}</span> <span class="w" id="mwE-o"> </span><span class="p" id="mwE-s">},</span> <span class="w" id="mwE-w"> </span><span class="n" id="mwE-0">SUMMER</span><span class="w" id="mwE-4"> </span><span class="p" id="mwE-8">{</span> <span class="w" id="mwE_A"> </span><span class="nd" id="mwE_E">@Override</span> <span class="w" id="mwE_I"> </span><span class="n" id="mwE_M">String</span><span class="w" id="mwE_Q"> </span><span class="nf" id="mwE_U">getDescription</span><span class="p" id="mwE_Y">()</span><span class="w" id="mwE_c"> </span><span class="p" id="mwE_g">{</span> <span class="w" id="mwE_k"> </span><span class="k" id="mwE_o">return</span><span class="w" id="mwE_s"> </span><span class="s" id="mwE_w">"hot"</span><span class="p" id="mwE_0">;</span> <span class="w" id="mwE_4"> </span><span class="p" id="mwE_8">}</span> <span class="w" id="mwFAA"> </span><span class="p" id="mwFAE">},</span> <span class="w" id="mwFAI"> </span><span class="n" id="mwFAM">FALL</span><span class="w" id="mwFAQ"> </span><span class="p" id="mwFAU">{</span> <span class="w" id="mwFAY"> </span><span class="nd" id="mwFAc">@Override</span> <span class="w" id="mwFAg"> </span><span class="n" id="mwFAk">String</span><span class="w" id="mwFAo"> </span><span class="nf" id="mwFAs">getDescription</span><span class="p" id="mwFAw">()</span><span class="w" id="mwFA0"> </span><span class="p" id="mwFA4">{</span> <span class="w" id="mwFA8"> </span><span class="k" id="mwFBA">return</span><span class="w" id="mwFBE"> </span><span class="s" id="mwFBI">"cooler"</span><span class="p" id="mwFBM">;</span> <span class="w" id="mwFBQ"> </span><span class="p" id="mwFBU">}</span> <span class="w" id="mwFBY"> </span><span class="p" id="mwFBc">};</span> <span class="w" id="mwFBg"> </span><span class="kd" id="mwFBk">abstract</span><span class="w" id="mwFBo"> </span><span class="n" id="mwFBs">String</span><span class="w" id="mwFBw"> </span><span class="nf" id="mwFB0">getDescription</span><span class="p" id="mwFB4">();</span> <span class="p" id="mwFB8">}</span>

Interfaces

Interfaces are types which contain no fields and usually define a number of methods without an actual implementation. They are useful to define a contract with any number of different implementations. Every interface is implicitly abstract. Interface methods are allowed to have a subset of access modifiers depending on the language version, strictfp, which has the same effect as for classes, and also static since Java SE 8.

<span id="mwFCc"></span><span class="kd" id="mwFCg">interface</span> <span class="nc" id="mwFCk">ActionListener</span><span class="w" id="mwFCo"> </span><span class="p" id="mwFCs">{</span> <span class="w" id="mwFCw"> </span><span class="kt" id="mwFC0">int</span><span class="w" id="mwFC4"> </span><span class="n" id="mwFC8">ACTION_ADD</span><span class="w" id="mwFDA"> </span><span class="o" id="mwFDE">=</span><span class="w" id="mwFDI"> </span><span class="mi" id="mwFDM">0</span><span class="p" id="mwFDQ">;</span> <span class="w" id="mwFDU"> </span><span class="kt" id="mwFDY">int</span><span class="w" id="mwFDc"> </span><span class="n" id="mwFDg">ACTION_REMOVE</span><span class="w" id="mwFDk"> </span><span class="o" id="mwFDo">=</span><span class="w" id="mwFDs"> </span><span class="mi" id="mwFDw">1</span><span class="p" id="mwFD0">;</span> <span class="w" id="mwFD4"> </span> <span class="w" id="mwFD8"> </span><span class="kt" id="mwFEA">void</span><span class="w" id="mwFEE"> </span><span class="nf" id="mwFEI">actionSelected</span><span class="p" id="mwFEM">(</span><span class="kt" id="mwFEQ">int</span><span class="w" id="mwFEU"> </span><span class="n" id="mwFEY">action</span><span class="p" id="mwFEc">);</span> <span class="p" id="mwFEg">}</span>

Implementing an interface

An interface is implemented by a class using the implements keyword. It is allowed to implement more than one interface, in which case they are written after implements keyword in a comma-separated list. A class implementing an interface must override all its methods, otherwise it must be declared as abstract.

<span id="mwFE8"></span><span class="kd" id="mwFFA">interface</span> <span class="nc" id="mwFFE">RequestListener</span><span class="w" id="mwFFI"> </span><span class="p" id="mwFFM">{</span> <span class="w" id="mwFFQ"> </span><span class="kt" id="mwFFU">int</span><span class="w" id="mwFFY"> </span><span class="nf" id="mwFFc">requestReceived</span><span class="p" id="mwFFg">();</span> <span class="p" id="mwFFk">}</span> <span class="kd" id="mwFFo">class</span> <span class="nc" id="mwFFs">ActionHandler</span><span class="w" id="mwFFw"> </span><span class="kd" id="mwFF0">implements</span><span class="w" id="mwFF4"> </span><span class="n" id="mwFF8">ActionListener</span><span class="p" id="mwFGA">,</span><span class="w" id="mwFGE"> </span><span class="n" id="mwFGI">RequestListener</span><span class="w" id="mwFGM"> </span><span class="p" id="mwFGQ">{</span> <span class="w" id="mwFGU"> </span><span class="kd" id="mwFGY">public</span><span class="w" id="mwFGc"> </span><span class="kt" id="mwFGg">void</span><span class="w" id="mwFGk"> </span><span class="nf" id="mwFGo">actionSelected</span><span class="p" id="mwFGs">(</span><span class="kt" id="mwFGw">int</span><span class="w" id="mwFG0"> </span><span class="n" id="mwFG4">action</span><span class="p" id="mwFG8">)</span><span class="w" id="mwFHA"> </span><span class="p" id="mwFHE">{</span> <span class="w" id="mwFHI"> </span><span class="c1" id="mwFHM">// ...</span> <span class="w" id="mwFHQ"> </span><span class="p" id="mwFHU">}</span> <span class="w" id="mwFHY"> </span><span class="kd" id="mwFHc">public</span><span class="w" id="mwFHg"> </span><span class="kt" id="mwFHk">int</span><span class="w" id="mwFHo"> </span><span class="nf" id="mwFHs">requestReceived</span><span class="p" id="mwFHw">()</span><span class="w" id="mwFH0"> </span><span class="p" id="mwFH4">{</span> <span class="w" id="mwFH8"> </span><span class="c1" id="mwFIA">// ...</span> <span class="w" id="mwFIE"> </span><span class="p" id="mwFII">}</span> <span class="p" id="mwFIM">}</span> <span class="c1" id="mwFIQ">// Calling method defined by interface</span> <span class="c1" id="mwFIU">// ActionHandler can be represented as RequestListener...</span> <span class="n" id="mwFIY">RequestListener</span><span class="w" id="mwFIc"> </span><span class="n" id="mwFIg">listener</span><span class="w" id="mwFIk"> </span><span class="o" id="mwFIo">=</span><span class="w" id="mwFIs"> </span><span class="k" id="mwFIw">new</span><span class="w" id="mwFI0"> </span><span class="n" id="mwFI4">ActionHandler</span><span class="p" id="mwFI8">();</span><span class="w" id="mwFJA"> </span> <span class="c1" id="mwFJE">// ...and thus is known to implement requestReceived() method</span> <span class="n" id="mwFJI">listener</span><span class="p" id="mwFJM">.</span><span class="na" id="mwFJQ">requestReceived</span><span class="p" id="mwFJU">();</span>

Functional interfaces and lambda expressions

These features were introduced with the release of Java SE 8. An interface automatically becomes a functional interface if it defines only one method (excluding those which are inherited from java.lang.Object). In this case an implementation can be represented as a lambda expression instead of implementing it in a new class, thus greatly simplifying writing code in the functional style. Functional interfaces can optionally be annotated with the java.lang.FunctionalInterface annotation, which will tell the compiler to check whether the interface actually conforms to a definition of a functional interface.

<span id="mwFJ4"></span><span class="c1" id="mwFJ8">// A functional interface</span> <span class="nd" id="mwFKA">@FunctionalInterface</span> <span class="kd" id="mwFKE">interface</span> <span class="nc" id="mwFKI">Calculation</span><span class="w" id="mwFKM"> </span><span class="p" id="mwFKQ">{</span> <span class="w" id="mwFKU"> </span><span class="kt" id="mwFKY">int</span><span class="w" id="mwFKc"> </span><span class="nf" id="mwFKg">calculate</span><span class="p" id="mwFKk">(</span><span class="kt" id="mwFKo">int</span><span class="w" id="mwFKs"> </span><span class="n" id="mwFKw">someNumber</span><span class="p" id="mwFK0">,</span><span class="w" id="mwFK4"> </span><span class="kt" id="mwFK8">int</span><span class="w" id="mwFLA"> </span><span class="n" id="mwFLE">someOtherNumber</span><span class="p" id="mwFLI">);</span> <span class="p" id="mwFLM">}</span> <span class="c1" id="mwFLQ">// A method which accepts this interface as a parameter</span> <span class="kt" id="mwFLU">int</span><span class="w" id="mwFLY"> </span><span class="nf" id="mwFLc">runCalculation</span><span class="p" id="mwFLg">(</span><span class="n" id="mwFLk">Calculation</span><span class="w" id="mwFLo"> </span><span class="n" id="mwFLs">calculation</span><span class="p" id="mwFLw">)</span><span class="w" id="mwFL0"> </span><span class="p" id="mwFL4">{</span> <span class="w" id="mwFL8"> </span><span class="k" id="mwFMA">return</span><span class="w" id="mwFME"> </span><span class="n" id="mwFMI">calculation</span><span class="p" id="mwFMM">.</span><span class="na" id="mwFMQ">calculate</span><span class="p" id="mwFMU">(</span><span class="mi" id="mwFMY">1</span><span class="p" id="mwFMc">,</span><span class="w" id="mwFMg"> </span><span class="mi" id="mwFMk">2</span><span class="p" id="mwFMo">);</span> <span class="p" id="mwFMs">}</span> <span class="c1" id="mwFMw">// Using a lambda to call the method</span> <span class="n" id="mwFM0">runCalculation</span><span class="p" id="mwFM4">((</span><span class="n" id="mwFM8">number</span><span class="p" id="mwFNA">,</span><span class="w" id="mwFNE"> </span><span class="n" id="mwFNI">otherNumber</span><span class="p" id="mwFNM">)</span><span class="w" id="mwFNQ"> </span><span class="o" id="mwFNU">-></span><span class="w" id="mwFNY"> </span><span class="n" id="mwFNc">number</span><span class="w" id="mwFNg"> </span><span class="o" id="mwFNk">+</span><span class="w" id="mwFNo"> </span><span class="n" id="mwFNs">otherNumber</span><span class="p" id="mwFNw">);</span> <span class="c1" id="mwFN0">// Equivalent code which uses an anonymous class instead</span> <span class="n" id="mwFN4">runCalculation</span><span class="p" id="mwFN8">(</span><span class="k" id="mwFOA">new</span><span class="w" id="mwFOE"> </span><span class="n" id="mwFOI">Calculation</span><span class="p" id="mwFOM">()</span><span class="w" id="mwFOQ"> </span><span class="p" id="mwFOU">{</span> <span class="w" id="mwFOY"> </span><span class="nd" id="mwFOc">@Override</span> <span class="w" id="mwFOg"> </span><span class="kd" id="mwFOk">public</span><span class="w" id="mwFOo"> </span><span class="kt" id="mwFOs">int</span><span class="w" id="mwFOw"> </span><span class="nf" id="mwFO0">calculate</span><span class="p" id="mwFO4">(</span><span class="kt" id="mwFO8">int</span><span class="w" id="mwFPA"> </span><span class="n" id="mwFPE">someNumber</span><span class="p" id="mwFPI">,</span><span class="w" id="mwFPM"> </span><span class="kt" id="mwFPQ">int</span><span class="w" id="mwFPU"> </span><span class="n" id="mwFPY">someOtherNumber</span><span class="p" id="mwFPc">)</span><span class="w" id="mwFPg"> </span><span class="p" id="mwFPk">{</span> <span class="w" id="mwFPo"> </span><span class="k" id="mwFPs">return</span><span class="w" id="mwFPw"> </span><span class="n" id="mwFP0">someNumber</span><span class="w" id="mwFP4"> </span><span class="o" id="mwFP8">+</span><span class="w" id="mwFQA"> </span><span class="n" id="mwFQE">someOtherNumber</span><span class="p" id="mwFQI">;</span> <span class="w" id="mwFQM"> </span><span class="p" id="mwFQQ">}</span> <span class="p" id="mwFQU">})</span>

The parameter types of a lambda do not have to be fully specified and can be inferred from the interface it implements, but there is no place to explicitly specify the lambda's return type (which is inferred). The body of the lambda can be written without a body block and a return statement if it is only an expression. Also, for those interfaces which only have a single parameter in the method, round brackets can be omitted.

<span id="mwFQ4"></span><span class="c1" id="mwFQ8">// Same call as above, but with fully specified types and a body block</span> <span class="n" id="mwFRA">runCalculation</span><span class="p" id="mwFRE">((</span><span class="kt" id="mwFRI">int</span><span class="w" id="mwFRM"> </span><span class="n" id="mwFRQ">number</span><span class="p" id="mwFRU">,</span><span class="w" id="mwFRY"> </span><span class="kt" id="mwFRc">int</span><span class="w" id="mwFRg"> </span><span class="n" id="mwFRk">otherNumber</span><span class="p" id="mwFRo">)</span><span class="w" id="mwFRs"> </span><span class="o" id="mwFRw">-></span><span class="w" id="mwFR0"> </span><span class="p" id="mwFR4">{</span> <span class="w" id="mwFR8"> </span><span class="k" id="mwFSA">return</span><span class="w" id="mwFSE"> </span><span class="n" id="mwFSI">number</span><span class="w" id="mwFSM"> </span><span class="o" id="mwFSQ">+</span><span class="w" id="mwFSU"> </span><span class="n" id="mwFSY">otherNumber</span><span class="p" id="mwFSc">;</span> <span class="p" id="mwFSg">});</span> <span class="c1" id="mwFSk">// A functional interface with a method which has only a single parameter</span> <span class="kd" id="mwFSo">interface</span> <span class="nc" id="mwFSs">StringExtender</span><span class="w" id="mwFSw"> </span><span class="p" id="mwFS0">{</span> <span class="w" id="mwFS4"> </span><span class="n" id="mwFS8">String</span><span class="w" id="mwFTA"> </span><span class="nf" id="mwFTE">extendString</span><span class="p" id="mwFTI">(</span><span class="n" id="mwFTM">String</span><span class="w" id="mwFTQ"> </span><span class="n" id="mwFTU">input</span><span class="p" id="mwFTY">);</span> <span class="p" id="mwFTc">}</span> <span class="c1" id="mwFTg">// Initializing a variable of this type by using a lambda</span> <span class="n" id="mwFTk">StringExtender</span><span class="w" id="mwFTo"> </span><span class="n" id="mwFTs">extender</span><span class="w" id="mwFTw"> </span><span class="o" id="mwFT0">=</span><span class="w" id="mwFT4"> </span><span class="n" id="mwFT8">input</span><span class="w" id="mwFUA"> </span><span class="o" id="mwFUE">-></span><span class="w" id="mwFUI"> </span><span class="n" id="mwFUM">input</span><span class="w" id="mwFUQ"> </span><span class="o" id="mwFUU">+</span><span class="w" id="mwFUY"> </span><span class="s" id="mwFUc">" Extended"</span><span class="p" id="mwFUg">;</span>

Lambdas cannot specify throws clauses. Lambdas implement some target functional interface (such as java.lang.Runnable, etc.). Lambdas themselves are not complete expressions of concrete types, but rather poly expressions, whose type are influenced by their surrounding target type rather than entirely by their own content.

<span id="mwFVI"></span><span class="kn" id="mwFVM">import</span><span class="w" id="mwFVQ"> </span><span class="nn" id="mwFVU">java.util.function.Function</span><span class="p" id="mwFVY">;</span> <span class="c1" id="mwFVc">// Invalid, as lambda expressions themselves have no standalone type</span> <span class="kd" id="mwFVg">var</span><span class="w" id="mwFVk"> </span><span class="n" id="mwFVo">f</span><span class="w" id="mwFVs"> </span><span class="o" id="mwFVw">=</span><span class="w" id="mwFV0"> </span><span class="p" id="mwFV4">(</span><span class="kt" id="mwFV8">int</span><span class="w" id="mwFWA"> </span><span class="n" id="mwFWE">x</span><span class="p" id="mwFWI">)</span><span class="w" id="mwFWM"> </span><span class="o" id="mwFWQ">-></span><span class="w" id="mwFWU"> </span><span class="n" id="mwFWY">x</span><span class="w" id="mwFWc"> </span><span class="o" id="mwFWg">+</span><span class="w" id="mwFWk"> </span><span class="mi" id="mwFWo">1</span><span class="p" id="mwFWs">;</span> <span class="c1" id="mwFWw">// Should instead be:</span> <span class="n" id="mwFW0">Function</span><span class="o" id="mwFW4"><</span><span class="n" id="mwFW8">Integer</span><span class="p" id="mwFXA">,</span><span class="w" id="mwFXE"> </span><span class="n" id="mwFXI">Integer</span><span class="o" id="mwFXM">></span><span class="w" id="mwFXQ"> </span><span class="n" id="mwFXU">f</span><span class="w" id="mwFXY"> </span><span class="o" id="mwFXc">=</span><span class="w" id="mwFXg"> </span><span class="n" id="mwFXk">x</span><span class="w" id="mwFXo"> </span><span class="o" id="mwFXs">-></span><span class="w" id="mwFXw"> </span><span class="n" id="mwFX0">x</span><span class="w" id="mwFX4"> </span><span class="o" id="mwFX8">+</span><span class="w" id="mwFYA"> </span><span class="mi" id="mwFYE">1</span><span class="p" id="mwFYI">;</span>

If a lambda implements a functional interface which extends java.lang.Serializable, then when the lambda is serialized, it becomes a java.lang.invoke.SerializedLambda, capturing information about the lambda itself, called its "serialized form". This is necessary, because lambda implementation classes are synthetic and JVM-specific, and must therefore be reconstructed exactly in another JVM invocation. Much like in C++, lambda type names are synthetic and compiler-generated with unspecified implementation details.

<span id="mwFZA"></span><span class="n" id="mwFZE">Runnable</span><span class="w" id="mwFZI"> </span><span class="n" id="mwFZM">r</span><span class="w" id="mwFZQ"> </span><span class="o" id="mwFZU">=</span><span class="w" id="mwFZY"> </span><span class="p" id="mwFZc">()</span><span class="w" id="mwFZg"> </span><span class="o" id="mwFZk">-></span><span class="w" id="mwFZo"> </span><span class="n" id="mwFZs">System</span><span class="p" id="mwFZw">.</span><span class="na" id="mwFZ0">out</span><span class="p" id="mwFZ4">.</span><span class="na" id="mwFZ8">println</span><span class="p" id="mwFaA">(</span><span class="s" id="mwFaE">"Hello"</span><span class="p" id="mwFaI">);</span> <span class="c1" id="mwFaM">// Could print something like:</span> <span class="c1" id="mwFaQ">// class org.wikipedia.examples.Main$$Lambda$1/0x0000000800b00440</span> <span class="n" id="mwFaU">System</span><span class="p" id="mwFaY">.</span><span class="na" id="mwFac">out</span><span class="p" id="mwFag">.</span><span class="na" id="mwFak">println</span><span class="p" id="mwFao">(</span><span class="n" id="mwFas">r</span><span class="p" id="mwFaw">.</span><span class="na" id="mwFa0">getClass</span><span class="p" id="mwFa4">());</span>

Lambdas do not generate class files, but rather emit an invokedynamic instruction on the JVM, which the runtime uses to create a suitable implementation class.

Capturing lambdas are typically distinct objects, due to requiring stored captured state, however non-capturing lambdas may potentially be singleton.

<span id="mwFbY"></span><span class="n" id="mwFbc">Runnable</span><span class="w" id="mwFbg"> </span><span class="n" id="mwFbk">r1</span><span class="w" id="mwFbo"> </span><span class="o" id="mwFbs">=</span><span class="w" id="mwFbw"> </span><span class="p" id="mwFb0">()</span><span class="w" id="mwFb4"> </span><span class="o" id="mwFb8">-></span><span class="w" id="mwFcA"> </span><span class="p" id="mwFcE">{};</span> <span class="n" id="mwFcI">Runnable</span><span class="w" id="mwFcM"> </span><span class="n" id="mwFcQ">r2</span><span class="w" id="mwFcU"> </span><span class="o" id="mwFcY">=</span><span class="w" id="mwFcc"> </span><span class="p" id="mwFcg">()</span><span class="w" id="mwFck"> </span><span class="o" id="mwFco">-></span><span class="w" id="mwFcs"> </span><span class="p" id="mwFcw">{};</span> <span class="n" id="mwFc0">System</span><span class="p" id="mwFc4">.</span><span class="na" id="mwFc8">out</span><span class="p" id="mwFdA">.</span><span class="na" id="mwFdE">println</span><span class="p" id="mwFdI">(</span><span class="n" id="mwFdM">r1</span><span class="w" id="mwFdQ"> </span><span class="o" id="mwFdU">==</span><span class="w" id="mwFdY"> </span><span class="n" id="mwFdc">r2</span><span class="p" id="mwFdg">);</span><span class="w" id="mwFdk"> </span><span class="c1" id="mwFdo">// May print true or false; determined by the JVM</span>

However, unlike C++, lambda types are not part of the language model; nothing about its runtime class may be depended upon, whereas in C++ the lambda type may still be extracted with decltype to obtain a real unique closure type; a lambda's java.lang.Class<?> cannot be referenced in code.

Method references

Java allows method references using the operator :: (it is not related to the C++ namespace qualifying operator ::). It is not necessary to use lambdas when there already is a named method compatible with the interface. This method can be passed instead of a lambda using a method reference. There are several types of method references:

The code above which calls runCalculation could be replaced with the following using the method references:

<span id="mwFlU"></span><span class="n" id="mwFlY">runCalculation</span><span class="p" id="mwFlc">(</span><span class="n" id="mwFlg">Integer</span><span class="p" id="mwFlk">::</span><span class="n" id="mwFlo">sum</span><span class="p" id="mwFls">);</span>

Note that in Java, constructors are not considered methods, and thus X::X does not exist; a constructor reference is retrieved with X::new.

Inheritance

Interfaces can inherit from other interfaces just like classes. Unlike classes it is allowed to inherit from multiple interfaces. However, it is possible that several interfaces have a field with the same name, in which case it becomes a single ambiguous member, which cannot be accessed.

<span id="mwFmM"></span><span class="cm" id="mwFmQ">/* Class implementing this interface must implement methods of both</span> <span class="cm" id="mwFmU">ActionListener and RequestListener */</span> <span class="kd" id="mwFmY">interface</span> <span class="nc" id="mwFmc">EventListener</span><span class="w" id="mwFmg"> </span><span class="kd" id="mwFmk">extends</span><span class="w" id="mwFmo"> </span><span class="n" id="mwFms">ActionListener</span><span class="p" id="mwFmw">,</span><span class="w" id="mwFm0"> </span><span class="n" id="mwFm4">RequestListener</span><span class="w" id="mwFm8"> </span><span class="p" id="mwFnA">{</span><span class="w" id="mwFnE"> </span> <span class="p" id="mwFnI">}</span>

Default methods

Java SE 8 introduced default methods to interfaces which allows developers to add new methods to existing interfaces without breaking compatibility with the classes already implementing the interface. Unlike regular interface methods, default methods have a body which will get called in the case if the implementing class does not override it.

<span id="mwFnc"></span><span class="kd" id="mwFng">interface</span> <span class="nc" id="mwFnk">StringManipulator</span><span class="w" id="mwFno"> </span><span class="p" id="mwFns">{</span> <span class="w" id="mwFnw"> </span><span class="n" id="mwFn0">String</span><span class="w" id="mwFn4"> </span><span class="nf" id="mwFn8">extendString</span><span class="p" id="mwFoA">(</span><span class="n" id="mwFoE">String</span><span class="w" id="mwFoI"> </span><span class="n" id="mwFoM">input</span><span class="p" id="mwFoQ">);</span> <span class="w" id="mwFoU"> </span> <span class="w" id="mwFoY"> </span><span class="c1" id="mwFoc">// A method which is optional to implement</span> <span class="w" id="mwFog"> </span><span class="k" id="mwFok">default</span><span class="w" id="mwFoo"> </span><span class="n" id="mwFos">String</span><span class="w" id="mwFow"> </span><span class="nf" id="mwFo0">shortenString</span><span class="p" id="mwFo4">(</span><span class="n" id="mwFo8">String</span><span class="w" id="mwFpA"> </span><span class="n" id="mwFpE">input</span><span class="p" id="mwFpI">)</span><span class="w" id="mwFpM"> </span><span class="p" id="mwFpQ">{</span> <span class="w" id="mwFpU"> </span><span class="k" id="mwFpY">return</span><span class="w" id="mwFpc"> </span><span class="n" id="mwFpg">input</span><span class="p" id="mwFpk">.</span><span class="na" id="mwFpo">substring</span><span class="p" id="mwFps">(</span><span class="mi" id="mwFpw">1</span><span class="p" id="mwFp0">);</span> <span class="w" id="mwFp4"> </span><span class="p" id="mwFp8">}</span> <span class="p" id="mwFqA">}</span> <span class="c1" id="mwFqE">// This is a valid class despite not implementing all the methods</span> <span class="kd" id="mwFqI">class</span> <span class="nc" id="mwFqM">PartialStringManipulator</span><span class="w" id="mwFqQ"> </span><span class="kd" id="mwFqU">implements</span><span class="w" id="mwFqY"> </span><span class="n" id="mwFqc">StringManipulator</span><span class="w" id="mwFqg"> </span><span class="p" id="mwFqk">{</span> <span class="w" id="mwFqo"> </span><span class="nd" id="mwFqs">@Override</span> <span class="w" id="mwFqw"> </span><span class="kd" id="mwFq0">public</span><span class="w" id="mwFq4"> </span><span class="n" id="mwFq8">String</span><span class="w" id="mwFrA"> </span><span class="nf" id="mwFrE">extendString</span><span class="p" id="mwFrI">(</span><span class="n" id="mwFrM">String</span><span class="w" id="mwFrQ"> </span><span class="n" id="mwFrU">input</span><span class="p" id="mwFrY">)</span><span class="w" id="mwFrc"> </span><span class="p" id="mwFrg">{</span> <span class="w" id="mwFrk"> </span><span class="k" id="mwFro">return</span><span class="w" id="mwFrs"> </span><span class="n" id="mwFrw">String</span><span class="p" id="mwFr0">.</span><span class="na" id="mwFr4">format</span><span class="p" id="mwFr8">(</span><span class="s" id="mwFsA">"%s Extended"</span><span class="p" id="mwFsE">,</span><span class="w" id="mwFsI"> </span><span class="n" id="mwFsM">input</span><span class="p" id="mwFsQ">);</span> <span class="w" id="mwFsU"> </span><span class="p" id="mwFsY">}</span> <span class="p" id="mwFsc">}</span>

Static methods

Static methods is another language feature introduced in Java SE 8. They behave in exactly the same way as in the classes.

<span id="mwFs4"></span><span class="kd" id="mwFs8">interface</span> <span class="nc" id="mwFtA">StringUtils</span><span class="w" id="mwFtE"> </span><span class="p" id="mwFtI">{</span> <span class="w" id="mwFtM"> </span><span class="kd" id="mwFtQ">static</span><span class="w" id="mwFtU"> </span><span class="n" id="mwFtY">String</span><span class="w" id="mwFtc"> </span><span class="nf" id="mwFtg">shortenByOneSymbol</span><span class="p" id="mwFtk">(</span><span class="n" id="mwFto">String</span><span class="w" id="mwFts"> </span><span class="n" id="mwFtw">input</span><span class="p" id="mwFt0">)</span><span class="w" id="mwFt4"> </span><span class="p" id="mwFt8">{</span> <span class="w" id="mwFuA"> </span><span class="k" id="mwFuE">return</span><span class="w" id="mwFuI"> </span><span class="n" id="mwFuM">input</span><span class="p" id="mwFuQ">.</span><span class="na" id="mwFuU">substring</span><span class="p" id="mwFuY">(</span><span class="mi" id="mwFuc">1</span><span class="p" id="mwFug">);</span> <span class="w" id="mwFuk"> </span><span class="p" id="mwFuo">}</span> <span class="p" id="mwFus">}</span> <span class="n" id="mwFuw">StringUtils</span><span class="p" id="mwFu0">.</span><span class="na" id="mwFu4">shortenByOneSymbol</span><span class="p" id="mwFu8">(</span><span class="s" id="mwFvA">"Test"</span><span class="p" id="mwFvE">);</span>

Private methods

Private methods were added in the Java 9 release. An interface can have a method with a body marked as private, in which case it will not be visible to inheriting classes. It can be called from default methods for the purposes of code reuse.

<span id="mwFvY"></span><span class="kd" id="mwFvc">interface</span> <span class="nc" id="mwFvg">Logger</span><span class="w" id="mwFvk"> </span><span class="p" id="mwFvo">{</span> <span class="w" id="mwFvs"> </span><span class="k" id="mwFvw">default</span><span class="w" id="mwFv0"> </span><span class="kt" id="mwFv4">void</span><span class="w" id="mwFv8"> </span><span class="nf" id="mwFwA">logError</span><span class="p" id="mwFwE">()</span><span class="w" id="mwFwI"> </span><span class="p" id="mwFwM">{</span> <span class="w" id="mwFwQ"> </span><span class="n" id="mwFwU">log</span><span class="p" id="mwFwY">(</span><span class="n" id="mwFwc">Level</span><span class="p" id="mwFwg">.</span><span class="na" id="mwFwk">ERROR</span><span class="p" id="mwFwo">);</span> <span class="w" id="mwFws"> </span><span class="p" id="mwFww">}</span> <span class="w" id="mwFw0"> </span><span class="k" id="mwFw4">default</span><span class="w" id="mwFw8"> </span><span class="kt" id="mwFxA">void</span><span class="w" id="mwFxE"> </span><span class="nf" id="mwFxI">logInfo</span><span class="p" id="mwFxM">()</span><span class="w" id="mwFxQ"> </span><span class="p" id="mwFxU">{</span> <span class="w" id="mwFxY"> </span><span class="n" id="mwFxc">log</span><span class="p" id="mwFxg">(</span><span class="n" id="mwFxk">Level</span><span class="p" id="mwFxo">.</span><span class="na" id="mwFxs">INFO</span><span class="p" id="mwFxw">);</span> <span class="w" id="mwFx0"> </span><span class="p" id="mwFx4">}</span> <span class="w" id="mwFx8"> </span><span class="kd" id="mwFyA">private</span><span class="w" id="mwFyE"> </span><span class="kt" id="mwFyI">void</span><span class="w" id="mwFyM"> </span><span class="nf" id="mwFyQ">log</span><span class="p" id="mwFyU">(</span><span class="n" id="mwFyY">Level</span><span class="w" id="mwFyc"> </span><span class="n" id="mwFyg">level</span><span class="p" id="mwFyk">)</span><span class="w" id="mwFyo"> </span><span class="p" id="mwFys">{</span> <span class="w" id="mwFyw"> </span><span class="n" id="mwFy0">SystemLogger</span><span class="p" id="mwFy4">.</span><span class="na" id="mwFy8">log</span><span class="p" id="mwFzA">(</span><span class="n" id="mwFzE">level</span><span class="p" id="mwFzI">.</span><span class="na" id="mwFzM">id</span><span class="p" id="mwFzQ">);</span> <span class="w" id="mwFzU"> </span><span class="p" id="mwFzY">}</span> <span class="p" id="mwFzc">}</span>

Annotations

Annotations in Java are a way to embed metadata into code. This language feature was introduced in J2SE 5.0.

Annotation types

Java has a set of predefined annotation types, but it is allowed to define new ones. An annotation type declaration is a special type of an interface declaration. They are declared in the same way as the interfaces, except the interface keyword is preceded by the @ sign. Java annotations are interfaces and are implicitly extended from java.lang.annotation.Annotation and cannot be extended from anything else. Unlike C++ annotations, which may be any object, Java annotations cannot be instantiated into a real runtime object.

<span id="mwF0U"></span><span class="nd" id="mwF0Y">@interface</span><span class="w" id="mwF0c"> </span><span class="n" id="mwF0g">BlockingOperations</span><span class="w" id="mwF0k"> </span><span class="p" id="mwF0o">{</span> <span class="p" id="mwF0s">}</span>

Annotations may have the same declarations in the body as the common interfaces, in addition they are allowed to include enums and annotations. The main difference is that abstract method declarations must not have any parameters or throw any exceptions. Also they may have a default value, which is declared using the default keyword after the method name:

<span id="mwF1A"></span><span class="nd" id="mwF1E">@interface</span><span class="w" id="mwF1I"> </span><span class="n" id="mwF1M">BlockingOperations</span><span class="w" id="mwF1Q"> </span><span class="p" id="mwF1U">{</span> <span class="w" id="mwF1Y"> </span><span class="kt" id="mwF1c">boolean</span><span class="w" id="mwF1g"> </span><span class="nf" id="mwF1k">fileSystemOperations</span><span class="p" id="mwF1o">();</span> <span class="w" id="mwF1s"> </span><span class="kt" id="mwF1w">boolean</span><span class="w" id="mwF10"> </span><span class="nf" id="mwF14">networkOperations</span><span class="p" id="mwF18">()</span><span class="w" id="mwF2A"> </span><span class="k" id="mwF2E">default</span><span class="w" id="mwF2I"> </span><span class="kc" id="mwF2M">false</span><span class="p" id="mwF2Q">;</span> <span class="p" id="mwF2U">}</span>

Usage of annotations

Annotations may be used in any kind of declaration, whether it is package, class (including enums), interface (including annotations), field, method, parameter, constructor, or local variable. Also they can be used with enum constants. Annotations are declared using the @ sign preceding annotation type name, after which element-value pairs are written inside brackets. All elements with no default value must be assigned a value.

<span id="mwF2s"></span><span class="nd" id="mwF2w">@BlockingOperations</span><span class="p" id="mwF20">(</span> <span class="w" id="mwF24"> </span><span class="n" id="mwF28">fileSystemOperations</span><span class="p" id="mwF3A">,</span><span class="w" id="mwF3E"> </span><span class="c1" id="mwF3I">// mandatory</span> <span class="w" id="mwF3M"> </span><span class="n" id="mwF3Q">networkOperations</span><span class="w" id="mwF3U"> </span><span class="o" id="mwF3Y">=</span><span class="w" id="mwF3c"> </span><span class="kc" id="mwF3g">true</span><span class="w" id="mwF3k"> </span><span class="c1" id="mwF3o">// optional</span> <span class="p" id="mwF3s">)</span> <span class="kt" id="mwF3w">void</span><span class="w" id="mwF30"> </span><span class="nf" id="mwF34">openOutputStream</span><span class="p" id="mwF38">()</span><span class="w" id="mwF4A"> </span><span class="p" id="mwF4E">{</span><span class="w" id="mwF4I"> </span> <span class="w" id="mwF4M"> </span><span class="c1" id="mwF4Q">// annotated method</span> <span class="p" id="mwF4U">}</span>

Besides the generic form, there are two other forms to declare an annotation, which are shorthands. Marker annotation is a short form, it is used when no values are assigned to elements:

<span id="mwF4o"></span><span class="nd" id="mwF4s">@Unused</span><span class="w" id="mwF4w"> </span><span class="c1" id="mwF40">// Shorthand for @Unused()</span> <span class="kt" id="mwF44">void</span><span class="w" id="mwF48"> </span><span class="nf" id="mwF5A">travelToJupiter</span><span class="p" id="mwF5E">()</span><span class="w" id="mwF5I"> </span><span class="p" id="mwF5M">{</span> <span class="p" id="mwF5Q">}</span>

The other short form is called single element annotation. It is used with annotations types containing only one element or in the case when multiple elements are present, but only one elements lacks a default value. In single element annotation form the element name is omitted and only value is written instead:

<span id="mwF5k"></span><span class="cm" id="mwF5o">/* </span> <span class="cm" id="mwF5s">Equivalent for @BlockingOperations(fileSystemOperations = true).</span> <span class="cm" id="mwF5w">networkOperations has a default value and</span> <span class="cm" id="mwF50">does not have to be assigned a value </span> <span class="cm" id="mwF54">*/</span> <span class="nd" id="mwF58">@BlockingOperations</span><span class="p" id="mwF6A">(</span><span class="kc" id="mwF6E">true</span><span class="p" id="mwF6I">)</span> <span class="kt" id="mwF6M">void</span><span class="w" id="mwF6Q"> </span><span class="nf" id="mwF6U">openOutputStream</span><span class="p" id="mwF6Y">()</span><span class="w" id="mwF6c"> </span><span class="p" id="mwF6g">{</span> <span class="p" id="mwF6k">}</span>

Generics

Generic programming (generics), or parameterized types, or parametric polymorphism, is one of the major features introduced in J2SE 5.0. Before generics were introduced, it was required to declare all the types explicitly. With generics, it became possible to work in a similar manner with different types without declaring the exact types. The main purpose of generics is to ensure type safety and to detect runtime errors during compilation. Unlike C++ templates, generics do not instantiate a specialization for each type, and unlike C#, generics are not reified, and information on the used parameters is not available at runtime due to type erasure (while Kotlin, another JVM language, offers reified generics, it achieves this by inlining the type at the call site). This is because historically, Java lacked generics entirely; thus generics are erased at runtime to allow a generic class X<T> to be compatible with X.

For instance, before generics were introduced, the Java collections framework stored everything as java.lang.Object.

<span id="mwF8Y"></span><span class="kn" id="mwF8c">import</span><span class="w" id="mwF8g"> </span><span class="nn" id="mwF8k">java.util.ArrayList</span><span class="p" id="mwF8o">;</span> <span class="kn" id="mwF8s">import</span><span class="w" id="mwF8w"> </span><span class="nn" id="mwF80">java.util.List</span><span class="p" id="mwF84">;</span> <span class="n" id="mwF88">List</span><span class="w" id="mwF9A"> </span><span class="n" id="mwF9E">names</span><span class="w" id="mwF9I"> </span><span class="o" id="mwF9M">=</span><span class="w" id="mwF9Q"> </span><span class="k" id="mwF9U">new</span><span class="w" id="mwF9Y"> </span><span class="n" id="mwF9c">ArrayList</span><span class="p" id="mwF9g">();</span> <span class="n" id="mwF9k">names</span><span class="p" id="mwF9o">.</span><span class="na" id="mwF9s">add</span><span class="p" id="mwF9w">(</span><span class="s" id="mwF90">"Alice"</span><span class="p" id="mwF94">);</span> <span class="n" id="mwF98">names</span><span class="p" id="mwF-A">.</span><span class="na" id="mwF-E">add</span><span class="p" id="mwF-I">(</span><span class="s" id="mwF-M">"Bob"</span><span class="p" id="mwF-Q">);</span> <span class="n" id="mwF-U">String</span><span class="w" id="mwF-Y"> </span><span class="n" id="mwF-c">first</span><span class="w" id="mwF-g"> </span><span class="o" id="mwF-k">=</span><span class="w" id="mwF-o"> </span><span class="p" id="mwF-s">(</span><span class="n" id="mwF-w">String</span><span class="p" id="mwF-0">)</span><span class="n" id="mwF-4">names</span><span class="p" id="mwF-8">.</span><span class="na" id="mwF_A">get</span><span class="p" id="mwF_E">(</span><span class="mi" id="mwF_I">0</span><span class="p" id="mwF_M">);</span><span class="w" id="mwF_Q"> </span><span class="c1" id="mwF_U">// first = "Alice"</span> <span class="n" id="mwF_Y">names</span><span class="p" id="mwF_c">.</span><span class="na" id="mwF_g">add</span><span class="p" id="mwF_k">(</span><span class="mi" id="mwF_o">1</span><span class="p" id="mwF_s">);</span><span class="w" id="mwF_w"> </span><span class="c1" id="mwF_0">// Allowed</span>

At runtime, generics appear as the lower bound of the type parameter (if no lower bound is specified, this is implicitly java.lang.Object). Because generics are erased, it is not possible to construct a generic type (such as new T()) or check types against a specialization (such as if (names instanceof List<String>)).

Also, generic classes may not extend java.lang.Throwable. This is because a generic exception FooException<T> would erase FooException<String> and FooException<Integer> to the same type at runtime, making the two indistinguishable at runtime. This is unlike C++, where templates have invariant type identity, thus making FooException<int> and FooException<string> different types. However, a generic type may be thrown (as long as it is bounded below by java.lang.Throwable). For example, the following pattern, sometimes known as the generic rethrow or sneaky throw, is used to bypass checked exceptions entirely, such as in the Project Lombok @SneakyThrows attribute.

<span id="mwGDE"></span><span class="kd" id="mwGDI">static</span><span class="w" id="mwGDM"> </span><span class="o" id="mwGDQ"><</span><span class="n" id="mwGDU">T</span><span class="w" id="mwGDY"> </span><span class="kd" id="mwGDc">extends</span><span class="w" id="mwGDg"> </span><span class="n" id="mwGDk">Throwable</span><span class="o" id="mwGDo">></span><span class="w" id="mwGDs"> </span><span class="kt" id="mwGDw">void</span><span class="w" id="mwGD0"> </span><span class="nf" id="mwGD4">sneakyThrow</span><span class="p" id="mwGD8">(</span><span class="n" id="mwGEA">Throwable</span><span class="w" id="mwGEE"> </span><span class="n" id="mwGEI">t</span><span class="p" id="mwGEM">)</span><span class="w" id="mwGEQ"> </span><span class="kd" id="mwGEU">throws</span><span class="w" id="mwGEY"> </span><span class="n" id="mwGEc">T</span><span class="w" id="mwGEg"> </span><span class="p" id="mwGEk">{</span> <span class="w" id="mwGEo"> </span><span class="k" id="mwGEs">throw</span><span class="w" id="mwGEw"> </span><span class="p" id="mwGE0">(</span><span class="n" id="mwGE4">T</span><span class="p" id="mwGE8">)</span><span class="n" id="mwGFA">t</span><span class="p" id="mwGFE">;</span> <span class="p" id="mwGFI">}</span>

This erases T down to java.lang.Throwable, bypassing the checked exception mechanism (which enforces only on types which do not descend from java.lang.Error or java.lang.RuntimeException) entirely.

Generic classes

Classes can be parameterized by adding a type variable inside angle brackets (< and >) following the class name. It makes possible the use of this type variable in class members instead of actual types. There can be more than one type variable, in which case they are declared in a comma-separated list.

It is possible to limit a type variable to a subtype of some specific class or declare an interface that must be implemented by the type. In this case the type variable is appended by the extends keyword followed by a name of the class or the interface. If the variable is constrained by both class and interface or if there are several interfaces, the class name is written first, followed by interface names with & sign used as the delimiter (in a way which resembles an intersection type).

<span id="mwGGQ"></span><span class="kn" id="mwGGU">import</span><span class="w" id="mwGGY"> </span><span class="nn" id="mwGGc">java.util.ArrayList</span><span class="p" id="mwGGg">;</span> <span class="kn" id="mwGGk">import</span><span class="w" id="mwGGo"> </span><span class="nn" id="mwGGs">java.util.Formattable</span><span class="p" id="mwGGw">;</span> <span class="cm" id="mwGG0">/* This class has two type variables, T and V. T must be </span> <span class="cm" id="mwGG4">a subtype of ArrayList and implement Formattable interface */</span> <span class="kd" id="mwGG8">public</span><span class="w" id="mwGHA"> </span><span class="kd" id="mwGHE">class</span> <span class="nc" id="mwGHI">Mapper</span><span class="o" id="mwGHM"><</span><span class="n" id="mwGHQ">T</span><span class="w" id="mwGHU"> </span><span class="kd" id="mwGHY">extends</span><span class="w" id="mwGHc"> </span><span class="n" id="mwGHg">ArrayList</span><span class="w" id="mwGHk"> </span><span class="o" id="mwGHo">&</span><span class="w" id="mwGHs"> </span><span class="n" id="mwGHw">Formattable</span><span class="p" id="mwGH0">,</span><span class="w" id="mwGH4"> </span><span class="n" id="mwGH8">V</span><span class="o" id="mwGIA">></span><span class="w" id="mwGIE"> </span><span class="p" id="mwGII">{</span> <span class="w" id="mwGIM"> </span><span class="kd" id="mwGIQ">public</span><span class="w" id="mwGIU"> </span><span class="kt" id="mwGIY">void</span><span class="w" id="mwGIc"> </span><span class="nf" id="mwGIg">add</span><span class="p" id="mwGIk">(</span><span class="n" id="mwGIo">T</span><span class="w" id="mwGIs"> </span><span class="n" id="mwGIw">array</span><span class="p" id="mwGI0">,</span><span class="w" id="mwGI4"> </span><span class="n" id="mwGI8">V</span><span class="w" id="mwGJA"> </span><span class="n" id="mwGJE">item</span><span class="p" id="mwGJI">)</span><span class="w" id="mwGJM"> </span><span class="p" id="mwGJQ">{</span> <span class="w" id="mwGJU"> </span><span class="c1" id="mwGJY">// array has add method because it is an ArrayList subclass</span> <span class="w" id="mwGJc"> </span><span class="n" id="mwGJg">array</span><span class="p" id="mwGJk">.</span><span class="na" id="mwGJo">add</span><span class="p" id="mwGJs">(</span><span class="n" id="mwGJw">item</span><span class="p" id="mwGJ0">);</span> <span class="w" id="mwGJ4"> </span><span class="p" id="mwGJ8">}</span> <span class="p" id="mwGKA">}</span>

When a variable of a parameterized type is declared or an instance is created, its type is written exactly in the same format as in the class header, except the actual type is written in the place of the type variable declaration.

<span id="mwGKQ"></span><span class="cm" id="mwGKU">/* Mapper is created with CustomList as T and Integer as V.</span> <span class="cm" id="mwGKY">CustomList must be a subclass of ArrayList and implement Formattable */</span> <span class="n" id="mwGKc">Mapper</span><span class="o" id="mwGKg"><</span><span class="n" id="mwGKk">CustomList</span><span class="p" id="mwGKo">,</span><span class="w" id="mwGKs"> </span><span class="n" id="mwGKw">Integer</span><span class="o" id="mwGK0">></span><span class="w" id="mwGK4"> </span><span class="n" id="mwGK8">mapper</span><span class="w" id="mwGLA"> </span><span class="o" id="mwGLE">=</span><span class="w" id="mwGLI"> </span><span class="k" id="mwGLM">new</span><span class="w" id="mwGLQ"> </span><span class="n" id="mwGLU">Mapper</span><span class="o" id="mwGLY"><</span><span class="n" id="mwGLc">CustomList</span><span class="p" id="mwGLg">,</span><span class="w" id="mwGLk"> </span><span class="n" id="mwGLo">Integer</span><span class="o" id="mwGLs">></span><span class="p" id="mwGLw">();</span>

Since Java SE 7, it is possible to use an empty type list, <> (sometimes called a "diamond"), in place of type arguments, in which case the latter will be inferred. This is sometimes called the "diamond operator", even though it is not actually an operator, but rather an empty type list. The following code in Java SE 7 is equivalent to the code in the previous example:

<span id="mwGME"></span><span class="n" id="mwGMI">Mapper</span><span class="o" id="mwGMM"><</span><span class="n" id="mwGMQ">CustomList</span><span class="p" id="mwGMU">,</span><span class="w" id="mwGMY"> </span><span class="n" id="mwGMc">Integer</span><span class="o" id="mwGMg">></span><span class="w" id="mwGMk"> </span><span class="n" id="mwGMo">mapper</span><span class="w" id="mwGMs"> </span><span class="o" id="mwGMw">=</span><span class="w" id="mwGM0"> </span><span class="k" id="mwGM4">new</span><span class="w" id="mwGM8"> </span><span class="n" id="mwGNA">Mapper</span><span class="o" id="mwGNE"><></span><span class="p" id="mwGNI">();</span>

When declaring a variable for a parameterized type, it is possible to use wildcards instead of explicit type names. Wildcards are expressed by writing ? sign instead of the actual type. It is possible to limit possible types to the subclasses or superclasses of some specific class by writing the extends keyword or the super keyword correspondingly followed by the class name.

<span id="mwGNo"></span><span class="cm" id="mwGNs">/* Any Mapper instance with CustomList as the first parameter</span> <span class="cm" id="mwGNw">may be used regardless of the second one.*/</span> <span class="n" id="mwGN0">Mapper</span><span class="o" id="mwGN4"><</span><span class="n" id="mwGN8">CustomList</span><span class="p" id="mwGOA">,</span><span class="w" id="mwGOE"> </span><span class="o" id="mwGOI">?></span><span class="w" id="mwGOM"> </span><span class="n" id="mwGOQ">mapper</span><span class="p" id="mwGOU">;</span> <span class="n" id="mwGOY">mapper</span><span class="w" id="mwGOc"> </span><span class="o" id="mwGOg">=</span><span class="w" id="mwGOk"> </span><span class="k" id="mwGOo">new</span><span class="w" id="mwGOs"> </span><span class="n" id="mwGOw">Mapper</span><span class="o" id="mwGO0"><</span><span class="n" id="mwGO4">CustomList</span><span class="p" id="mwGO8">,</span><span class="w" id="mwGPA"> </span><span class="n" id="mwGPE">Boolean</span><span class="o" id="mwGPI">></span><span class="p" id="mwGPM">();</span> <span class="n" id="mwGPQ">mapper</span><span class="w" id="mwGPU"> </span><span class="o" id="mwGPY">=</span><span class="w" id="mwGPc"> </span><span class="k" id="mwGPg">new</span><span class="w" id="mwGPk"> </span><span class="n" id="mwGPo">Mapper</span><span class="o" id="mwGPs"><</span><span class="n" id="mwGPw">CustomList</span><span class="p" id="mwGP0">,</span><span class="w" id="mwGP4"> </span><span class="n" id="mwGP8">Integer</span><span class="o" id="mwGQA">></span><span class="p" id="mwGQE">();</span> <span class="cm" id="mwGQI">/* Will not accept types that use anything but</span> <span class="cm" id="mwGQM">a subclass of Number as the second parameter */</span> <span class="kt" id="mwGQQ">void</span><span class="w" id="mwGQU"> </span><span class="nf" id="mwGQY">addMapper</span><span class="p" id="mwGQc">(</span><span class="n" id="mwGQg">Mapper</span><span class="o" id="mwGQk"><?</span><span class="p" id="mwGQo">,</span><span class="w" id="mwGQs"> </span><span class="o" id="mwGQw">?</span><span class="w" id="mwGQ0"> </span><span class="kd" id="mwGQ4">extends</span><span class="w" id="mwGQ8"> </span><span class="n" id="mwGRA">Number</span><span class="o" id="mwGRE">></span><span class="w" id="mwGRI"> </span><span class="n" id="mwGRM">mapper</span><span class="p" id="mwGRQ">)</span><span class="w" id="mwGRU"> </span><span class="p" id="mwGRY">{</span> <span class="p" id="mwGRc">}</span>

Generic methods and constructors

Usage of generics may be limited to some particular methods, this concept applies to constructors as well. To declare a parameterized method, type variables are written before the return type of the method in the same format as for the generic classes. In the case of constructor, type variables are declared before the constructor name.

<span id="mwGRw"></span><span class="kd" id="mwGR0">class</span> <span class="nc" id="mwGR4">Mapper</span><span class="w" id="mwGR8"> </span><span class="p" id="mwGSA">{</span> <span class="w" id="mwGSE"> </span><span class="c1" id="mwGSI">// The class is not generic, the constructor is</span> <span class="w" id="mwGSM"> </span><span class="o" id="mwGSQ"><</span><span class="n" id="mwGSU">T</span><span class="p" id="mwGSY">,</span><span class="w" id="mwGSc"> </span><span class="n" id="mwGSg">V</span><span class="o" id="mwGSk">></span><span class="w" id="mwGSo"> </span><span class="nf" id="mwGSs">Mapper</span><span class="p" id="mwGSw">(</span><span class="n" id="mwGS0">T</span><span class="w" id="mwGS4"> </span><span class="n" id="mwGS8">array</span><span class="p" id="mwGTA">,</span><span class="w" id="mwGTE"> </span><span class="n" id="mwGTI">V</span><span class="w" id="mwGTM"> </span><span class="n" id="mwGTQ">item</span><span class="p" id="mwGTU">)</span><span class="w" id="mwGTY"> </span><span class="p" id="mwGTc">{}</span> <span class="p" id="mwGTg">}</span> <span class="cm" id="mwGTk">/* This method will accept only arrays of the same type as</span> <span class="cm" id="mwGTo">the searched item type or its subtype */</span> <span class="kd" id="mwGTs">static</span><span class="w" id="mwGTw"> </span><span class="o" id="mwGT0"><</span><span class="n" id="mwGT4">T</span><span class="p" id="mwGT8">,</span><span class="w" id="mwGUA"> </span><span class="n" id="mwGUE">V</span><span class="w" id="mwGUI"> </span><span class="kd" id="mwGUM">extends</span><span class="w" id="mwGUQ"> </span><span class="n" id="mwGUU">T</span><span class="o" id="mwGUY">></span><span class="w" id="mwGUc"> </span><span class="kt" id="mwGUg">boolean</span><span class="w" id="mwGUk"> </span><span class="nf" id="mwGUo">contains</span><span class="p" id="mwGUs">(</span><span class="n" id="mwGUw">T</span><span class="w" id="mwGU0"> </span><span class="n" id="mwGU4">item</span><span class="p" id="mwGU8">,</span><span class="w" id="mwGVA"> </span><span class="n" id="mwGVE">V</span><span class="o" id="mwGVI">[]</span><span class="w" id="mwGVM"> </span><span class="n" id="mwGVQ">arr</span><span class="p" id="mwGVU">)</span><span class="w" id="mwGVY"> </span><span class="p" id="mwGVc">{</span> <span class="w" id="mwGVg"> </span><span class="k" id="mwGVk">for</span><span class="w" id="mwGVo"> </span><span class="p" id="mwGVs">(</span><span class="n" id="mwGVw">T</span><span class="w" id="mwGV0"> </span><span class="n" id="mwGV4">currentItem</span><span class="w" id="mwGV8"> </span><span class="p" id="mwGWA">:</span><span class="w" id="mwGWE"> </span><span class="n" id="mwGWI">arr</span><span class="p" id="mwGWM">)</span><span class="w" id="mwGWQ"> </span><span class="p" id="mwGWU">{</span> <span class="w" id="mwGWY"> </span><span class="k" id="mwGWc">if</span><span class="w" id="mwGWg"> </span><span class="p" id="mwGWk">(</span><span class="n" id="mwGWo">item</span><span class="p" id="mwGWs">.</span><span class="na" id="mwGWw">equals</span><span class="p" id="mwGW0">(</span><span class="n" id="mwGW4">currentItem</span><span class="p" id="mwGW8">))</span><span class="w" id="mwGXA"> </span><span class="p" id="mwGXE">{</span> <span class="w" id="mwGXI"> </span><span class="k" id="mwGXM">return</span><span class="w" id="mwGXQ"> </span><span class="kc" id="mwGXU">true</span><span class="p" id="mwGXY">;</span> <span class="w" id="mwGXc"> </span><span class="p" id="mwGXg">}</span> <span class="w" id="mwGXk"> </span><span class="p" id="mwGXo">}</span> <span class="w" id="mwGXs"> </span><span class="k" id="mwGXw">return</span><span class="w" id="mwGX0"> </span><span class="kc" id="mwGX4">false</span><span class="p" id="mwGX8">;</span> <span class="p" id="mwGYA">}</span>

Generic interfaces

Interfaces can be parameterized in the similar manner as the classes.

<span id="mwGYU"></span><span class="kd" id="mwGYY">interface</span> <span class="nc" id="mwGYc">Expandable</span><span class="o" id="mwGYg"><</span><span class="n" id="mwGYk">T</span><span class="w" id="mwGYo"> </span><span class="kd" id="mwGYs">extends</span><span class="w" id="mwGYw"> </span><span class="n" id="mwGY0">Number</span><span class="o" id="mwGY4">></span><span class="w" id="mwGY8"> </span><span class="p" id="mwGZA">{</span> <span class="w" id="mwGZE"> </span><span class="kt" id="mwGZI">void</span><span class="w" id="mwGZM"> </span><span class="nf" id="mwGZQ">addItem</span><span class="p" id="mwGZU">(</span><span class="n" id="mwGZY">T</span><span class="w" id="mwGZc"> </span><span class="n" id="mwGZg">item</span><span class="p" id="mwGZk">);</span> <span class="p" id="mwGZo">}</span> <span class="c1" id="mwGZs">// This class is parameterized</span> <span class="kd" id="mwGZw">class</span> <span class="nc" id="mwGZ0">MyArray</span><span class="o" id="mwGZ4"><</span><span class="n" id="mwGZ8">T</span><span class="w" id="mwGaA"> </span><span class="kd" id="mwGaE">extends</span><span class="w" id="mwGaI"> </span><span class="n" id="mwGaM">Number</span><span class="o" id="mwGaQ">></span><span class="w" id="mwGaU"> </span><span class="kd" id="mwGaY">implements</span><span class="w" id="mwGac"> </span><span class="n" id="mwGag">Expandable</span><span class="o" id="mwGak"><</span><span class="n" id="mwGao">T</span><span class="o" id="mwGas">></span><span class="w" id="mwGaw"> </span><span class="p" id="mwGa0">{</span> <span class="w" id="mwGa4"> </span><span class="kt" id="mwGa8">void</span><span class="w" id="mwGbA"> </span><span class="nf" id="mwGbE">addItem</span><span class="p" id="mwGbI">(</span><span class="n" id="mwGbM">T</span><span class="w" id="mwGbQ"> </span><span class="n" id="mwGbU">item</span><span class="p" id="mwGbY">)</span><span class="w" id="mwGbc"> </span><span class="p" id="mwGbg">{</span> <span class="w" id="mwGbk"> </span><span class="p" id="mwGbo">}</span> <span class="p" id="mwGbs">}</span> <span class="c1" id="mwGbw">// And this is not and uses an explicit type instead</span> <span class="kd" id="mwGb0">class</span> <span class="nc" id="mwGb4">IntegerArray</span><span class="w" id="mwGb8"> </span><span class="kd" id="mwGcA">implements</span><span class="w" id="mwGcE"> </span><span class="n" id="mwGcI">Expandable</span><span class="o" id="mwGcM"><</span><span class="n" id="mwGcQ">Integer</span><span class="o" id="mwGcU">></span><span class="w" id="mwGcY"> </span><span class="p" id="mwGcc">{</span> <span class="w" id="mwGcg"> </span><span class="kt" id="mwGck">void</span><span class="w" id="mwGco"> </span><span class="nf" id="mwGcs">addItem</span><span class="p" id="mwGcw">(</span><span class="n" id="mwGc0">Integer</span><span class="w" id="mwGc4"> </span><span class="n" id="mwGc8">item</span><span class="p" id="mwGdA">)</span><span class="w" id="mwGdE"> </span><span class="p" id="mwGdI">{</span> <span class="w" id="mwGdM"> </span><span class="p" id="mwGdQ">}</span> <span class="p" id="mwGdU">}</span>