Java

Java is a general-purpose, object-oriented programming language and software platform designed for developing applications that can run across different operating systems and hardware environments. Java is used to develop server-side and enterprise systems, web applications, cloud services, data processing software, and other types of applications.

One of Java’s key features is that programs run through the Java Virtual Machine (JVM). Source code is typically compiled not directly into machine instructions for a specific processor but into intermediate bytecode, which is executed by the JVM. This allows the same Java program to run on different platforms as long as a compatible virtual machine is available.

How Java Works

The development and execution of a traditional Java program involves several main stages:

• The developer writes source code in .java files.
• The Java compiler converts it into bytecode.
• The result is typically stored in .class files.
• The JVM loads the required classes.
• The virtual machine verifies and executes the bytecode.
• The JVM interacts with the operating system and hardware.

For example, the same compiled .class file can run both on a developer’s laptop and on a Linux server in a data center.

In simplified form, the process looks like this:

Java Source Code → Compiler → Java Bytecode → JVM → Operating System → Hardware

This approach helps separate the application from the specifics of a particular operating system and processor architecture.

What Is the JVM?

JVM (Java Virtual Machine) is a virtual machine that executes Java bytecode. JVM implementations are available for different operating systems and hardware platforms.

The JVM performs several important functions:

• loads classes;
• verifies bytecode;
• manages memory;
• executes code;
• provides automatic garbage collection;
• provides the application’s runtime environment.

For example, the JVM releases memory that is no longer in use on its own, so developers do not have to manage it manually.

To improve performance, modern JVMs can use JIT compilation (Just-In-Time compilation). Frequently executed sections of bytecode are converted at runtime into machine code optimized for the specific processor.

JDK, JRE, and JVM: What Is the Difference?

These terms refer to different parts of the Java platform.

• JVM (Java Virtual Machine) — executes Java bytecode.
• JRE (Java Runtime Environment) — the traditional term for the environment required to run Java applications, including the JVM and related libraries and components.
• JDK (Java Development Kit) — a toolkit for developing Java applications that includes the compiler and other development tools, as well as the required runtime components.

For example, a server that only needs to run a finished application requires a runtime environment with a JVM, while the developer’s machine needs the full JDK.

In modern Java versions, distributing a separate general-purpose JRE no longer plays the same role it once did. Applications can instead use custom runtime images containing only the required Java modules.

Write Once, Run Anywhere

Java is closely associated with the WORA (Write Once, Run Anywhere) principle.

A program is compiled into platform-independent bytecode. To execute it, a JVM implementation for the target platform is required.

For example, the same bytecode can potentially run on:

• Windows;
• Linux;
• macOS;
• various server and cloud environments.

For example, a service developed on Windows can run unchanged in a Linux container in a data center.

In practice, portability also depends on the libraries and external components being used and whether the application contains platform-specific code.

Main Features of Java

Java is a statically typed language: the types of variables and expressions are checked at compile time.

Key features of the language and platform include:

• object-oriented programming model;
• static typing;
• automatic memory management;
• Garbage Collection;
• extensive standard library;
• multithreading support;
• exception handling;
• bytecode portability;
• extensive ecosystem of libraries and development tools.

For example, a mistake in a variable’s type surfaces at compile time rather than during production use.

Modern Java supports not only traditional object-oriented constructs but also a number of functional programming features, such as lambda expressions.

What Is Java Used For?

Java is used in various areas of software development but is particularly widespread in server-side and enterprise systems.

Typical use cases include:

• web application backends;
• enterprise information systems;
• banking and financial applications;
• e-commerce systems;
• REST APIs and microservices;
• cloud services;
• large-scale data processing systems;
• integration platforms;
• development tools;
• server-side components of distributed systems.

For example, the core systems of many banks and insurers run on Java applications that are maintained and extended over many years.

Java has also historically played an important role in Android application development, although modern Android development also makes extensive use of Kotlin.

Advantages of Java

The main advantages of Java include:

• application portability across platforms;
• mature server-side ecosystem;
• automatic memory management;
• a large number of libraries and frameworks;
• multithreading support;
• development and diagnostic tools;
• suitability for large enterprise systems;
• long-term platform development and compatibility with a large amount of existing software.

For example, applications written many years ago can often keep running on newer Java versions.

Java is particularly useful for projects where a mature development infrastructure and long-term software maintenance are important.

Limitations of Java

The JVM introduces an additional software layer between the application and the operating system. This can increase memory requirements and affect application startup time compared with some programs compiled directly into machine code.

Other factors to consider include:

• JVM resource consumption;
• Garbage Collector configuration;
• startup time of some applications;
• dependence on a compatible runtime environment;
• complexity of large Java ecosystems and enterprise frameworks.

For example, JVM startup time matters far more for short-lived functions in a serverless environment than for a long-running server service.

However, specific characteristics vary considerably depending on the JVM implementation, application architecture, and technology stack.

FAQ

🠔 Back to glossary