Java is a programming language created by James Gosling from Sun Microsystems (Sun) in 1991. Java allows to write a program and run it on multiple operating systems. The first publicly available version of Java (Java 1.0) was released in 1995. Sun Microsystems was acquired by the Oracle Corporation in 2010. Oracle has now the steermanship for Java. In 2006 Sun started to make Java available under the GNU General Public License (GPL). Oracle continues this project called OpenJDK.

Currently every 3 months a new version of Java is released. Certain versions are supported for 2 years and are called long-term maintenance (LTV), regular versions only for 6 months. The current LTM version of Java is Java 21.

Java is defined by a specification and consists of a programming language, a compiler, core libraries and a runtime (Java virtual machine).

The Java language was designed with the following properties:

Java is case-sensitive, e.g., variables called myValue and myvalue are treated as different variables.

The Java virtual machine (JVM) is a software implementation of a computer that executes programs like a real machine.

The Java virtual machine is written specifically for a specific operating system, e.g., for Linux a special implementation is required as well as for Windows.

Java programs are compiled by the Java compiler into bytecode. The Java virtual machine interprets this bytecode and executes the Java program.

Java source files are written as plain text documents. The programmer uses a text editor or an Integrated Development Environment (IDE) for creating these text documents. An IDE supports the programmer in the task of writing code, e.g., it provides auto-formating of the source code, highlighting of the important keywords, etc. Typical Java IDEs are Visual Studio Code or the Eclipse IDE.

The Java runtime executes bytecode instructions. Therefore the text files must be converted from text to bytecode. These instructions are stored in .class files and can be executed by the Java Virtual Machine.

This can be done via the Java compiler(javac), either by the programmer by calling the Java compiler directly or by the IDE.

The Java runtime automatically frees the memory which is not referred to by other objects. The Java garbage collector checks all object references and finds the objects which can be automatically released.

While the garbage collector relieves the programmer from the need to explicitly manage memory, the programmer still need to ensure that he does not keep unneeded object references, otherwise the garbage collector cannot release the associated memory. Keeping unneeded object references are typically called memory leaks.

The classpath defines where the Java compiler and Java runtime look for .class files to load. These instructions can be used in the Java program.

For example, if you want to use an external Java library you have to add this library to your classpath to use it in your program.

To run Java programs, you:

You can test whether the JRE is correctly installed via a console. To open a console on Windows: Win+R, enter cmd and press Enter). Now type in the following command:

If the JRE is correctly installed, this commands prints information about your Java installation. In this case you can skip the Java installation description.

If the command line returns the information that the program could not be found, you have to install Java.

A Java runtime is provided by multiple suppliers, one source of a Java runtime is https://adoptium.net/. It contains instructions how to install Java for all supported platforms. For the Windows and Mac platform you find also native installer software.

If you have problems installing Java on your system, search via Google for How to install Java runtime on YOUR OS. Of course, replace YOUR OS with your operating system, e.g., Windows, Ubuntu, Mac OS X, etc. This should result in helpful links.

The following Java program is developed under Linux using a text editor and the command line. The process on other operating system should be similar, but is not covered in this description.

Select or create a new directory which will be used for your Java development. In this description the path \home\vogella\javastarter is used. On Microsoft Windows you might want to use c:\temp\javastarter. This path is called javadir in the following description.

Open a text editor which supports plain text, e.g., gedit under Linux or Notepad under Windows and write the following source code.

Save the source code in your javadir directory with the HelloWorld.java filename. The name of a Java source file must always equal the class name (within the source code) and end with the .java extension. In this example the filename must be HelloWorld.java, because the class is called HelloWorld.

Open a shell for command line access.

Switch to the javadir directory with the command cd javadir, for example, in the above example via the cd \home\vogella\javastarter command. Use the ls command (dir under Microsoft Windows) to verify that the source file is in the directory.

Compile your Java source file into a class file with the following command.

Afterwards list again the content of the directory with the ls or dir command. The directory contains now a file HelloWorld.class. If you see this file, you have successfully compiled your first Java source code into bytecode.

