Why You Should Implement Unit Tests for Your Java Application

In modern software development, unit testing stands as an indispensable pillar of ensuring code quality and reliability. At its core, unit testing involves the systematic validation of individual units or components of a software application, typically at the function or method level. The primary goal? To verify that each unit behaves exactly as intended under various conditions, effectively contributing to the overall functionality of the system.

Writing unit tests in Java with JUnit 5 offers a structured approach to this crucial aspect of software engineering. By meticulously crafting tests to assess the behavior of isolated code units, developers gain invaluable insights into the correctness and robustness of their implementations. But why is unit testing so vital, especially in the context of Java development with JUnit 5?

First and foremost, unit testing serves as an early warning system, flagging potential bugs and errors in the codebase long before they manifest into critical issues in a production environment. By identifying and rectifying these issues early in the development lifecycle, developers can significantly reduce the time and effort spent on debugging and troubleshooting later stages.

Moreover, unit testing fosters a culture of confidence and trust in the codebase. Each passing test provides a tangible affirmation that a particular piece of functionality works as expected, instilling a sense of assurance among developers and stakeholders alike. This confidence translates into smoother integration processes, as developers can confidently integrate their changes knowing that existing functionality remains intact.

Furthermore, writing unit tests in Java with JUnit 5 facilitates seamless code maintenance and refactoring. As software projects evolve over time, developers often need to make changes to existing code to accommodate new requirements or optimize performance. Unit tests act as a safety net, ensuring that modifications do not inadvertently introduce regressions or break existing functionality.

In summary, unit testing with JUnit 5 is not merely a best practice; it’s a fundamental aspect of modern software development. By validating individual units of code in isolation, developers can uncover defects early, build confidence in their codebase, and facilitate seamless maintenance and evolution of software projects.

Most Important Annotations for JUnit 5 tests in Java

In JUnit 5, annotations play an important role in defining the behavior and structure of unit tests. Understanding and effectively utilizing these annotations is essential for writing clear, concise, and maintainable test code. Below, are some important annotations that are necessary for writing unit tests in Java with JUnit 5.

@Test

This annotation is used to mark a method as a test method. JUnit 5 will execute all methods annotated with @Test.

@BeforeEach

Methods annotated with @BeforeEach are executed before each test method in the class. They are typically used to set up common test fixtures or initialize resources.

@AfterEach

Methods annotated with @AfterEach are executed after each test method in the class. They are commonly used to clean up resources or reset the state after each test.

@BeforeAll

Methods annotated with @BeforeAll are executed once before all test methods in the class. They are used for setup operations that are performed once for the entire test class.

@AfterAll

Methods annotated with @AfterAll are executed once after all test methods in the class have been executed. They are typically used for cleanup operations that need to be performed once after all tests have finished.

@Disabled

Methods annotated with @Disabled are skipped during test execution. This annotation is useful for temporarily excluding tests that are not ready or relevant

@ExtendWith

Used to register extensions with JUnit 5 tests, @ExtendWith allows you to customize the behavior of test classes or methods by applying additional functionality provided by extensions.

Step-by-Step Guide to Writing Unit Tests in Java with JUnit 5

In this tutorial, we are writing unit tests in Java with JUnit 5 for our FileHelper from the reading and writing to files in Java tutorials. You can find the full code of the FileHelper class here on our GitHub repository.

To start, we must create a class that will later contain all the tests. This can be automatically done. For that, you need to open the class which should be tested and press CTRL+SHIFT+T on your keyboard. Now a small menu will appear where you can click on create new test. Then a configuration window is going to show on your screen. With that configurator, you can choose the JUnit version, the class name, a superclass, and the destination package and you can even auto-generate the setup and teardown methods and create test methods for the methods inside the class.

For this tutorial, we are just choosing the correct version and the class name. The rest will be left empty.

For our FileHelper we want to test both read and write methods. All of the methods have a Path as a method parameter so we first need to create a file within a directory that can be used for testing. To not have to worry about deleting the directory after all the tests, we are using the @TempDir annotation. This will generate a temporary directory when starting the tests. After all the tests run through, the directory will be deleted automatically. Without this annotation it would be necessary, to create the directory in the @BeforeAll method and delete it in the @AfterAll method.

In addition to the directory that will contain the file, we are also declaring a file name, the file for the tests itself and the file content in the test class.

  @TempDir
  private File tempDir;
  private final String fileName = "tempFile.txt";
  private File tempFile = new File(tempDir, fileName);;
  private final List<String> testContent = List.of("Hello World!", "This is a test.");

