Summary  
This chapter explains how to annotate code with single-line (`//`) and multi-line (`/* … */`) comments that are ignored at runtime to clarify and document your code for human readers.

General domain of usage  
Code documentation

**Comments** are notes inside your code that are completely ignored by the program when it runs. They are meant for humans, not the computer — Java skips them during execution, so they do not affect how your program works in any way.

Despite that, comments are extremely useful. They help you explain what your code is doing, leave reminders for yourself, and make your programs easier to read and understand — especially when they become longer or more complex.

## Single-line Comments

A single-line comment starts with `//`. Everything written after `//` on the same line is treated as a comment.


cGFja2FnZSBjb20uZXhhbXBsZTsKCnB1YmxpYyBjbGFzcyBNYWluIHsKICAgIHB1YmxpYyBzdGF0aWMgdm9pZCBtYWluKFN0cmluZ1tdIGFyZ3MpIHsKICAgICAgICAvLyBUaGlzIHByaW50cyBhIG1lc3NhZ2UgdG8gdGhlIHNjcmVlbgogICAgICAgIFN5c3RlbS5vdXQucHJpbnRsbigiSGVsbG8hIik7CiAgICB9Cn0=

## Multi-line Comments

When you need to write longer explanations, you can use multi-line comments. These start with `/*` and end with `*/`. Everything between them is ignored by Java.

```java
public class Main {
   public static void main(String[] args) {
       /*
       This program prints a simple message.
       The comment can span multiple lines.
       Java will ignore everything inside it.
       */
       System.out.println("Hello!");
   }
}
```

Comments are especially useful in larger programs because they help you understand what different parts of the code are supposed to do without having to analyze everything from scratch.

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

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.regex.Pattern;

import com.example.Main;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

public class MainTest {

    @Test
    @DisplayName("The code prints the right message")
    void testPrintsHelloWorldFlexible() {
        ByteArrayOutputStream outContent = new ByteArrayOutputStream();
        PrintStream originalOut = System.out;
        System.setOut(new PrintStream(outContent));

        Main.main(new String[]{});

        System.setOut(originalOut);

        String output = outContent.toString().trim();

        Pattern pattern = Pattern.compile("Hey\\\s+I'm\\\s+working", Pattern.CASE_INSENSITIVE);
        assertTrue(pattern.matcher(output).find(), "Actual output: " + output);
    }

    @Test
    @DisplayName("Comment was used to ignore the line with mistake.")
    public void testContainsCommentToRemoveThirdLine() throws IOException {
        String path = "/app/devResources/java/src/main/java/com/example/Main.java";
        String content = new String(Files.readAllBytes(Paths.get(path)));

        String[] lines = content.split("\\\R");
        String normalizedContent = content.replaceAll("\\\s+", "");

        boolean foundAsComment = normalizedContent.contains("//System.out.println");

        assertTrue(foundAsComment);
    }
}

MainTest.java

Dive into the fundamentals of Java by learning the core concepts that power modern applications. Explore variables, data types, operators, conditionals, and strings while building a strong foundation in programming. Through practical examples and hands-on challenges, you'll develop the skills needed to write, understand, and troubleshoot Java code with confidence.

Discover how to begin your Java journey by learning what Java is, where it is used, and how Java programs are structured. Understand how to print output, write comments, and build the foundation needed for all future programming concepts.

Master the skills needed to store, manage, and work with data in Java. Learn how variables, constants, data types, operators, and type casting work, and apply these concepts through practical coding exercises and real-world examples.

Explore the essentials of decision-making in Java by working with comparison and logical operators, conditional statements, and switch expressions. Learn how programs evaluate conditions, make choices, and respond to different situations through practical examples and challenges.

Dive into the fundamentals of working with text in Java. Learn how strings are created and manipulated, explore formatting and comparison techniques, validate user input, extract useful information from text, and apply these skills in realistic programming scenarios.

Comments

Single-line Comments

Multi-line Comments

Solution