You can now start your compiled Java program. Ensure that you are still in the jardir directory and enter the following command to start your Java program.

The system should write "Hello World" on the command line.

You can use the classpath to run the program from another place in your directory.

Switch to the command line, e.g., under Windows Start  Run cmd. Switch to any directory you want. Type:

If you are not in the directory in which the compiled class is stored, then the system will show an error message: Exception in thread "main" java.lang.NoClassDefFoundError: test/TestClass

To use the class, type the following command. Replace "mydirectory" with the directory which contains the test directory. You should again see the "HelloWorld" output.

A class is a template that describes the data and behavior associated with an instance of that class.

A class is defined by the class keyword and must start with a capital letter. The body of a class is surrounded by {}.

The data associated with a class is stored in variables ; the behavior associated to a class or object is implemented with methods.

A class is contained in a text file with the same name as the class plus the .java extension. It is also possible to define inner classes, these are classes defined within another class, in this case you do not need a separate file for this class.

An object is an instance of a class.

The object is the real element which has data and can perform actions. Each object is created based on the class definition. The class can be seen as the blueprint of an object, i.e., it describes how an object is created.

Java groups classes into functional packages.

Packages are typically used to group classes into logical units. For example, all graphical views of an application might be placed in the same package called com.vogella.webapplication.views.

It is common practice to use the reverse domain name of the company as top level package. For example, the company might own the domain, vogella.com and in this example the Java packages of this company starts with com.vogella.

Other main reason for the usage of packages is to avoid name collisions of classes. A name collision occurs if two programmers give the same fully qualified name to a class. The fully qualified name of a class in Java consists of the package name followed by a dot (.) and the class name.

Without packages, a programmer may create a Java class called Test. Another programmer may create a class with the same name. With the usage of packages you can tell the system which class to call. For example, if the first programmer puts the Test class into package report and the second programmer puts his class into package xmlreader you can distinguish between these classes by using the fully qualified name, e.g, xmlreader.Test or report.Test.

A class can be derived from another class. In this case this class is called a subclass. Another common phrase is that a class extends another class.

The class from which the subclass is derived is called a superclass.

Inheritance allows a class to inherit the behavior and data definitions of another class.

The following codes demonstrates how a class can extend another class. In Java a class can only extend a maximum of one class.

Every object in Java implicitly extends the Object class. The class defines the following methods for every Java object:

In Java an exception is an event to indicate an error during the runtime of an application. So this disrupts the usual flow of the application’s instructions.

In general exceptions are thrown up in the call hierarchy until they get catched.

Checked Exceptions are explicitly thrown by methods, which might cause the exception or re-thrown by methods in case a thrown Exception is not caught.

So when calling methods, which throw checked Exceptions the Exceptions have either to be caught or to be re-thrown.

Checked Exceptions are used when an error can be predicted under certain circumstances, e.g., a file which cannot be found.

Runtime Exceptions are Exceptions, which are not explicitly mentioned in the method signature and therefore also do not have to be catched explicitly.

The most famous runtime exception is the NullPointerException, which occurs during runtime, when a method is invoked on an object, which actually is null.

An interfaces is a type similar to a class and is defined via the interface keyword. Interfaces are used to define common behavior of implementing classes. If two classes implement the same interface, other code which work on the interface level, can use objects of both classes.

Like a class an interface defines methods. Classes can implement one or several interfaces. A class which implements an interface must provide an implementation for all abstract methods defined in the interface.

An interface can have abstract methods and _default_methods. A default method is defined via the default keyword at the beginning of the method signature. All other methods defined in an interfaces are public and abstract; explicit declaration of these modifiers is optional.

Interfaces can have constants which are always implicitly public, static and final.

The following code shows an example implementation of an interface.

A class can implement an interface. In this case it must provide concrete implementations of the abstract interface methods. If you implement a method defined by an interface, you can use @Override annotation. This indicates to the Java compiler that you actually want to implement a method defined by this interface. This way the compiler can give you an error in you mis-typed the name of the method or in the number of arguments. The following class implements the MyInterface interface, its must therefore implement the abstract method and can use the default methods.