After declaring every necessary variable in the class we are creating the @BeforeEach and @AfterEach method. In these methods, we are going to create/delete the file that will be used for the tests.

  @BeforeEach
  void setUp() throws IOException {
    tempFile.createNewFile();
  }

  @AfterEach
  void tearDown() {
    tempFile.delete();
  }

Now we are going to test our methods of the FileWriter class. Since the FileWriter class has read and write methods implemented with java.nio and java.io, we are going to test these in two different tests.

To create a unit test you need to write a method that does something to begin with. In this case, this would be FileHelper.writeToFile and FileHelper.readFromFile. To make this method a test you need to add a @Test annotation above the method declaration. Now the method is already a valid test which calls a method but doesn’t check if the method is actually working. Therefore we are adding an assertEquals call which will check if the file content written and then read by our FileHelper has the same amount of lines. Furthermore, we are iterating through the read results and checking if it is equal to the content we wanted to write with the FileHelper.

If all these assertions are correct, we know that the writing and reading of files is working correctly. The same checks are also done in the test method for the java.io FileWriter methods.

  @Test
  void testFileWriter() {
    FileHelper.writeToFile(tempFile.getAbsolutePath(), String.join("\n", testContent));
    List<String> fileContent = FileHelper.readFromFile(tempFile.getAbsolutePath());

    assertEquals(testContent.size(), fileContent.size());

    for (int i = 0; i < testContent.size(); i++) {
      assertEquals(testContent.get(i), fileContent.get(i));
    }
  }

  @Test
  void testBufferedFileWriter() {
    FileHelper.writeToFileBufferedWriter(tempFile.getAbsolutePath(),
        String.join("\n", testContent));
    List<String> fileContent = FileHelper.readFromFileBufferedReader(tempFile.getAbsolutePath());

    assertEquals(testContent.size(), fileContent.size());

    for (int i = 0; i < testContent.size(); i++) {
      assertEquals(testContent.get(i), fileContent.get(i));
    }
  }

To prevent code duplications, the checks can also be done in a separate method which is called by a test method. The code would then look like this:

  @Test
  void testFileWriter() {
    FileHelper.writeToFile(tempFile.getAbsolutePath(), String.join("\n", testContent));
    checkReadResult(FileHelper.readFromFile(tempFile.getAbsolutePath()));
  }

  @Test
  void testBufferedFileWriter() {
    FileHelper.writeToFileBufferedWriter(tempFile.getAbsolutePath(),
        String.join("\n", testContent));
    checkReadResult(FileHelper.readFromFileBufferedReader(tempFile.getAbsolutePath()));
  }

  private void checkReadResult(List<String> actualContent) {
    assertEquals(testContent.size(), actualContent.size());

    for (int i = 0; i < testContent.size(); i++) {
      assertEquals(testContent.get(i), actualContent.get(i));
    }
  }

It’s also possible to assert Exceptions to test invalid parameters given to the FileHelper. Instead of assertEquals you can use assertThrows with the expected exception class, an executable code and you can also add an error message to all of your assertions. It is also possible to check the exception message because assertThrows returns the occurred exception.

  @Test
  void readFromFileError() {
    RuntimeException e = assertThrows(RuntimeException.class,
        () -> FileHelper.readFromFile(tempDir.getAbsolutePath()),
        "Exception was not thrown!");

    assertEquals(e.getCause().getMessage(), "The file cannot be accessed!");
  }

  @Test
  void readFromFileBufferedReaderError() {
    assertThrows(RuntimeException.class,
        () -> FileHelper.readFromFileBufferedReader(tempDir.getAbsolutePath()),
        "Exception was not thrown!");
  }

Your full test class should now be the same as the code below. You can also find the complete code here.

import static org.junit.jupiter.api.Assertions.*;

import java.io.File;
import java.io.IOException;
import java.util.List;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;

class FileHelperTest {

  @TempDir
  private File tempDir;
  private final String fileName = "tempFile.txt";
  private File tempFile = new File(tempDir, fileName);;
  private final List<String> testContent = List.of("Hello World!", "This is a test.");

  @BeforeEach
  void setUp() throws IOException {
    tempFile.createNewFile();
  }

  @AfterEach
  void tearDown() {
    tempFile.delete();
  }

  @Test
  void testFileWriter() {
    FileHelper.writeToFile(tempFile.getAbsolutePath(), String.join("\n", testContent));
    checkReadResult(FileHelper.readFromFile(tempFile.getAbsolutePath()));
  }