Before Java 8 evolving interfaces, e.g., adding new methods to an interface, was not possible without breaking existing clients. Java 8 introduced default methods, now you can extend an interface without breaking clients by simply suppling a default implementation with it. Adding such a default method is a source and binary compatible change.

A class can always override a default method to supply a better behavior.

If a class implements two interfaces and if these interfaces provide the same default method, Java resolves the correct method for the class by the following rules:

The following listing demonstrates listing number 3.

In your implementation you can also call the super method you prefer.

All interfaces that have only one method are called functional interfaces. Functional interfaces have the advantage that they can be used together with lambda expressions. See What are lambdas? to learn more about lambdas, e.g., the type of lambdas is a functional interface.

The Java compiler automatically identifies functional interfaces. The only requirement is that they have only one abstract method. However, is possible to capture the design intent with a @FunctionalInterface annotation.

Several default Java interfaces are functional interfaces:

Java also contains the java.util.function package which contains functional interfaces which are frequently used such as:

Annotations provide data about a class that is not part of the programming logic itself. They have no direct effect on the code they annotate. Other components can use this information.

Annotations can be preserved at runtime (RetentionPolicy.RUNTIME) or are only available at development time (RetentionPolicy.SOURCE).

If a class extends another class, it inherits the methods from its superclass. If it wants to change these methods, it can override these methods, i.e., redeclare the methods. This is necessary for an abstract method unless the class itself is defined as abstract.

The @Override annotation can be added to such a method. It is used by the Java compiler to check if the annotated method really overrides a method of an interface or the extended class.

To override a method, you use the same method signature in the source code of the subclass.

To indicate to the reader of the source code and the Java compiler that you have the intention to override a method, you can use the @Override annotation.

The following code demonstrates how you can override a method from a superclass.

It is good practice to always use the @Override annotation. This way the Java compiler validates if you did override all methods as intended and prevents errors.

The @Deprecated annotation can be used on a field, method, constructor or class and indicates that this element is outdated and should not be used anymore. Adding @Deprecated to the class does not deprecate automatically all its fields and methods.

Java supports that annotations can be placed on any type. The following gives several examples assuming the annotations exists.

Variables allow the Java program to store values during the runtime of the program.

A variable can either be a: * primitive variable * reference variable

A primitive variable contains the value. A reference variable contains a reference (pointer) to the object. Hence, if you compare two reference variables, you compare if both point to the same object. To identify if objects contain the same data, use the object1.equals(object2) method call.

Instance variable is associated with an instance of the class (also called object). Access works over these objects.

Instance variables can have any access control and can be marked final or transient. Instance variables marked as final cannot be changed after a value has been assigned to them.

Local (stack) variable declarations cannot have access modifiers. Local variables do not get default values, so they must be initialized before they can be used.

final is the only modifier available to local variables. This modifier defines that the variable cannot be changed after the first assignment.

A method is a block of code with parameters and a return value. It can be called on the object.

Methods can be declared with var-args. In this case the method declares a parameter which accepts everything from zero to many arguments (syntax: type …​ name;) A method can only have one var-args parameter and this must be the last parameter in the method.

Overwrite of a superclass method: A method must be of the exact same return parameter and the same arguments. Also the return parameter must be the same. Overload methods: An overloaded method is a method with the same name, but different arguments. The return type can not be used to overload a method.

A public static method with the following signature can be used to start a Java application. Such a method is typically called main method.

A class contains constructors that are invoked by the Java runtime to create objects based on the class definition.

Constructor declarations look like method declarations except that they use the name of the class and have no return type.

A class can have several constructors with different parameters.

In the following example the constructor of the class expects a parameter.

Each class must define at least one constructor. If no explicit constructor is defined in the Java source file, the compiler implicitly adds a constructor. If the class is sub-classed, then the constructor of the super class is always called implicitly in this case.

In the following example the definition of the constructor without parameters (also known as the empty constructor) is unnecessary. If not specified, the compiler would create one.