  @Test
  void testBufferedFileWriter() {
    FileHelper.writeToFileBufferedWriter(tempFile.getAbsolutePath(),
        String.join("\n", testContent));
    checkReadResult(FileHelper.readFromFileBufferedReader(tempFile.getAbsolutePath()));
  }

  private void checkReadResult(List<String> actualContent) {
    assertEquals(testContent.size(), actualContent.size());

    for (int i = 0; i < testContent.size(); i++) {
      assertEquals(testContent.get(i), actualContent.get(i));
    }
  }

  @Test
  void readFromFileError() {
    RuntimeException e = assertThrows(RuntimeException.class,
        () -> FileHelper.readFromFile(tempDir.getAbsolutePath()),
        "Exception was not thrown!");

    assertEquals(e.getCause().getMessage(), "The file cannot be accessed!");
  }

  @Test
  void readFromFileBufferedReaderError() {
    assertThrows(RuntimeException.class,
        () -> FileHelper.readFromFileBufferedReader(tempDir.getAbsolutePath()),
        "Exception was not thrown!");
  }
}

Now that your test class is ready, you can execute the whole test class with all the tests with the green arrow next to the class name inside the code or just run a single test method with the green arrow next to the method declaration.

When the tests are finished you will see the result of them in the run window at the bottom of your IDE as shown in the screenshot below.

If you don’t see each test method result but only the test class, you have to switch from running unit tests with Gradle to running them with IntelliJ IDEA. To do this you first have to open the settings of IntelliJ. This can be done with CTRL+ALT+S or via the top menu under ‘File’. After opening the settings window, you need to find ‘Build, Execution, Deployment’ on the left side, expand it, find Build Tools and click on Gradle. In the window after clicking on Gradle you can now set ‘Run tests using:. Choose IntelliJ IDEA from the drop-down menu and click OK.

If you now run your unit tests you will see every single test listed on the run window.

If a unit test fails you will also be able to see the difference in the result window, so you don’t have to debug into the test to see what values are getting compared or checked.

As we wrap up our journey through the process of writing unit tests in Java with JUnit 5, I hope you’ve found this guide insightful and helpful in enhancing your knowledge. Should you encounter any questions or challenges while implementing, don’t hesitate to reach out. Your feedback, queries, and insights are always valued, and I’m here to assist you on your coding adventures. Until next time, happy coding!

Why Proper Logging is Necessary for Every Application

Proper logging is indispensable for every application as it serves as a crucial lifeline for developers and operators alike. Logging provides a detailed record of system behavior, errors, and events, aiding in troubleshooting and debugging processes. It offers insights into the application’s health, performance, and usage patterns, enabling developers to identify and rectify issues promptly.

Moreover, comprehensive logs enhance security by facilitating the detection of suspicious activities or breaches. In essence, robust logging practices not only enhance the reliability and maintainability of an application but also contribute significantly to its overall security and performance.

Adding Log4j2 Dependencies to Your Project

Before implementing logging in Java with Log4j2 you first need to add certain dependencies to your Java project so that you can use Log4j2. If you are using Kotlin as your DSL you can copy the required dependencies from below. If you use any other language you can find the correct dependency implementation on the Maven repository. To follow this tutorial you need the slf4j-api dependency and the log4j-slf4j2-impl. The dependencies need to be added to your build.gradle if you use Gradle or to your pom.xml if you use Maven.

    implementation("org.slf4j:slf4j-api:2.0.12")
    implementation("org.apache.logging.log4j:log4j-slf4j2-impl:2.23.1")

Implement Logging in Java with Log4j2

The first thing you need to do to implement logging in Java with Log4j2 is, to create a configuration file. In that file, you need to define different settings like log levels, different log appenders and settings for these like a Rollover strategy. The file must be placed in your application’s resources folder and named ‘log4j2’. The file type is XML. After the creation, it should look like the red highlighted file below.

Inside the file, you can now define different configurations. For example, you can create a File logger or configure it, to log everything in the application console. But you can also configure multiple loggers. All the different configurations can be found on the website of Apache about log4j2.

In this tutorial, we are going to create a file logger. The file logger will be configured with a SizeBasedTriggeringPolicy which means that if the current log file of the app is bigger than the configured value, a new log file will be created and the ‘full’ one will be saved. We are also adding a DefaultRolloverStrategy. With that, it can be prevented that hundreds of ‘full’ log files are being created. You can have different conditions to delete old log files like a maximum amount, an age limitation and many more.