The naming convention for creating a constructor is the following: classname (Parameter p1, …​) { }.

Every object is created based on a constructor. This constructor method is the first statement called before anything else can be done with the object.

There are three access modifiers keywords available in Java: * public * protected * private

There are four access levels: public, protected, default and private.

They define how the corresponding element is visible to other components.

If something is declared public, e.g., classes or methods can be freely created or called by other Java objects. If something is declared private, e.g., a method, it can only be accessed within the class in which it is declared.

The access levels protected and default are similar. A protected class can be accessed from the package and sub-classes outside the package, while a default class can get accessed only via the same package.

The following table describes the visibility:

final methods: cannot be overwritten in a subclass abstract method: no method body

synchronized method: thread safe, can be final and have any access control

native methods: platform dependent code, apply only to methods

strictfp: class or method

You have to access a Java class always via its full-qualified name, i.e., the package name plus a . followed by the class name.

You can add import statements into your class file. These allow you to use the related classes in your code without the package qualifier.

Static import allows public static members (fields and methods) of another class to be used in Java code without a class reference.

The feature provides a typesafe mechanism to include constants into code. It also improves code readability and allows Java API designers to write a concise API.

Class methods and class variables are associated with the class and not an instance of the class, i.e., objects. To refer to these elements, you can use the classname and a dot (".") followed by the class method or class variable name.

Class methods and class variables are declared with the static keyword. Class methods are also called static methods and class variables are also called static variables or static fields.

An example for the usage of a static field is println of the following statement: System.out.println("Hello World"). Hereby out is a static field, an object of type PrintStream and you call the println() method on this object.

If you define a static variable, the Java runtime environment associates one class variable for a class no matter how many instances (objects) exist. The static variable can therefore be seen as a global variable.

The following code demonstrates the usage of static fields.

If a variable should be defined as constant, you declare it with the static and the final keyword.

The static method runs without any instance of the class, it cannot directly access non-static variables or methods.

A class and method can be declared as abstract. An abstract class can not be directly instantiated.

If a class has at least one method, which only contains the declaration of the method, but not the implementation, then this class is abstract and can not be instantiated. Sub-classes need then to define the methods except if they are also declared as abstract.

If a class contains an abstract method, it also needs to get defined with the abstract keyword.

The following example shows an abstract class.

While programming Java you have to create several classes, methods, instance variables. The following uses the package test.

A local variable must always be declared in a method.

Create a new Java project called com.vogella.javastarter.exercises1 and a package with the same name.

Create a class called Person.

Add three instance variables to it, one for storing the first name of the person, one for storing the last name and one for storing the age of the Person.

Use the constructor of the Person object to set the values to some default value.

Add a toString method as described by the following coding and solve the TODO. This method is used to convert the object to a String representation.

Create a new class called Main with a public static void main(String[] args). In this method create an instance of the Person class.

Add a constructor to your Person class which takes first name, last name and age as parameter. Assign the values to your instance variables.

In your main method create at least one object of type Person and use System.out.println() with the object as parameter.

Define methods which allow you to read the values of the instance variables and to set them. These methods are called setter and getter.

Getters should start with get followed by the variable name whereby the first letter of the variable is capitalized.

Setter should start with set followed by the variable name whereby the first letter of the variable is capitalized.

For example, the variable called firstName would have the getFirstName() getter method and the setFirstName(String s) setter method.

Change your main method so that you create one Person object and use the setter method to change the last name.

Create a new object called Address. The Address should allow you to store the address of a person.

Add a new instance variable of this type in the Person object. Also, create a getter and setter for the Address object in the Person object.

The following is the expected result after the creation of a Person class and it gets instantiated.

The following is the expected result after the usage of the constructor.

The following is the expected result after the definition of getter and setter methods.

The following is the expected result after the creation of an Address object.

Use the following to convert from other types to Strings

The conversion from string to number is independent from the local settings, e.g., it always uses the English notification for number. In this notification a correct number format is "8.20". The German number "8,20" would result in an error.

To convert from a German number, you have to use the NumberFormat class. The challenge is that when the value is, for example, 98.00 then the NumberFormat class would create a Long which cannot be casted to Double. Hence the following complex conversion class.

int i = (int) double;

Use the following to convert a Date to a SQL date

The if-then statement is a control flow statement. A block of code is only executed when the test specified by the if part evaluates to true. The optional else block is executed when the if part evaluates to false.

The following example code shows a class with two methods. The first method demonstrates the usage of if-then and the second method demonstrates the usage of if-then-else.

The switch statement can be used to handle several alternatives if they are based on the same constant value.

Use == to compare two primitives or to see if two references refer to the same object. Use the equals() method to see if two different objects are equal.

&& and || are both Short Circuit Methods which means that they terminate once the result of an evaluation is already clear. Example (true || …​) is always true while (false && …​) always is always interpreted as false. Usage:

(var !=null && var.method1() …​) ensures that var is not null before doing the real check.

A for loop is a repetition control structure that allows you to write a block of code which is executed a specific number of times. The syntax is the following.

The following shows an example for a for loop.

TIP:For arrays and collections there is also an enhanced for loop available. This loop is covered in the Array description.

A while loop is a repetition control structure that allows you to write a block of code which is executed until a specific condition evaluates to false. The syntax is the following.

The following shows an example for a while loop.

The do-while loop is similar to the while loop, with the exception that the condition is checked after the execution. The syntax is the following.

The following shows an example for a do-while loop.

An array is a container object that holds a fixed number of values of a single type. An item in an array is called an element. Every element can be accessed via an index. The first element in an array is addressed via the 0 index, the second via 1, etc.

Arrays and collections can be processed with a simpler for loop.

The following code demonstrates its usage.

The String class represents character strings. All string literals, for example, "hello", are implemented as instances of this class. An instance of this class is an object. Strings are immutable, e.g., an assignment of a new value to a String object creates a new object.

To concatenate Strings use a StringBuilder.

For memory efficiency Java uses a String pool. The string pool allows string literals to be reused. This is possible because strings in Java are immutable.

If the same string literal is used in several places in the Java code, only one copy of that string is created.

Whenever a String object is created and gets a string literal assigned the string pool is used. For example, String s = "constant". However, the new operator forces a new String copy to be allocated, for example, in String s = new String("constant");.

To compare the String objects s1 and s2, use the s1.equals(s2) method.

The following lists the most common string operations.

The Java programming language supports lambdas as of Java 8. A lambda expression is a block of code with parameters. Lambdas allows you to specify a block of code which should be executed later. If a method expects a functional interface as parameter it is possible to pass in the lambda expression instead.

The type of a lambda expression in Java is a functional interface.

Using lambdas allows to use a condensed syntax compared to other Java programming constructs. For example the Collection interfaces has forEach method which accepts a lambda expression.

You can use method references in a lambda expression. Method reference define the method to be called via CalledFrom::method. CalledFrom can be * instance::instanceMethod * SomeClass::staticMethod * SomeClass::instanceMethod

The Java programming language supports lambdas but not closures. A lambda is an anonymous function, e.g., it can be defined as parameter. Closures are code fragments or code blocks which can be used without being a method or a class. This means that a closure can access variables not defined in its parameter list and that it can also be assigned to a variable.

A stream from the java.util.stream package is a sequence of elements from a source that supports aggregate operations.

Allow to create a stream of sequence of primitive int-valued elements supporting sequential and parallel aggregate operations.

Allow to create a stream of sequence of primitive int-valued elements supporting sequential and parallel aggregate operations.

The following example demonstrates how to use streams to filter a list, perform a mapping operation and to create one final result string from it with the reduce method.

The following is a larger example for the usage of streams. The code is based on the slides from the Goldmann Sachs Collection presentation at EclipseCOn 2015

Lets assume the following data model.

With this data model you can use streams and lambdas to filter and search the data as demonstrated in the following example.

If you need more assistance we offer Online Training and Onsite training as well as consulting

See License for license information.