You can copy the full code of the file logger configuration from the jasta GitHub repository or from below. Carefully read the comments in the XML file to fully understand the meaning of each line inside the file, configure it to your requirements, and implement your custom logging in Java with Log4j2.

<?xml version="1.0" encoding="UTF-8"?>
<!--
Status defines the level of internal Log4j events that should be logged to the console.
If there are any configuration problems without an obvious error you can set it to trace or other levels.
Valid values are: off, trace, debug, info, warn, error, fatal, all
-->
<Configuration status="info">
  <Properties>
    <!-- 
    The path of the log directory. With the configuration below, the log files are stored under 
    <drive>:\logs
    -->
    <Property name="LOG_DIR">/logs</Property>
  </Properties>

  <Appenders>
    <!--
     name: The name of the appender
     fileName: The name of the current log file
     filePattern: The file names of any older log which is created if the current log size exceeds the SizeBasedTriggeringPolicy
     immediateFlush: Log is written as soon as the log methods are called
     -->
    <RollingFile
      name="fileLogger"
      fileName="${LOG_DIR}/AppCurrent.log"
      filePattern="${LOG_DIR}/App_%d{yyyy-MM-dd_hh-mm-ss}.log"
      immediateFlush="true">
      <PatternLayout>
        <!--
        The format of the log message inside the file
        Example: 2024-04-04 18:57:29.369 [Bank.register] [INFO] WorldBank Germany - Customer 'Id' successfully registered!
        Definition: <Date with Time> [<ClassName>.<Method>] [<Message Log Level>] <LoggerName> - <Message>
        -->
        <Pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%C{1}.%M] [%level] %logger{36} - %msg%n</Pattern>
      </PatternLayout>
      <Policies>
        <!-- Maximum size of the current log file -->
        <SizeBasedTriggeringPolicy size="10MB"/>
      </Policies>

      <!-- Rollover strategy to delete old log files -->
      <DefaultRolloverStrategy>
        <!-- Search path for the deletion and depth (1 = just the search path not any subfolders, -1: search path with every subfolder, 2,3,4...: search path with x subfolders -->
        <Delete basePath="${LOG_DIR}" maxDepth="1">
          <!-- File name pattern for the old log files -->
          <IfFileName glob="App_*.log"/>
          <!-- Maximum amount of old log file -->
          <IfAccumulatedFileCount exceeds="10"/>
        </Delete>
      </DefaultRolloverStrategy>
    </RollingFile>
  </Appenders>

  <Loggers>
    <!--
    The log level of the root logger which will be applied to the child logger.
    With info log messages with .info, .error, .warn are logged - .debug for example will not get logged
    Valid values are: off, trace, debug, info, warn, error, fatal, all
    -->
    <Root level="info">
      <!-- Add the appender via its name -->
      <AppenderRef ref="fileLogger"/>
    </Root>
  </Loggers>
</Configuration>

After you have copied the code above or configured it to your requirements, you can start logging in Java with Log4j2. Therefore you have to call LoggerFactory.getLogger(<ConstructorParameter>) with either a class or a String as a constructor parameter. The given Parameter will be the name of the logger. The returned Object will be a Logger Object from org.slf4j.Logger. You can now call different log methods like debug, error, info, warn, trace and many more. Depending on what log level is set in the configuration file some messages will not get logged. All available methods can be seen here.

An example declaration would look like this:

private static final Logger LOGGER = LoggerFactory.getLogger(TestDriver.class);

Later the Logger object can be used like this:

LOGGER.info("Application is starting...");

If you are logging much, your log output directory will look similar to the screenshot below. As you can see, a new log file is created after 10KB (in this case 11KB since it is such a small unit. With MB it would not be 11MB). Also, the old log files are created with the date and time as configured in the log4j2.xml file. Furthermore, the limit of 10 old log files is also considered. If a new log file were to be created, the oldest log file, in this case ‘App_2024-04-06_05-13-05.log’, would be deleted.

This was the process of implementing logging in Java with Log4j2. If you have any questions or trouble implementing your logging system feel free to leave a comment below.

The Importance of Writing to Files in Java

In the world of software development, the ability to write data to files in Java plays a vital role in managing and preserving valuable information. This aspect is often considered the counterpart to reading files, as it enables developers to not only access existing data but also store new or modified data for future use.

When we talk about writing files in Java, we’re essentially talking about the process of saving data to different types of files, be it plain text files, structured data files like CSV or XML, or even binary files. This capability is crucial for a wide range of applications. For instance, in a logging scenario, writing critical events to a log file ensures that important information is recorded for debugging or auditing purposes.

Moreover, writing to files in Java facilitates data persistence, ensuring that essential data isn’t lost between application sessions. This is particularly crucial for applications that require user preferences or settings to be saved, allowing users to seamlessly resume their activities without losing their custom configurations.

Beyond basic data storage, Java’s file writing capabilities extend to creating structured outputs in formats suitable for sharing and collaboration. For example, generating reports in PDF or Excel formats allows users to analyze and share data insights efficiently. This ability to produce structured outputs enhances the usability and versatility of Java-powered applications across various domains.

Mastering the art of writing to files in Java empowers developers to design robust and efficient software solutions that not only capture and retain crucial data but also unleash the full potential of their applications to deliver impactful insights and drive innovation.

Implement Different Ways to Write to Files

For reading files in Java there are two different approaches. One uses Java.io which is available since version 1.1 and the other uses a method of Java.nio which was introduced with version 1.7.

Java NIO Files

The more modern and easy solution for writing to files in Java is Java.nio.Files. With that, you can call the static method write from Files with a Path parameter, the content as a byte array and OpenOptions. Via the OpenOptions you can decide what should happen if the file already exists/not exists. There are many different options like Create, Create_New and Append. You can find all the options with a description here.

  public static void writeToFile(String path, String content) {
    try {
      Files.write(Path.of(path), content.getBytes(), StandardOpenOption.CREATE);
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }

BufferedWriter with FileWriter

The more traditional and sometimes necessary way with a Java version below 1.7 is with a BufferedWriter and a FileWriter. After initializing the BufferedWriter with the FileWriter the write method of the BufferedWriter has to be called with the content as a String. After the method call the BufferedWriter has to be closed via its close method.

  public static void writeToFileBufferedWriter(String path, String content) {
    File fileToWrite = new File(path);
    try {
      boolean fileExists = fileToWrite.exists();
      if (!fileExists) {
        fileExists = fileToWrite.createNewFile();
      }

      if (fileExists && fileToWrite.isFile() && fileToWrite.canWrite()) {
        BufferedWriter writer = new BufferedWriter(new FileWriter(fileToWrite));
        writer.write(content);
        writer.close();
      } else {
        throw new RuntimeException(new IOException("The file cannot be accessed!"));
      }
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }

You can also find the whole code on the jasta GitHub repository. To also learn how to read files in Java you can click here. If you have any questions or feedback feel free to comment below.

The Importance of Reading Files in Java

In the realm of software development, the ability to efficiently read and process data from files is a fundamental skill, and Java equips developers with powerful tools to accomplish this task seamlessly.

Reading files in Java is not merely a technical necessity; it is a gateway to unlocking valuable insights and harnessing the potential of diverse data sources. Whether it’s parsing configuration files, analyzing log data, or extracting information from structured documents, Java’s file reading capabilities play a pivotal role in enabling developers to interact with data stored in various formats.

From plain text files to complex binary formats, Java offers versatile mechanisms for accessing and manipulating file contents. Moreover, Java’s support for popular data interchange formats such as JSON and XML further enhances its utility in modern software development.

JSON and XML, being widely adopted for their simplicity and flexibility in representing structured data, find extensive use in web services, configuration files, and data exchange between different systems. By adeptly reading and processing files in Java, developers can seamlessly integrate these data formats into their applications, thereby facilitating interoperability and enhancing the overall functionality and usability of their software solutions.

In essence, mastering the art of reading files in Java is not merely about manipulating bytes and characters; it’s about harnessing the potential of data to drive innovation, gain insights, and deliver impactful software solutions.

Implement Different Ways to Read Files

For reading files in Java there are two different approaches. One uses Java.io which is available since version 1.1 and the other uses a method of Java.nio which was introduced with version 1.7.

Java NIO Files

The more modern and easy solution for reading files in Java is Java.nio.Files. With that, you can call the static method readAllLines from Files with a Path parameter. A Path can be created via toPath on a File object or with Path.of(<FilePathAsString>). Optionally you can add a Charset after the path as well. It returns a list of strings where one entry represents one line in the file.

  public static List<String> readFromFile(String path) {
    File fileToRead = new File(path);

    if (fileToRead.exists() && fileToRead.isFile() && fileToRead.canRead()) {
      try {
        return Files.readAllLines(fileToRead.toPath());
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
    } else {
      throw new RuntimeException(new IOException("The file cannot be accessed!"));
    }
  }

BufferedReader with FileReader

The more traditional and sometimes necessary way with a Java version below 1.7 is with a BufferedReader and a FileReader. After initializing the BufferedReader with the FilleReader the readLine method of the BufferedReader has to be called to get the next line. When the file ends, the method will return null. After the end of the file is reached the BufferedReader has to be closed.

  public static List<String> readFromFileBufferedReader(String path) {
    File fileToRead = new File(path);

    if (fileToRead.exists() && fileToRead.isFile() && fileToRead.canRead()) {
      try {
        BufferedReader reader = new BufferedReader(new FileReader(fileToRead));
        String temp;
        List<String> content = new ArrayList<>();

        while ((temp = reader.readLine()) != null) {
          content.add(temp);
        }

        reader.close();

        return content;
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
    } else {
      throw new RuntimeException(new IOException("The file cannot be accessed!"));
    }
  }

You can also find the whole code on the jasta GitHub repository. You can also click here to learn how to write to files in Java. If you have any questions or feedback feel free to comment below.

What are Java Objects and Why Do They Exist?

As you might already know, there are some predefined objects in Java. Examples would be a String which stores some text or an Integer which can store a number. These are already pretty useful but what would you do, if you want to store multiple pieces of information for one thing? An example would be a car. All necessary information cannot be stored inside a String or an Integer. So the best approach is to create a new Object which cannot just store one particular information but many different things.

Regarding the car example some things that should be stored would be:

• Brand
• Model
• Plate
• Color
• Seats
• Steering wheel

Of course, there are many more things, but this is enough for the beginning. Some of the info can be easily stored in a string like the brand or the model whereas others require more details like the seats and steering wheel. This is because seats can come in various configurations for example with heating or without. That is also the case for the steering wheel. Therefore we would also need to create custom Java objects for the seats and the steering wheel.

Understanding the Purpose of Constructors in Java

Before actually creating your first Java Objects you have to know about constructors. A constructor is called at the very beginning of creating an object. It is called once and then never again. The purpose of it is to set some variables in the object or execute functions that are necessary at the beginning. Variables that are given with the constructor to the Java Object are often:

• Values that must be set before any method call
• Values that are already known upon the creation of the object
• Values that are used for a method call inside the constructor

To get back to the car example a constructor would look like this:

  public Car(String brand, String model) {
    this.brand = brand;
    this.model = model;
  }

With that constructor, we are already setting the brand and the model inside the car object since this information is already known on creation. Other information is probably not known when starting with the creation of the car.

Good to know is, if there is no constructor defined in a class it is the same as an empty constructor. But there can also be multiple constructor definitions.

  public Car(String brand, String model) {
    this.brand = brand;
    this.model = model;
  }  
  
  public Car(String brand, String model, String color) {
    this.brand = brand;
    this.model = model;
    this.color = color;
  }

In the example above you have two constructors so you can create an object with these options depending on if you already know the color. In the code a new car object can now be created via ‘new Car(“Audi”, “A4”);’ or ‘new Car(“Audi”, “A4”, “Green”);’.

The difference between a constructor and a setter method is, that a constructor is once called when creating an object. A setter method can be but must not be called after initializing the object and can also be called multiple times with different values.

How to Create and Use Java Objects

Now let’s implement the car example with Java Objects. The complete code can be found and cloned from the jasta GitHub repository. To begin with we have to create our objects by creating new classes. If you don’t know how to create classes in IntelliJ IDEA click here. We need to create the following classes: Car, Seat, Steeringwheel and a Main class to test the Java Objects. After creating all classes your project structure looks like the screenshot below.

First of all, we are adding code to the seat class. We are adding three variables to the class: material, weight and heating. Since we will probably know all of these when creating the seat we are setting all of them inside the constructor. Also, these attributes will not change, therefore they have the final keyword in front of the declaration so they can not be modified later on. To get the values of the variables we are also adding get methods.

public class Seat {

  private final String material;
  private final int weight;
  private final boolean heating;

  public Seat(String material, int weight, boolean heating) {
    this.material = material;
    this.weight = weight;
    this.heating = heating;
  }

  public String getMaterial() {
    return material;
  }

  public int getWeight() {
    return weight;
  }

  public boolean isHeating() {
    return heating;
  }
}

The second class which will be implemented is the Steeringwheel class. For simplicity, we are just adding two variables: material and diameter. These will be known on creation and should not be changed later. Therefore the final keyword is added again and the values are assigned inside the constructor. In addition, of course, getter methods are added.

public class Steeringwheel {

  private final String material;
  private final int diameter;

  public Steeringwheel(String material, int diameter) {
    this.material = material;
    this.diameter = diameter;
  }

  public String getMaterial() {
    return material;
  }

  public int getDiameter() {
    return diameter;
  }
}

Now that all Java Objects used for the car object are created, we can implement the car class. As previously described a car will have multiple seats therefore a list of seats, a String brand, a String model, a Steeringwheel object, a String plate and a String with the car’s color. The list type, the brand and the model shouldn’t be modified after initialization therefore they are declared final. Since the list type is already declared at the variable declaration only the brand and the model need to be set in the constructor. Every other attribute can be set via the corresponding set method. Of course getter methods are added as well.

import java.util.ArrayList;
import java.util.List;

public class Car {

  private final List<Seat> seats = new ArrayList<>();
  private final String brand;
  private final String model;
  private Steeringwheel steeringwheel;
  private String plate;
  private String color;

  public Car(String brand, String model) {
    this.brand = brand;
    this.model = model;
  }

  public List<Seat> getSeats() {
    return seats;
  }

  public void addSeat(Seat seat) {
    seats.add(seat);
  }

  public String getBrand() {
    return brand;
  }

  public String getModel() {
    return model;
  }

  public Steeringwheel getSteeringwheel() {
    return steeringwheel;
  }

  public void setSteeringwheel(Steeringwheel steeringwheel) {
    this.steeringwheel = steeringwheel;
  }

  public String getPlate() {
    return plate;
  }

  public void setPlate(String plate) {
    this.plate = plate;
  }

  public String getColor() {
    return color;
  }

  public void setColor(String color) {
    this.color = color;
  }
}

To test and understand how all this works, you can copy the code from below into your main class and execute it.

public class Main {

  public static void main(String[] args) {
    Car audiA4 = new Car("Audi", "A4");

    audiA4.setColor("green");

    Steeringwheel steeringwheel = new Steeringwheel("Leather", 38);
    audiA4.setSteeringwheel(steeringwheel);

    audiA4.addSeat(new Seat("Leather", 10, true));
    audiA4.addSeat(new Seat("Leather", 10, true));
    audiA4.addSeat(new Seat("Fabric", 8, false));
    audiA4.addSeat(new Seat("Fabric", 8, false));
    audiA4.addSeat(new Seat("Fabric", 8, false));

    audiA4.setPlate("ABCD1");

    System.out.println(
        "Car: " + audiA4.getBrand() + " " + audiA4.getModel() + " in " + audiA4.getColor());
    System.out.println(
        "Steeringwheel: " + audiA4.getSteeringwheel().getMaterial() + " steeringwheel which is "
            + audiA4.getSteeringwheel().getDiameter() + "cm big");

    int count = 1;
    String tempSeatOutput;
    for (Seat seat : audiA4.getSeats()) {
      tempSeatOutput =
          "Seat " + count + ": " + seat.getMaterial() + " seat which weights " + seat.getWeight()
              + "kg";

      if (seat.isHeating()) {
        tempSeatOutput += " and can heat up";
      } else {
        tempSeatOutput += " and cannot heat up";
      }

      System.out.println(tempSeatOutput);
      count++;
    }

    System.out.println("Plate: " + audiA4.getPlate());
  }
}

The code above creates a new object with Car audiA4 = new Car(“Audi”, “A4”);. ‘Audi’ and ‘A4’ are the constructor arguments (brand and model). After creation, we are now using the setter methods of the car objects to set other variables.

The color is just set with a simple String argument. To set a Steeringwheel object we first have to create one. This is done like the Car object but now with Steeringwheel: Steeringwheel steeringwheel = new Steeringwheel(“Leather”, 38);. When creating the Steeringwheel Object the constructor arguments (material and diameter) are added. Now there are two separate objects. One is the Car and the other one is the Steeringwheel Object. To link the Steeringwheel object to the Car object we need to call the setSteeringwheel method of the car. The same process is now done with the seats but with anonymous objects.

Anonymous objects are used if you don’t need to access the object later on in the code. So you can type new Seat(<material>, <weight>, <heating>) and add it immediately to the car with addSeat. This has two benefits. All this is done within one line and you don’t have to think about an object name. This can also be done with the Steeringwheel object since it will not be used directly later in the code.

After setting the plate every information about the car is printed out in the console. To do this the respective getter method is called to get the wanted String, Steeringwheel or Seat objects.

That’s the process of creating and using Java Objects. If you have any questions feel free to leave a comment.

Create your first Java program

To create your first Java program you have to start IntelliJ IDEA. If you don’t already have installed IntelliJ you can follow this guide to do so. After the program is started, your screen should look like the screenshot below. There you can click on new Project to create your first Java program.

Now you will see the project configuration screen. In the middle of this window, you will see the section JDK with a drop-down list. If you have never programmed Java before, the text “<No SDK>” will be selected in the menu. To add a SDK you can simply open the drop-down and click Download JDK. In the following windows, you should select the newest available LTS version. LTS stands for Long-Term-Support. To find the newest LTS Java version, you can visit the official Oracle Java SE Support Roadmap website. In this case, the newest version is 21.

After downloading the JDK it should be automatically selected on your project configuration screen – if not just select it from the drop-down menu. Now you have to fill out the remaining project configurations.

For the project name and the location, you can choose whatever you want. The preselected language Java is already correct so we leave that as it is. When choosing the build system you can choose whatever you like the best, but it is recommended to use Gradle for various factors. This includes customizability and performance. Sometimes after changing the build system, the just downloaded JDK will be deselected. If that happens, you can just reselect it.

Below the JDK menu, you can select the Gradle DSL which simply means in what language the Gradle files are written. While it does not matter that much, it is recommended to choose Kotlin, because it is superior to Groovy.

If you want you can check the two checkboxes below to add sample code and to generate the code with onboarding tips. But you can also uncheck them and just copy the necessary code which is provided later in this post.

You can also open the advanced settings by clicking on it. Sometimes there might be a version conflict between your JDK and your Gradle version. For example, you need to use at least Gradle version 8.5 for the JDK version 21. If there is a lower version selected, you have to deselect Auto-select and enter the required version. For every other field, you can leave with the prefilled values.

Now your project configuration window should look similar to the screenshot provided below. If this is the case, you can now create your first Java program via the Create button.

Now IntelliJ does create your first Java program with the provided configuration and your screen will look like this.

In the screenshot, you can see two highlighted sections. The one on the bottom indicates if there is a process running. While creating your project it will be visible. After it is finished building, the progress bar will disappear.
The marked section on the top will also appear when creating your project. You can either wait till the processes which are shown at the bottom bar are finished or you can press Setup SDK.

Start your program

After your project is finished building, you can now run it. If you did not select the checkbox to create some example code when creating the project, you first have to create a new class. You can do this by right-clicking on your Java folder which is inside src-main and saying New and clicking on Java Class.

Now you can enter whatever name you like. For this tutorial, you should name it ‘Main’. With that window, you can also create other things like Interfaces and Records but for this program, we need a Class. You can confirm your choices by pressing the enter key.

After your class is created you can now insert the example code from below.

public class Main {
    public static void main(String[] args) {
        System.out.printf("Hello and welcome!");

        for (int i = 1; i <= 5; i++) {
            System.out.println("i = " + i);
        }
    }
}

To run your first Java program you have to either click on the play button at the top right or click on the play button next to your code and select Run Main.

Now IntelliJ will compile your project. While compiling, an output window will open at the bottom of your IDE. There you can see some messages regarding the building of the project and you will also see the result of your first Java program. Since this is a rather small project the output will be displayed very quickly.

The result displays firstly the sentence ‘Hello and welcome!’ which is done with the command System.out.printf(). After that, you can see the numbers from 1 to 5. This is done via the for loop which is simply counting from 1 (i = 1) to 5 (i <= 5) while i++ says i should be incremented by 1 with every run. Inside the for loop, you can see a slightly different version of the first command to output the ‘Hello and welcome!’. The only real difference is that System.out.println prints every output inside a new line. To see what is happening inside the for loop it is printing out the current number which is assigned to i in the output window.

Modify the source code of your first Java program

Now that you have created and started your first Java program, you can modify it a bit. Just replace your current code with the code from below. If your current code has ‘package XXX’ in the first line, you have to leave it there and just replace everything below.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        System.out.println("What is your name?");

        Scanner reader = new Scanner(System.in);
        System.out.println("Hello " + reader.next() + "!");
    }
}

If you execute the program now, you will see that it is asking you for your name. Just enter your name at that point and press enter. The program will now greet you.

From this code, you will already recognize the ‘System.out.println()’ which is printing something out in your output window. The only new part is the Scanner, which is there to read your input, in this case, your name.
The last ‘System.out.println()’ now combines your input which we get via reader.next() with ‘Hello’ and a ‘!’.

Maybe you have also noticed the import statement on top of the code. This is necessary so that we can use the Scanner class inside our Main class. But you do not have to worry about this too much because IntelliJ creates the imports for you automatically while programming.

Now you have successfully created your first Java program and also modified it.
Have fun coding!