.class file), not directly to machine code. The JVM (Java Virtual Machine) then runs that bytecode on any device. This is Java's famous Write Once, Run Anywhere (WORA) promise."
},
{
"type": "table",
"headers": ["Tool", "What it does", "Handles"],
"rows": [
["JDK — Java Development Kit", "Full developer toolkit — compiler, debugger, and JRE bundled together", "Writing & compiling Java code"],
["JRE — Java Runtime Environment", "Runs Java programs — includes JVM and the standard class libraries", "Running existing Java apps"],
["JVM — Java Virtual Machine", "Executes bytecode on your operating system — makes WORA possible", "Cross-platform execution"]
]
},
{
"type": "note",
"text": "Rule of thumb: Develop with the JDK. Deploy with the JRE. The JVM lives inside the JRE."
},
{
"type": "header",
"level": 2,
"text": "Java Example"
},
{
"type": "paragraph",
"text": "Java is often used in everyday programming tasks, like saying hello to a user:"
},
{
"type": "code",
"language": "java",
"code": "public class Main {\n public static void main(String[] args) {\n System.out.println(\"Hello, World!\");\n System.out.println(\"Java is fun!\");\n }\n}\n// Output:\n// Hello, World!\n// Java is fun!"
},
{
"type": "header",
"level": 2,
"text": "Get Started"
},
{
"type": "paragraph",
"text": "By the end of this tutorial, you will know how to write basic Java programs and apply your skills to real-life examples."
},
{
"type": "paragraph",
"text": "You don't need any prior programming experience - just curiosity and practice!"
},
{
"type": "image",
"src": "assets/images/java/yt_logo_rgb_dark.png",
"alt": "Java Tutorial on YouTube"
}
]
},
"get-started": {
"title": "Java Getting Started",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Get Started With Java"
},
{
"type": "paragraph",
"text": "At Coding Tamilan, you can try Java without installing anything."
},
{
"type": "paragraph",
"text": "Our Online Java Editor runs directly in your browser, and shows both the code and the result:"
},
{
"type": "paragraph",
"text": "This editor will be used in the entire tutorial to demonstrate the different aspects of Java."
},
{
"type": "header",
"level": 2,
"text": "Java Install"
},
{
"type": "paragraph",
"text": "However, if you want to run Java on your own computer, follow the instructions below."
},
{
"type": "paragraph",
"text": "Some PCs might have Java already installed."
},
{
"type": "paragraph",
"text": "To check if you have Java installed on a Windows PC, search in the start bar for Java or type the following in Command Prompt (cmd.exe):"
},
{
"type": "example",
"title": "Example",
"code": "C:\\Users\\Your Name>java -version"
},
{
"type": "paragraph",
"text": "If Java is installed, you will see something like this (depending on version):"
},
{
"type": "paragraph",
"text": "If you do not have Java installed on your computer, you can download it at oracle.com."
},
{
"type": "paragraph",
"text": "Note: In this tutorial, we will write Java code in a text editor. However, it is possible to write Java in an Integrated Development Environment, such as IntelliJ IDEA, Netbeans or Eclipse, which are particularly useful when managing larger collections of Java files."
},
{
"type": "header",
"level": 2,
"text": "Java Quickstart"
},
{
"type": "paragraph",
"text": "In Java, every application begins with a class name, and that class must match the filename."
},
{
"type": "paragraph",
"text": "Let's create our first Java file, called Main.java, which can be done in any text editor \n(like Notepad)."
},
{
"type": "paragraph",
"text": "The file should contain a \"Hello World\" message, which is written with the \nfollowing code:"
},
{
"type": "paragraph",
"text": "Don't worry if you don't understand the code above - we will discuss it in detail in later chapters. \nFor now, focus on how to run the code above."
},
{
"type": "paragraph",
"text": "Save the code in Notepad as \"Main.java\". Open Command Prompt (cmd.exe), navigate to the directory where you saved your file, and type \"javac \nMain.java\":"
},
{
"type": "example",
"title": "Example",
"code": "C:\\Users\\Your Name>javac Main.java"
},
{
"type": "paragraph",
"text": "This will compile your code. If there are no errors in the code, the command prompt will take you to the next line. \nNow, type \"java Main\" to run the file:"
},
{
"type": "example",
"title": "Example",
"code": "C:\\Users\\Your Name>java Main"
},
{
"type": "paragraph",
"text": "The output should read:"
},
{
"type": "paragraph",
"text": "Congratulations! You have written and executed your first Java program."
},
{
"type": "code",
"language": "java",
"code": "// Main.java — save this file, then compile and run\npublic class Main {\n public static void main(String[] args) {\n System.out.println(\"Hello World\");\n }\n}\n// Compile: javac Main.java\n// Run: java Main\n// Output: Hello World"
},
{
"type": "image",
"src": "assets/images/java/yt_logo_rgb_dark.png",
"alt": "Java Tutorial on YouTube"
}
]
},
"syntax": {
"title": "Java Syntax",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Java Syntax"
},
{
"type": "paragraph",
"text": "In the previous chapter, we created a Java file called Main.java, and we used the following code to print \"Hello World\" to the screen:"
},
{
"type": "header",
"level": 3,
"text": "Example explained"
},
{
"type": "paragraph",
"text": "Every line of code that runs in Java must be inside a class. \nThe class name should always start with an uppercase first letter. In our example, we named the class Main."
},
{
"type": "paragraph",
"text": "Note: Java is case-sensitive. \nMyClass and myclass would be treated as two completely different names."
},
{
"type": "paragraph",
"text": "The name of the Java file must match the class name. \nSo if your class is called Main, the file must be saved as Main.java. \nThis is because Java uses the class name to find and run your code. If the names don't match, Java will give an error and the program will not run."
},
{
"type": "paragraph",
"text": "When saving the file, save it using the class name and add .java to the end of the filename. \nTo run the example above on your computer, make sure that Java is properly installed: \nGo to the Get Started Chapter for how to install Java. The output should be:"
},
{
"type": "header",
"level": 2,
"text": "The main Method"
},
{
"type": "paragraph",
"text": "The main() method is required in every Java program. It is where the program starts running:"
},
{
"type": "paragraph",
"text": "Any code placed inside the main() method will be executed."
},
{
"type": "paragraph",
"text": "For now, you don't need to understand the keywords public, static, and void. \nYou will learn about them later in this tutorial. \nJust remember: main() is the starting point of every Java program."
},
{
"type": "header",
"level": 2,
"text": "System.out.println()"
},
{
"type": "paragraph",
"text": "Inside the main() method, we can use the println() \nmethod to print a line of text to the screen:"
},
{
"type": "note",
"text": "Note: The curly braces {} mark the beginning and the end of a block of code.
System.out.println() may look long, but you can think of it as a single command that means: \n\"Send this text to the screen.\"
Here's what each part means (you will learn the details later):
\nSystem is a built-in Java class.out is a member of System, short for \"output\".println() is a method, short for \"print line\".Finally, remember that each Java statement must end with a semicolon (;).
println() method to output values or print text in Java:"
},
{
"type": "paragraph",
"text": "You can add as many println() methods as you want. Note that it will add a new line for each method:"
},
{
"type": "header",
"level": 2,
"text": "Double Quotes"
},
{
"type": "paragraph",
"text": "Text must be wrapped inside double quotations marks \"\"."
},
{
"type": "paragraph",
"text": "If you forget the double quotes, an error occurs:"
},
{
"type": "header",
"level": 2,
"text": "The Print() Method"
},
{
"type": "paragraph",
"text": "There is also a print() method, which is similar to println()."
},
{
"type": "paragraph",
"text": "The only difference is that it does not insert a new line at the end of the output:"
},
{
"type": "paragraph",
"text": "Note that we add an extra space (after \"Hello World!\" in the example above) \nfor better readability."
},
{
"type": "note",
"text": "In this tutorial, we will only use println() \nas it makes the code output easier to read.
System.out.print()", "No", "Output on the same line"],
["System.out.println()", "Yes", "One value per line (most common)"],
["System.out.printf()", "No (use %n)", "Formatted output with placeholders"]
]
},
{
"type": "code",
"language": "java",
"code": "System.out.print(\"Hello \"); // no newline\nSystem.out.println(\"World!\"); // adds newline \u2192 Hello World!\nSystem.out.printf(\"Hi %s! You are %d years old.%n\", \"Alice\", 25);\n// Hi Alice! You are 25 years old.\n\nint x = 42;\nSystem.out.println(\"Value: \" + x); // Value: 42 (concatenation)\nSystem.out.printf(\"Value: %d%n\", x); // Value: 42 (formatted)"
},
{
"type": "image",
"src": "assets/images/java/yt_logo_rgb_dark.png",
"alt": "Java Tutorial on YouTube"
}
]
},
"comments": {
"title": "Java Comments",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Java Comments"
},
{
"type": "paragraph",
"text": "Comments can be used to explain Java code, and to make it more readable. It can also be used to \nprevent execution when testing alternative code."
},
{
"type": "header",
"level": 2,
"text": "Single-line Comments"
},
{
"type": "paragraph",
"text": "Single-line comments start with two forward slashes (//)."
},
{
"type": "paragraph",
"text": "Any text between // and the end of the line \nis ignored by Java (will not be executed)."
},
{
"type": "paragraph",
"text": "This example uses a single-line comment before a line of code:"
},
{
"type": "paragraph",
"text": "This example uses a single-line comment at the end of a line of code:"
},
{
"type": "header",
"level": 2,
"text": "Java Multi-line Comments"
},
{
"type": "paragraph",
"text": "Multi-line comments start with /* and ends with */."
},
{
"type": "paragraph",
"text": "Any text between /* and */ will be ignored by Java."
},
{
"type": "paragraph",
"text": "This example uses a multi-line comment (a comment block) to explain the code:"
},
{
"type": "note",
"text": "It's up to you which one you use. Normally, we use // for short comments, and /* */ for longer.
String - stores text, such as \"Hello\". String values are \n surrounded by double quotes",
"int - stores integers (whole numbers), without decimals, such as 123 or -123",
"float - stores floating point numbers, with decimals, such as 19.99 or -19.99",
"char - stores single characters, such as \n 'a' or 'B'. Char values are surrounded by single quotes",
"boolean - stores values with two states: \n true or false"
]
},
{
"type": "header",
"level": 2,
"text": "Declaring (Creating) Variables"
},
{
"type": "paragraph",
"text": "To create a variable in Java, you need to:"
},
{
"type": "list",
"ordered": false,
"items": [
"Choose a type (like int or String)",
"Give the variable a name (like x, age, or name)",
"Optionally assign it a value using ="
]
},
{
"type": "paragraph",
"text": "Here's the basic syntax:"
},
{
"type": "playground",
"subtype": "syntax-anatomy",
"title": "Variable Syntax Breakdown",
"config": {
"tokens": [
{
"text": "int",
"type": "keyword",
"explanation": "The data type. It tells Java this variable will hold a whole number (integer)."
},
{
"text": " "
},
{
"text": "myAge",
"type": "variable",
"explanation": "The variable name. You choose this. It should describe what the value represents. Java uses camelCase by convention."
},
{
"text": " "
},
{
"text": "=",
"type": "operator",
"explanation": "The assignment operator. It assigns the value on the right to the variable on the left."
},
{
"text": " "
},
{
"text": "25",
"type": "value",
"explanation": "The value being stored in the variable. Since the type is int, this must be a whole number (no decimals)."
},
{
"text": ";",
"type": "operator",
"explanation": "The semicolon ends the statement. Every Java statement must end with a semicolon."
}
]
}
},
{
"type": "paragraph",
"text": "For example, if you want to store some text, you can use a String:"
},
{
"type": "paragraph",
"text": "To create a variable that should store a number, you can use int:"
},
{
"type": "paragraph",
"text": "You can also declare a variable without assigning the value, and assign the value later:"
},
{
"type": "paragraph",
"text": "Note that if you assign a new value to an existing variable, it will overwrite the previous value:"
},
{
"type": "header",
"level": 2,
"text": "Final Variables"
},
{
"type": "paragraph",
"text": "If you don't want others (or yourself) to overwrite existing values, use the final keyword (this will declare the variable as \"final\" or \"constant\", which means unchangeable and read-only):"
},
{
"type": "header",
"level": 2,
"text": "Other Types"
},
{
"type": "paragraph",
"text": "A demonstration of how to declare variables of other types:"
},
{
"type": "note",
"text": "You will learn more about data types in the next section.
" }, { "type": "playground", "subtype": "variable", "title": "Interactive Variable Lab", "config": { "type": "int", "name": "myAge", "value": "25" } }, { "type": "code", "language": "java", "code": "// Declare then assign separately\nint age;\nage = 25;\n\n// Declare and initialize together\nString name = \"Alice\";\ndouble salary = 45000.50;\nboolean isActive = true;\nchar grade = 'A';\n\n// Multiple vars of same type\nint x = 10, y = 20, z = 30;\n\n// var keyword (Java 10+) \u2014 type inferred\nvar city = \"Chennai\"; // String\nvar count = 100; // int\nSystem.out.println(city + \" \" + count); // Chennai 100" }, { "type": "image", "src": "assets/images/java/yt_logo_rgb_dark.png", "alt": "Java Tutorial on YouTube" } ] }, "data-types": { "title": "Java Data Types", "blocks": [ { "type": "header", "level": 2, "text": "Java Data Types" }, { "type": "paragraph", "text": "Every variable in Java must have a data type — it tells Java what kind of value the variable can hold and how much memory to reserve." }, { "type": "paragraph", "text": "Data types are divided into two groups:" }, { "type": "list", "ordered": false, "items": [ "Primitive data types — the 8 built-in types:byte, short, int, long, float, double, boolean and char",
"Non-primitive data types — such as String, Arrays, and Classes (you will learn these in later chapters)"
]
},
{
"type": "header",
"level": 2,
"text": "Primitive Data Types"
},
{
"type": "paragraph",
"text": "A primitive type stores a simple value directly in memory. There are exactly 8 of them in Java. Click each one below to explore its size, range, and usage:"
},
{
"type": "playground",
"subtype": "data-type-explorer"
},
{
"type": "header",
"level": 2,
"text": "Declaring Primitive Variables"
},
{
"type": "paragraph",
"text": "Here is how you declare variables for each of the common primitive types:"
},
{
"type": "playground",
"subtype": "output",
"title": "Primitive Type Declarations",
"config": {
"rows": [
{
"type": "comment",
"value": "// Integer types"
},
{
"type": "println",
"value": "\"byte: \" + (byte) 100"
},
{
"type": "println",
"value": "\"int: \" + 2147483647"
},
{
"type": "println",
"value": "\"long: \" + 8000000000L"
},
{
"type": "comment",
"value": "// Decimal types"
},
{
"type": "println",
"value": "\"float: \" + 3.14f"
},
{
"type": "println",
"value": "\"double: \" + 19.99"
},
{
"type": "comment",
"value": "// Other primitives"
},
{
"type": "println",
"value": "\"boolean: \" + true"
},
{
"type": "println",
"value": "\"char: \" + 'A'"
}
]
}
},
{
"type": "header",
"level": 2,
"text": "Primitive vs Non-Primitive"
},
{
"type": "list",
"ordered": false,
"items": [
"Primitive types always have a value — they can never be null",
"Non-primitive types (like String) can be null — meaning they reference no object",
"Primitives store values directly; non-primitives store a reference (memory address) to an object",
"Non-primitive types have built-in methods you can call (e.g. \"hello\".length())"
]
},
{
"type": "header",
"level": 2,
"text": "Types Are Fixed"
},
{
"type": "paragraph",
"text": "Once a variable is declared with a type, it cannot change to another type. Java is a statically typed language — the type is checked at compile time, not at runtime."
},
{
"type": "note",
"text": "If you need to convert a value from one type to another, use type casting — you will learn about this in the next chapter.
" }, { "type": "playground", "subtype": "syntax-anatomy", "title": "Type Declaration Anatomy", "config": { "tokens": [ { "text": "double", "type": "keyword", "explanation": "The data type. Tells Java this variable holds a decimal number with high precision." }, { "text": " " }, { "text": "price", "type": "variable", "explanation": "The variable name. Choose a meaningful name that describes what the value represents." }, { "text": " " }, { "text": "=", "type": "operator", "explanation": "The assignment operator. Assigns the value on the right to the variable on the left." }, { "text": " " }, { "text": "19.99", "type": "value", "explanation": "The literal value being stored. Because the type is double, decimals are allowed." }, { "text": ";", "type": "operator", "explanation": "Every Java statement ends with a semicolon." } ] } }, { "type": "code", "language": "java", "code": "byte small = 127; // -128 to 127\nshort medium = 32767; // -32,768 to 32,767\nint num = 2_000_000; // underscores improve readability\nlong big = 9_876_543_210L; // append L for long\nfloat price = 9.99f; // append f for float\ndouble pi = 3.14159265358979; // 15-16 decimal digits\nboolean flag = true;\nchar ch = 'J';\n\nSystem.out.println(Integer.MAX_VALUE); // 2147483647\nSystem.out.println(Double.MIN_VALUE); // 4.9E-324\nSystem.out.println(Character.isLetter(ch)); // true" }, { "type": "image", "src": "assets/images/java/yt_logo_rgb_dark.png", "alt": "Java Tutorial on YouTube" } ] }, "type-casting": { "title": "Java Type Casting", "blocks": [ { "type": "header", "level": 2, "text": "Java Type Casting" }, { "type": "paragraph", "text": "Type casting means converting a value from one data type into another. Java has two kinds — one happens automatically, and one you must do yourself." }, { "type": "list", "ordered": false, "items": [ "Widening Casting (automatic) — smaller type → larger type. Java does this for you because no data can be lost.", "Narrowing Casting (manual) — larger type → smaller type. You must write it explicitly because data may be lost (e.g. decimals are truncated)." ] }, { "type": "playground", "subtype": "type-casting" }, { "type": "header", "level": 2, "text": "Widening Casting" }, { "type": "paragraph", "text": "Widening casting is automatic — Java converts the value without any extra syntax. It is safe because a larger type can always hold a smaller type's value without losing any information." }, { "type": "playground", "subtype": "output", "title": "Widening: int → double", "config": { "rows": [ { "type": "comment", "value": "// int is automatically widened to double" }, { "type": "println", "value": "\"int value: \" + 9" }, { "type": "println", "value": "\"double value: \" + 9.0" } ] } }, { "type": "playground", "subtype": "syntax-anatomy", "title": "Widening Cast Anatomy", "config": { "tokens": [ { "text": "double", "type": "keyword", "explanation": "The target (larger) type. Java will automatically accept the int value here." }, { "text": " " }, { "text": "myDouble", "type": "variable", "explanation": "The new variable that will hold the widened value." }, { "text": " " }, { "text": "=", "type": "operator", "explanation": "Assignment operator. Java automatically converts the int on the right to double." }, { "text": " " }, { "text": "myInt", "type": "variable", "explanation": "The int variable being widened. No cast syntax needed — Java handles it automatically." }, { "text": ";", "type": "operator", "explanation": "End of statement." } ] } }, { "type": "header", "level": 2, "text": "Narrowing Casting" }, { "type": "paragraph", "text": "Narrowing casting is manual — you must place the target type in parentheses(targetType) before the value. This tells Java you are aware data might be lost."
},
{
"type": "note",
"text": "Data loss example: Casting 9.78 (double) to int gives 9 — the decimal part .78 is silently dropped (truncated, not rounded).
double before dividing — otherwise Java performs integer division and drops the decimal:"
},
{
"type": "playground",
"subtype": "output",
"title": "Score Percentage Calculator",
"config": {
"rows": [
{
"type": "comment",
"value": "// Without cast: integer division loses the decimal"
},
{
"type": "println",
"value": "\"Without cast: \" + (700 / 1000 * 100) + \"%\""
},
{
"type": "comment",
"value": "// With cast: correct percentage"
},
{
"type": "println",
"value": "\"With cast: \" + ((double) 700 / 1000 * 100) + \"%\""
}
]
}
},
{
"type": "image",
"src": "assets/images/java/yt_logo_rgb_dark.png",
"alt": "Java Tutorial on YouTube"
},
{
"type": "code",
"language": "java",
"code": "// Widening (automatic): smaller → larger type\nint myInt = 9;\ndouble myDouble = myInt; // int automatically becomes double\nSystem.out.println(myDouble); // 9.0\n\n// Narrowing (manual): larger → smaller type (decimal truncated)\ndouble pi = 3.14159;\nint piInt = (int) pi;\nSystem.out.println(piInt); // 3\n\n// Real-life use: percentage calculation\nint score = 700, maxScore = 1000;\ndouble pct = (double) score / maxScore * 100;\nSystem.out.println(pct + \"%\"); // 70.0%"
}
]
},
"operators": {
"title": "Java Operators",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Java Operators"
},
{
"type": "paragraph",
"text": "Operators are symbols that tell Java to perform an operation on variables or values. Java groups them into four main categories:"
},
{
"type": "list",
"ordered": false,
"items": [
"Arithmetic — perform math: + - * / % ++ --",
"Comparison — compare two values, always returns true or false: == != > < >= <=",
"Logical — combine boolean expressions: && || !",
"Assignment — assign or update a variable's value: = += -= *= /= %="
]
},
{
"type": "playground",
"subtype": "operators"
},
{
"type": "header",
"level": 2,
"text": "Arithmetic Operators"
},
{
"type": "paragraph",
"text": "Arithmetic operators perform standard math operations between two values. The % (modulus) operator returns the remainder after division — useful for checking if a number is even or odd."
},
{
"type": "playground",
"subtype": "syntax-anatomy",
"title": "Arithmetic Expression Anatomy",
"config": {
"tokens": [
{
"text": "int",
"type": "keyword",
"explanation": "Data type. The result of adding two ints is also an int."
},
{
"text": " "
},
{
"text": "result",
"type": "variable",
"explanation": "Variable that stores the outcome of the expression."
},
{
"text": " "
},
{
"text": "=",
"type": "operator",
"explanation": "Assignment operator — stores the computed value into result."
},
{
"text": " "
},
{
"text": "a",
"type": "variable",
"explanation": "The left operand — the first number in the operation."
},
{
"text": " "
},
{
"text": "+",
"type": "operator",
"explanation": "The arithmetic operator. Here it adds the values of a and b together."
},
{
"text": " "
},
{
"text": "b",
"type": "variable",
"explanation": "The right operand — the second number in the operation."
},
{
"text": ";",
"type": "operator",
"explanation": "Semicolon ends the statement."
}
]
}
},
{
"type": "header",
"level": 2,
"text": "Comparison Operators"
},
{
"type": "paragraph",
"text": "Comparison operators compare two values and always produce a boolean result — either true or false. They are the building blocks of conditions in if statements and loops."
},
{
"type": "note",
"text": "Don't confuse == (compare) with = (assign). Using = where you meant == is one of the most common beginner mistakes in Java.
&& (AND) — true only when both sides are true",
"|| (OR) — true when at least one side is true",
"! (NOT) — inverts the boolean value: !true → false"
]
},
{
"type": "header",
"level": 2,
"text": "Assignment Operators"
},
{
"type": "paragraph",
"text": "Assignment operators are shorthand for updating a variable. Instead of writing x = x + 5, you can write x += 5. They work for all arithmetic operations."
},
{
"type": "header",
"level": 2,
"text": "Compound Assignment Operators"
},
{
"type": "table",
"headers": ["Operator", "Example", "Equivalent to", "Meaning"],
"rows": [
["+=", "x += 5", "x = x + 5", "Add and assign"],
["-=", "x -= 3", "x = x - 3", "Subtract and assign"],
["*=", "x *= 2", "x = x * 2", "Multiply and assign"],
["/=", "x /= 4", "x = x / 4", "Divide and assign"],
["%=", "x %= 3", "x = x % 3", "Modulus and assign"]
]
},
{
"type": "header",
"level": 2,
"text": "Ternary Operator"
},
{
"type": "paragraph",
"text": "The ternary operator ? : is a one-line shorthand for a simple if-else. Syntax: condition ? valueIfTrue : valueIfFalse"
},
{
"type": "code",
"language": "java",
"code": "int age = 20;\nString status = (age >= 18) ? \"Adult\" : \"Minor\";\nSystem.out.println(status); // Adult\n\n// Same logic written as if-else:\nif (age >= 18) {\n status = \"Adult\";\n} else {\n status = \"Minor\";\n}\n\n// Another example — find the larger number\nint a = 10, b = 25;\nint max = (a > b) ? a : b;\nSystem.out.println(\"Max: \" + max); // Max: 25"
},
{
"type": "image",
"src": "assets/images/java/yt_logo_rgb_dark.png",
"alt": "Java Tutorial on YouTube"
}
]
},
"strings": {
"title": "Java Strings",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Java Strings"
},
{
"type": "intro",
"text": "A String stores text — any sequence of characters surrounded by double quotes. Unlike primitive types, String is an object with built-in methods you can call on it."
},
{
"type": "playground",
"subtype": "strings"
},
{
"type": "header",
"level": 2,
"text": "Declaring a String"
},
{
"type": "playground",
"subtype": "syntax-anatomy",
"config": {
"title": "String Declaration",
"tokens": [
{
"text": "String",
"type": "keyword",
"tip": "The String class — note the capital S"
},
{
"text": " name",
"type": "variable",
"tip": "Variable name"
},
{
"text": " = ",
"type": "operator"
},
{
"text": "\"Hello, Java!\"",
"type": "value",
"tip": "The text value — always wrapped in double quotes"
},
{
"text": ";",
"type": "punctuation"
}
]
}
},
{
"type": "header",
"level": 2,
"text": "Common String Methods"
},
{
"type": "list",
"ordered": false,
"items": [
"length() — number of characters",
"toUpperCase() / toLowerCase() — change case",
"trim() — remove leading/trailing whitespace",
"charAt(i) — character at index i",
"indexOf(s) — position of first match, or -1",
"contains(s) — returns true if match found",
"substring(i) — new string from index i to end",
"replace(a, b) — swap all occurrences of a with b"
]
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "String methods in action",
"rows": [
{
"code": "String txt = \"Hello, Java World!\";",
"output": ""
},
{
"code": "System.out.println(txt.length());",
"output": "18"
},
{
"code": "System.out.println(txt.toUpperCase());",
"output": "HELLO, JAVA WORLD!"
},
{
"code": "System.out.println(txt.indexOf(\"Java\"));",
"output": "7"
},
{
"code": "System.out.println(txt.replace(\"Java\", \"Tamil\"));",
"output": "Hello, Tamil World!"
}
]
}
},
{
"type": "note",
"text": "String indexes start at 0, just like arrays. The first character is at index 0, the second at index 1, and so on. Use charAt(0) to get the first character."
},
{
"type": "code",
"language": "java",
"code": "String s = \"Hello, Java!\";\nSystem.out.println(s.length()); // 12\nSystem.out.println(s.toUpperCase()); // HELLO, JAVA!\nSystem.out.println(s.substring(7, 11)); // Java\nSystem.out.println(s.contains(\"Java\")); // true\nSystem.out.println(s.replace(\"Java\", \"World\")); // Hello, World!\nSystem.out.println(s.charAt(0)); // H\n\n// Comparing \u2014 always use .equals()\nString a = \"hello\", b = \"hello\";\nSystem.out.println(a.equals(b)); // true \u2713\nSystem.out.println(a.equalsIgnoreCase(\"HELLO\")); // true"
}
]
},
"math": {
"title": "Java Math",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Java Math Class"
},
{
"type": "intro",
"text": "The Math class provides ready-to-use methods for common mathematical operations — no imports needed, just call Math.methodName()."
},
{
"type": "playground",
"subtype": "math"
},
{
"type": "header",
"level": 2,
"text": "Key Math Methods"
},
{
"type": "list",
"ordered": false,
"items": [
"Math.max(x, y) — returns the larger value",
"Math.min(x, y) — returns the smaller value",
"Math.abs(x) — removes the sign, always returns positive",
"Math.sqrt(x) — square root of x",
"Math.pow(base, exp) — base raised to the power of exp",
"Math.round(x) — rounds to nearest integer",
"Math.ceil(x) — always rounds up",
"Math.floor(x) — always rounds down",
"Math.random() — random double between 0.0 and 1.0"
]
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "Math methods",
"rows": [
{
"code": "System.out.println(Math.max(15, 42));",
"output": "42"
},
{
"code": "System.out.println(Math.abs(-64));",
"output": "64"
},
{
"code": "System.out.println(Math.sqrt(144));",
"output": "12.0"
},
{
"code": "System.out.println(Math.pow(2, 8));",
"output": "256.0"
},
{
"code": "System.out.println(Math.round(4.6));",
"output": "5"
}
]
}
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "Random number 0–99",
"rows": [
{
"code": "int rand = (int)(Math.random() * 100);",
"output": ""
},
{
"code": "System.out.println(rand);",
"output": "73 ← changes every run"
}
]
}
},
{
"type": "note",
"text": "Math.random() returns a different value every time the program runs. To get a random integer between 0 and N, use (int)(Math.random() * N)."
},
{
"type": "code",
"language": "java",
"code": "System.out.println(Math.max(15, 42)); // 42\nSystem.out.println(Math.min(15, 42)); // 15\nSystem.out.println(Math.abs(-64)); // 64\nSystem.out.println(Math.sqrt(144)); // 12.0\nSystem.out.println(Math.pow(2, 10)); // 1024.0\nSystem.out.println(Math.round(4.6)); // 5\nSystem.out.println(Math.ceil(4.2)); // 5.0\nSystem.out.println(Math.floor(4.9)); // 4.0\n\n// Random integer 0–99\nint rand = (int)(Math.random() * 100);\nSystem.out.println(rand); // e.g. 73 (changes every run)"
}
]
},
"booleans": {
"title": "Java Booleans",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Java Booleans"
},
{
"type": "paragraph",
"text": "A boolean is the simplest data type in Java — it can only ever be true or false. Booleans are the foundation of every decision your program makes."
},
{
"type": "list",
"ordered": false,
"items": [
"Is the user logged in? → boolean isLoggedIn = true;",
"Is the light on? → boolean isLightOn = false;",
"Is it raining? → boolean isRaining = true;"
]
},
{
"type": "playground",
"subtype": "syntax-anatomy",
"title": "Boolean Declaration Anatomy",
"config": {
"tokens": [
{
"text": "boolean",
"type": "keyword",
"explanation": "The data type. A boolean can only hold true or false — nothing else."
},
{
"text": " "
},
{
"text": "isLoggedIn",
"type": "variable",
"explanation": "The variable name. Boolean names usually start with 'is', 'has', or 'can' to make them read like a yes/no question."
},
{
"text": " "
},
{
"text": "=",
"type": "operator",
"explanation": "Assignment operator."
},
{
"text": " "
},
{
"text": "true",
"type": "value",
"explanation": "The boolean value. Only two options exist: true or false (always lowercase in Java)."
},
{
"text": ";",
"type": "operator",
"explanation": "End of statement."
}
]
}
},
{
"type": "header",
"level": 2,
"text": "Boolean Expressions"
},
{
"type": "paragraph",
"text": "In practice, booleans are rarely written as literals. They are almost always the result of an expression — a comparison that Java evaluates to true or false:"
},
{
"type": "playground",
"subtype": "output",
"title": "Boolean Expressions",
"config": {
"rows": [
{
"type": "comment",
"value": "// Direct boolean values"
},
{
"type": "println",
"value": "\"true: \" + true"
},
{
"type": "println",
"value": "\"false: \" + false"
},
{
"type": "comment",
"value": "// Boolean from a comparison expression"
},
{
"type": "println",
"value": "\"10 > 5: \" + (10 > 5)"
},
{
"type": "println",
"value": "\"10 < 5: \" + (10 < 5)"
},
{
"type": "println",
"value": "\"10 == 10: \" + (10 == 10)"
}
]
}
},
{
"type": "header",
"level": 2,
"text": "Real-Life Example: Voting Age"
},
{
"type": "paragraph",
"text": "Booleans shine when you use them to make decisions. Here we check if a person is old enough to vote (age ≥ 18) and print a different message depending on the result:"
},
{
"type": "playground",
"subtype": "output",
"title": "Voting Age Checker",
"config": {
"rows": [
{
"type": "comment",
"value": "// Change the age and run again to see a different result"
},
{
"type": "println",
"value": "\"Age: 20\""
},
{
"type": "println",
"value": "\"Old enough to vote: \" + (20 >= 18)"
},
{
"type": "println",
"value": "\"---\""
},
{
"type": "println",
"value": "\"Age: 15\""
},
{
"type": "println",
"value": "\"Old enough to vote: \" + (15 >= 18)"
}
]
}
},
{
"type": "header",
"level": 2,
"text": "Combining Booleans"
},
{
"type": "paragraph",
"text": "You can combine boolean expressions using logical operators to build more complex conditions:"
},
{
"type": "playground",
"subtype": "output",
"title": "Logical Operators with Booleans",
"config": {
"rows": [
{
"type": "comment",
"value": "// AND (&&): both must be true"
},
{
"type": "println",
"value": "\"18 >= 18 && 18 < 65: \" + (18 >= 18 && 18 < 65)"
},
{
"type": "comment",
"value": "// OR (||): at least one must be true"
},
{
"type": "println",
"value": "\"isStudent || isSenior: \" + (true || false)"
},
{
"type": "comment",
"value": "// NOT (!): inverts the result"
},
{
"type": "println",
"value": "\"!false: \" + !false"
}
]
}
},
{
"type": "note",
"text": "Booleans are the foundation of all decision-making in Java. Every if statement, every loop condition, every comparison — they all produce or consume a boolean value. You will learn how to use them in if...else in the next chapter.
if to run a block of code only when a condition is true. If the condition is false, the block is skipped entirely."
},
{
"type": "playground",
"subtype": "syntax-anatomy",
"config": {
"title": "if Statement",
"tokens": [
{
"text": "if",
"type": "keyword",
"tip": "Keyword that starts a conditional check"
},
{
"text": " ",
"type": "plain"
},
{
"text": "(",
"type": "punctuation",
"tip": "Opening parenthesis — condition goes inside"
},
{
"text": "age",
"type": "variable",
"tip": "The variable being checked"
},
{
"text": " >= ",
"type": "operator",
"tip": "Comparison operator: greater than or equal to"
},
{
"text": "18",
"type": "value",
"tip": "The value to compare against"
},
{
"text": ")",
"type": "punctuation",
"tip": "Closing parenthesis"
},
{
"text": " {",
"type": "punctuation",
"tip": "Opening brace — code block starts here"
},
{
"text": "\n System.out.println(...);",
"type": "plain"
},
{
"text": "\n}",
"type": "punctuation",
"tip": "Closing brace — code block ends here"
}
]
}
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "if Statement",
"rows": [
{
"code": "int age = 20;",
"output": ""
},
{
"code": "if (age >= 18) {",
"output": ""
},
{
"code": " System.out.println(\"You can vote!\");",
"output": "You can vote!"
},
{
"code": "}",
"output": ""
}
]
}
},
{
"type": "header",
"level": 2,
"text": "The else Statement"
},
{
"type": "paragraph",
"text": "Add an else block to handle the case when the condition is false. Only one of the two blocks will ever run — never both."
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "if...else Statement",
"rows": [
{
"code": "int age = 15;",
"output": ""
},
{
"code": "if (age >= 18) {",
"output": ""
},
{
"code": " System.out.println(\"You can vote!\");",
"output": ""
},
{
"code": "} else {",
"output": ""
},
{
"code": " System.out.println(\"Too young to vote.\");",
"output": "Too young to vote."
},
{
"code": "}",
"output": ""
}
]
}
},
{
"type": "header",
"level": 2,
"text": "The else if Statement"
},
{
"type": "paragraph",
"text": "When you need to check more than two possibilities, chain else if blocks. Java checks each condition from top to bottom and runs the first one that is true."
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "if...else if...else",
"rows": [
{
"code": "int score = 82;",
"output": ""
},
{
"code": "if (score >= 90) {",
"output": ""
},
{
"code": " System.out.println(\"Grade: A\");",
"output": ""
},
{
"code": "} else if (score >= 75) {",
"output": ""
},
{
"code": " System.out.println(\"Grade: B\");",
"output": "Grade: B"
},
{
"code": "} else if (score >= 50) {",
"output": ""
},
{
"code": " System.out.println(\"Grade: C\");",
"output": ""
},
{
"code": "} else {",
"output": ""
},
{
"code": " System.out.println(\"Grade: F\");",
"output": ""
},
{
"code": "}",
"output": ""
}
]
}
},
{
"type": "header",
"level": 2,
"text": "Conditions Use Comparison Operators"
},
{
"type": "paragraph",
"text": "Every if condition evaluates to true or false. You build conditions using comparison operators:"
},
{
"type": "list",
"ordered": false,
"items": [
"a == b — Equal to",
"a != b — Not equal to",
"a > b — Greater than",
"a < b — Less than",
"a >= b — Greater than or equal to",
"a <= b — Less than or equal to"
]
},
{
"type": "note",
"text": "Always use curly braces { } even for single-line if blocks. Without them, only the very next line belongs to the if — a common source of bugs."
},
{
"type": "code",
"language": "java",
"code": "int score = 75;\nif (score >= 90) {\n System.out.println(\"A\");\n} else if (score >= 80) {\n System.out.println(\"B\");\n} else if (score >= 70) {\n System.out.println(\"C\");\n} else {\n System.out.println(\"Below C\");\n}\n// Output: C\n\n// Ternary shorthand\nString result = (score >= 50) ? \"Pass\" : \"Fail\";\nSystem.out.println(result); // Pass"
}
]
},
"switch": {
"title": "Java Switch",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Java Switch Statements"
},
{
"type": "intro",
"text": "When you have many specific values to check, a switch statement is cleaner and more readable than a long chain of if...else if."
},
{
"type": "paragraph",
"text": "Think of it like a TV remote: press button 1 → Channel 1, press 2 → Channel 2, press anything else → nothing happens. Java evaluates the expression once, then jumps directly to the matching case."
},
{
"type": "playground",
"subtype": "switch"
},
{
"type": "header",
"level": 2,
"text": "Switch Statement Syntax"
},
{
"type": "playground",
"subtype": "syntax-anatomy",
"config": {
"title": "switch Statement",
"tokens": [
{
"text": "switch",
"type": "keyword",
"tip": "Keyword that starts a switch statement"
},
{
"text": " (",
"type": "punctuation"
},
{
"text": "day",
"type": "variable",
"tip": "The variable being matched against cases"
},
{
"text": ") {",
"type": "punctuation",
"tip": "Opening brace — cases go inside"
},
{
"text": "\n case ",
"type": "keyword",
"tip": "Each case checks for a specific value"
},
{
"text": "1",
"type": "value",
"tip": "The exact value this case matches"
},
{
"text": ":",
"type": "punctuation"
},
{
"text": "\n System.out.println(...);",
"type": "plain"
},
{
"text": "\n break",
"type": "keyword",
"tip": "Exits the switch — prevents fall-through to the next case"
},
{
"text": ";",
"type": "punctuation"
},
{
"text": "\n default",
"type": "keyword",
"tip": "Runs if no case matches — like the final else"
},
{
"text": ":",
"type": "punctuation"
},
{
"text": "\n System.out.println(...);",
"type": "plain"
},
{
"text": "\n}",
"type": "punctuation",
"tip": "Closing brace — end of switch block"
}
]
}
},
{
"type": "header",
"level": 2,
"text": "How It Works"
},
{
"type": "list",
"ordered": true,
"items": [
"Java evaluates the switch expression once.",
"It compares the result against each case value from top to bottom.",
"When a match is found, that block of code runs.",
"break exits the switch — without it, Java continues into the next case (fall-through).",
"default runs if no case matches — it is optional."
]
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "Day of Week",
"rows": [
{
"code": "int day = 3;",
"output": ""
},
{
"code": "switch (day) {",
"output": ""
},
{
"code": " case 1: System.out.println(\"Monday\"); break;",
"output": ""
},
{
"code": " case 2: System.out.println(\"Tuesday\"); break;",
"output": ""
},
{
"code": " case 3: System.out.println(\"Wednesday\"); break;",
"output": "Wednesday"
},
{
"code": " case 4: System.out.println(\"Thursday\"); break;",
"output": ""
},
{
"code": " case 5: System.out.println(\"Friday\"); break;",
"output": ""
},
{
"code": " default: System.out.println(\"Weekend!\");",
"output": ""
},
{
"code": "}",
"output": ""
}
]
}
},
{
"type": "header",
"level": 2,
"text": "The break Keyword"
},
{
"type": "paragraph",
"text": "Without break, Java keeps running into the next case block even after a match — this is called fall-through. This is rarely what you want."
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "Fall-through (no break!)",
"rows": [
{
"code": "int day = 2;",
"output": ""
},
{
"code": "switch (day) {",
"output": ""
},
{
"code": " case 1: System.out.println(\"Monday\");",
"output": ""
},
{
"code": " case 2: System.out.println(\"Tuesday\");",
"output": "Tuesday"
},
{
"code": " case 3: System.out.println(\"Wednesday\");",
"output": "Wednesday"
},
{
"code": " default: System.out.println(\"Other\");",
"output": "Other"
},
{
"code": "}",
"output": ""
}
]
}
},
{
"type": "note",
"text": "Fall-through printed three lines instead of one because there were no break statements. Always add break; after each case unless you intentionally want fall-through."
},
{
"type": "header",
"level": 2,
"text": "The default Keyword"
},
{
"type": "paragraph",
"text": "The default block runs when no case matches. It works like the final else in an if-else chain and is optional but recommended."
},
{
"type": "note",
"text": "switch vs if-else: Use switch when you're comparing one variable against many specific, known values. Use if-else when your conditions involve ranges (e.g. score >= 90) or complex expressions."
},
{
"type": "code",
"language": "java",
"code": "int day = 3;\nswitch (day) {\n case 1: System.out.println(\"Monday\"); break;\n case 2: System.out.println(\"Tuesday\"); break;\n case 3: System.out.println(\"Wednesday\"); break;\n case 4: System.out.println(\"Thursday\"); break;\n case 5: System.out.println(\"Friday\"); break;\n default: System.out.println(\"Weekend!\");\n}\n// Output: Wednesday\n\n// Switch expression (Java 14+)\nString type = switch (day) {\n case 1, 2, 3, 4, 5 -> \"Weekday\";\n default -> \"Weekend\";\n};\nSystem.out.println(type); // Weekday"
}
]
},
"while-loop": {
"title": "Java While Loop",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Java While Loop"
},
{
"type": "intro",
"text": "A while loop keeps running a block of code as long as a condition stays true. The moment the condition becomes false, the loop stops."
},
{
"type": "paragraph",
"text": "Think of it like a vending machine: keep dispensing items while there are items left. When the stock hits zero, stop."
},
{
"type": "playground",
"subtype": "while-loop"
},
{
"type": "header",
"level": 2,
"text": "Syntax"
},
{
"type": "playground",
"subtype": "syntax-anatomy",
"config": {
"title": "while Loop",
"tokens": [
{
"text": "while",
"type": "keyword",
"tip": "Keyword that starts the loop"
},
{
"text": " (",
"type": "punctuation"
},
{
"text": "i < 5",
"type": "operator",
"tip": "Condition checked before every iteration — must evaluate to true or false"
},
{
"text": ") {",
"type": "punctuation",
"tip": "Opening brace — loop body starts here"
},
{
"text": "\n System.out.println(i);",
"type": "plain"
},
{
"text": "\n i",
"type": "variable",
"tip": "Counter variable"
},
{
"text": "++",
"type": "operator",
"tip": "Update — without this the loop runs forever!"
},
{
"text": ";",
"type": "punctuation"
},
{
"text": "\n}",
"type": "punctuation",
"tip": "Closing brace — loop body ends here"
}
]
}
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "Count up while i < 5",
"rows": [
{
"code": "int i = 0;",
"output": ""
},
{
"code": "while (i < 5) {",
"output": ""
},
{
"code": " System.out.println(i);",
"output": "0\n1\n2\n3\n4"
},
{
"code": " i++;",
"output": ""
},
{
"code": "}",
"output": ""
}
]
}
},
{
"type": "header",
"level": 2,
"text": "Countdown Example"
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "Countdown from 3",
"rows": [
{
"code": "int count = 3;",
"output": ""
},
{
"code": "while (count > 0) {",
"output": ""
},
{
"code": " System.out.println(count + \"...\");",
"output": "3...\n2...\n1..."
},
{
"code": " count--;",
"output": ""
},
{
"code": "}",
"output": ""
},
{
"code": "System.out.println(\"Go!\");",
"output": "Go!"
}
]
}
},
{
"type": "note",
"text": "Always update the variable inside the loop. If i++ is missing, the condition never becomes false and the loop runs forever — an infinite loop that freezes the program."
},
{
"type": "code",
"language": "java",
"code": "// while loop\nint i = 1;\nwhile (i <= 5) {\n System.out.print(i + \" \"); // 1 2 3 4 5\n i++;\n}\n\n// do-while \u2014 executes at least once\nint n = 0;\ndo {\n System.out.println(\"Attempt: \" + n);\n n++;\n} while (n < 3);\n\n// Sum using while\nint sum = 0, num = 1;\nwhile (num <= 10) { sum += num; num++; }\nSystem.out.println(\"Sum 1-10: \" + sum); // 55"
}
]
},
"for-loop": {
"title": "Java For Loop",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Java For Loop"
},
{
"type": "intro",
"text": "Use a for loop when you know exactly how many times the loop should run. It packs the init, condition, and update into one compact line."
},
{
"type": "playground",
"subtype": "for-loop"
},
{
"type": "header",
"level": 2,
"text": "The Three Parts of a for Loop"
},
{
"type": "playground",
"subtype": "syntax-anatomy",
"config": {
"title": "for Loop",
"tokens": [
{
"text": "for",
"type": "keyword",
"tip": "Keyword that starts the for loop"
},
{
"text": " (",
"type": "punctuation"
},
{
"text": "int i = 0",
"type": "variable",
"tip": "Statement 1: runs once before the loop starts — initialise your counter"
},
{
"text": "; ",
"type": "punctuation"
},
{
"text": "i < 5",
"type": "operator",
"tip": "Statement 2: checked before every iteration — loop runs while this is true"
},
{
"text": "; ",
"type": "punctuation"
},
{
"text": "i++",
"type": "keyword",
"tip": "Statement 3: runs after every iteration — update the counter"
},
{
"text": ") {",
"type": "punctuation"
},
{
"text": "\n System.out.println(i);",
"type": "plain"
},
{
"text": "\n}",
"type": "punctuation",
"tip": "Closing brace — end of loop body"
}
]
}
},
{
"type": "list",
"ordered": true,
"items": [
"Init (int i = 0) — runs once before the loop starts. Sets the starting value.",
"Condition (i < 5) — checked before every iteration. If false, loop stops.",
"Update (i++) — runs after every iteration. Moves the counter forward."
]
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "Print 0 to 4",
"rows": [
{
"code": "for (int i = 0; i < 5; i++) {",
"output": ""
},
{
"code": " System.out.println(i);",
"output": "0\n1\n2\n3\n4"
},
{
"code": "}",
"output": ""
}
]
}
},
{
"type": "header",
"level": 2,
"text": "More Examples"
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "Even numbers 2–10",
"rows": [
{
"code": "for (int i = 2; i <= 10; i += 2) {",
"output": ""
},
{
"code": " System.out.println(i);",
"output": "2\n4\n6\n8\n10"
},
{
"code": "}",
"output": ""
}
]
}
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "Sum of 1 to 5",
"rows": [
{
"code": "int sum = 0;",
"output": ""
},
{
"code": "for (int i = 1; i <= 5; i++) {",
"output": ""
},
{
"code": " sum += i;",
"output": ""
},
{
"code": "}",
"output": ""
},
{
"code": "System.out.println(\"Sum = \" + sum);",
"output": "Sum = 15"
}
]
}
},
{
"type": "note",
"text": "for vs while: Use for when you know the number of iterations in advance. Use while when the loop count depends on a condition that can change unpredictably."
},
{
"type": "code",
"language": "java",
"code": "// Count from 1 to 5\nfor (int i = 1; i <= 5; i++) {\n System.out.print(i + \" \"); // 1 2 3 4 5\n}\n\n// Enhanced for-each \u2014 arrays\nint[] nums = {10, 20, 30, 40, 50};\nfor (int n : nums) {\n System.out.print(n + \" \"); // 10 20 30 40 50\n}\n\n// Nested loops \u2014 times table\nfor (int i = 1; i <= 3; i++) {\n for (int j = 1; j <= 3; j++) {\n System.out.printf(\"%3d\", i * j);\n }\n System.out.println();\n}"
}
]
},
"break-continue": {
"title": "Java Break and Continue",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Controlling Loop Flow"
},
{
"type": "intro",
"text": "Sometimes you need to exit a loop early or skip one iteration. Java gives you two keywords for this: break and continue."
},
{
"type": "playground",
"subtype": "break-continue"
},
{
"type": "header",
"level": 2,
"text": "The break Statement"
},
{
"type": "paragraph",
"text": "break immediately exits the entire loop. No more iterations run — execution jumps to the line after the closing brace."
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "break — stop at 5",
"rows": [
{
"code": "for (int i = 1; i <= 9; i++) {",
"output": ""
},
{
"code": " if (i == 5) { break; }",
"output": ""
},
{
"code": " System.out.println(i);",
"output": "1\n2\n3\n4"
},
{
"code": "}",
"output": ""
}
]
}
},
{
"type": "header",
"level": 2,
"text": "The continue Statement"
},
{
"type": "paragraph",
"text": "continue skips the rest of the current iteration and jumps straight to the next one. The loop itself keeps running."
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "continue — skip 4",
"rows": [
{
"code": "for (int i = 1; i <= 7; i++) {",
"output": ""
},
{
"code": " if (i == 4) { continue; }",
"output": ""
},
{
"code": " System.out.println(i);",
"output": "1\n2\n3\n5\n6\n7"
},
{
"code": "}",
"output": ""
}
]
}
},
{
"type": "header",
"level": 2,
"text": "Using Both Together"
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "skip 3, stop at 7",
"rows": [
{
"code": "for (int i = 1; i <= 9; i++) {",
"output": ""
},
{
"code": " if (i == 3) { continue; }",
"output": ""
},
{
"code": " if (i == 7) { break; }",
"output": ""
},
{
"code": " System.out.println(i);",
"output": "1\n2\n4\n5\n6"
},
{
"code": "}",
"output": ""
}
]
}
},
{
"type": "note",
"text": "break and continue work the same way in while loops. break always exits the nearest enclosing loop, and continue always skips to the next iteration of that same loop."
},
{
"type": "code",
"language": "java",
"code": "// break \u2014 exit loop early\nfor (int i = 1; i <= 9; i++) {\n if (i == 5) break;\n System.out.print(i + \" \"); // 1 2 3 4\n}\n\n// continue \u2014 skip one iteration\nfor (int i = 1; i <= 9; i++) {\n if (i % 2 == 0) continue; // skip even\n System.out.print(i + \" \"); // 1 3 5 7 9\n}\n\n// Labelled break \u2014 exit outer loop\nouter:\nfor (int i = 1; i <= 3; i++) {\n for (int j = 1; j <= 3; j++) {\n if (i == 2 && j == 2) break outer;\n System.out.println(i + \",\" + j);\n }\n}"
}
]
},
"arrays": {
"title": "Java Arrays",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Java Arrays"
},
{
"type": "intro",
"text": "An array stores multiple values of the same type in a single variable — like a row of numbered boxes, each holding one item."
},
{
"type": "paragraph",
"text": "Instead of writing String car1 = \"Volvo\", String car2 = \"BMW\"... you store them all in one array and access each by its index."
},
{
"type": "playground",
"subtype": "arrays"
},
{
"type": "header",
"level": 2,
"text": "Declaring and Initialising an Array"
},
{
"type": "playground",
"subtype": "syntax-anatomy",
"config": {
"title": "Array Declaration",
"tokens": [
{
"text": "String",
"type": "keyword",
"tip": "The type of every element in the array"
},
{
"text": "[]",
"type": "punctuation",
"tip": "Square brackets declare this as an array"
},
{
"text": " cars",
"type": "variable",
"tip": "The array variable name"
},
{
"text": " = ",
"type": "operator"
},
{
"text": "{",
"type": "punctuation",
"tip": "Opening brace — list your values inside"
},
{
"text": "\"Volvo\"",
"type": "value",
"tip": "Element at index 0"
},
{
"text": ", ",
"type": "punctuation"
},
{
"text": "\"BMW\"",
"type": "value",
"tip": "Element at index 1"
},
{
"text": ", ",
"type": "punctuation"
},
{
"text": "\"Ford\"",
"type": "value",
"tip": "Element at index 2"
},
{
"text": "}",
"type": "punctuation",
"tip": "Closing brace"
},
{
"text": ";",
"type": "punctuation"
}
]
}
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "Access by index",
"rows": [
{
"code": "String[] cars = {\"Volvo\", \"BMW\", \"Ford\"};",
"output": ""
},
{
"code": "System.out.println(cars[0]);",
"output": "Volvo"
},
{
"code": "System.out.println(cars[1]);",
"output": "BMW"
},
{
"code": "System.out.println(cars[2]);",
"output": "Ford"
},
{
"code": "System.out.println(cars.length);",
"output": "3"
}
]
}
},
{
"type": "header",
"level": 2,
"text": "Loop Through an Array"
},
{
"type": "paragraph",
"text": "Use a for loop with .length to visit every element:"
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "Loop through array",
"rows": [
{
"code": "int[] scores = {92, 78, 85, 61};",
"output": ""
},
{
"code": "for (int i = 0; i < scores.length; i++) {",
"output": ""
},
{
"code": " System.out.println(scores[i]);",
"output": "92\n78\n85\n61"
},
{
"code": "}",
"output": ""
}
]
}
},
{
"type": "note",
"text": "Index starts at 0, not 1. An array of 4 elements has indexes 0, 1, 2, 3. Accessing index 4 throws an ArrayIndexOutOfBoundsException. Use .length - 1 to safely reach the last element."
},
{
"type": "code",
"language": "java",
"code": "int[] nums = {10, 20, 30, 40, 50};\nSystem.out.println(nums.length); // 5\nSystem.out.println(nums[2]); // 30\nnums[2] = 99;\n\n// for-each traversal\nfor (int n : nums) System.out.print(n + \" \"); // 10 20 99 40 50\n\n// Sort\njava.util.Arrays.sort(nums);\nSystem.out.println(java.util.Arrays.toString(nums)); // [10, 20, 40, 50, 99]\n\n// 2D array\nint[][] grid = {{1,2,3},{4,5,6},{7,8,9}};\nSystem.out.println(grid[1][2]); // 6"
}
]
},
"methods": {
"title": "Java Methods",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Java Methods"
},
{
"type": "intro",
"text": "A method is a reusable block of code that runs only when called. Define it once, call it anywhere — as many times as you need."
},
{
"type": "playground",
"subtype": "methods"
},
{
"type": "header",
"level": 2,
"text": "Method Anatomy"
},
{
"type": "playground",
"subtype": "syntax-anatomy",
"config": {
"title": "Method Definition",
"tokens": [
{
"text": "static",
"type": "keyword",
"tip": "The method belongs to the class, not to an object"
},
{
"text": " ",
"type": "plain"
},
{
"text": "int",
"type": "keyword",
"tip": "Return type — what the method gives back. Use void if it returns nothing."
},
{
"text": " ",
"type": "plain"
},
{
"text": "add",
"type": "variable",
"tip": "Method name — use camelCase by convention"
},
{
"text": "(",
"type": "punctuation",
"tip": "Opening parenthesis — parameters go inside"
},
{
"text": "int a",
"type": "variable",
"tip": "First parameter: type then name"
},
{
"text": ", ",
"type": "punctuation"
},
{
"text": "int b",
"type": "variable",
"tip": "Second parameter"
},
{
"text": ") {",
"type": "punctuation",
"tip": "Opening brace — method body starts here"
},
{
"text": "\n return a + b;",
"type": "plain"
},
{
"text": "\n}",
"type": "punctuation",
"tip": "Closing brace — method body ends here"
}
]
}
},
{
"type": "header",
"level": 2,
"text": "Defining and Calling"
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "void method — no return value",
"rows": [
{
"code": "static void greet(String name) {",
"output": ""
},
{
"code": " System.out.println(\"Hello, \" + name + \"!\");",
"output": ""
},
{
"code": "}",
"output": ""
},
{
"code": "// calling the method:",
"output": ""
},
{
"code": "greet(\"Sathish\");",
"output": "Hello, Sathish!"
},
{
"code": "greet(\"Java\");",
"output": "Hello, Java!"
}
]
}
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "int method — with return value",
"rows": [
{
"code": "static int add(int a, int b) {",
"output": ""
},
{
"code": " return a + b;",
"output": ""
},
{
"code": "}",
"output": ""
},
{
"code": "int result = add(12, 8);",
"output": ""
},
{
"code": "System.out.println(result);",
"output": "20"
}
]
}
},
{
"type": "note",
"text": "void means the method does not return anything — it just performs an action. When you need the method to produce a value, replace void with the return type (int, String, boolean, etc.) and add a return statement."
},
{
"type": "code",
"language": "java",
"code": "// Return a value\nstatic int multiply(int a, int b) {\n return a * b;\n}\n\n// Void \u2014 perform action, return nothing\nstatic void greet(String name) {\n System.out.println(\"Hello, \" + name + \"!\");\n}\n\nSystem.out.println(\"4 \u00d7 7 = \" + multiply(4, 7)); // 4 \u00d7 7 = 28\ngreet(\"Alice\"); // Hello, Alice!\n\n// Overloading \u2014 same name, different params\nstatic double multiply(double a, double b) { return a * b; }\nSystem.out.println(multiply(2.5, 4.0)); // 10.0"
}
]
},
"method-parameters": {
"title": "Java Method Parameters",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Parameters and Arguments"
},
{
"type": "intro",
"text": "Parameters are the variables listed in the method definition. Arguments are the actual values you pass when calling the method."
},
{
"type": "playground",
"subtype": "methods"
},
{
"type": "playground",
"subtype": "syntax-anatomy",
"config": {
"title": "Parameters vs Arguments",
"tokens": [
{
"text": "static void",
"type": "keyword"
},
{
"text": " greet",
"type": "variable",
"tip": "Method name"
},
{
"text": "(",
"type": "punctuation"
},
{
"text": "String",
"type": "keyword",
"tip": "Parameter type"
},
{
"text": " name",
"type": "variable",
"tip": "Parameter — acts as a local variable inside the method"
},
{
"text": ") {",
"type": "punctuation"
},
{
"text": "\n System.out.println(\"Hello, \" + name);",
"type": "plain"
},
{
"text": "\n}",
"type": "punctuation"
},
{
"text": "\n\ngreet(",
"type": "plain"
},
{
"text": "\"Sathish\"",
"type": "value",
"tip": "Argument — the real value passed at call time"
},
{
"text": ");",
"type": "punctuation"
}
]
}
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "Single parameter",
"rows": [
{
"code": "static void greet(String name) {",
"output": ""
},
{
"code": " System.out.println(\"Hello, \" + name + \"!\");",
"output": ""
},
{
"code": "}",
"output": ""
},
{
"code": "greet(\"Priya\");",
"output": "Hello, Priya!"
},
{
"code": "greet(\"Kumar\");",
"output": "Hello, Kumar!"
}
]
}
},
{
"type": "header",
"level": 2,
"text": "Multiple Parameters"
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "Multiple parameters",
"rows": [
{
"code": "static void printAge(String name, int age) {",
"output": ""
},
{
"code": " System.out.println(name + \" is \" + age + \" years old.\");",
"output": ""
},
{
"code": "}",
"output": ""
},
{
"code": "printAge(\"Arun\", 22);",
"output": "Arun is 22 years old."
},
{
"code": "printAge(\"Meena\", 19);",
"output": "Meena is 19 years old."
}
]
}
},
{
"type": "header",
"level": 2,
"text": "Return Values"
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "Method with return value",
"rows": [
{
"code": "static int multiply(int a, int b) {",
"output": ""
},
{
"code": " return a * b;",
"output": ""
},
{
"code": "}",
"output": ""
},
{
"code": "System.out.println(multiply(6, 7));",
"output": "42"
},
{
"code": "System.out.println(multiply(3, 9));",
"output": "27"
}
]
}
},
{
"type": "note",
"text": "Parameter = variable in the definition. Argument = value at the call site. Arguments must match parameters in number, order, and type."
},
{
"type": "code",
"language": "java",
"code": "// Pass by value \u2014 original unchanged\nstatic void doubleIt(int n) { n = n * 2; }\nint x = 5;\ndoubleIt(x);\nSystem.out.println(x); // 5 \u2014 not changed\n\n// Return a value\nstatic int square(int n) { return n * n; }\nSystem.out.println(square(7)); // 49\n\n// Varargs \u2014 variable number of args\nstatic int sum(int... nums) {\n int total = 0;\n for (int n : nums) total += n;\n return total;\n}\nSystem.out.println(sum(1, 2, 3, 4, 5)); // 15"
}
]
},
"method-overloading": {
"title": "Java Method Overloading",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Method Overloading"
},
{
"type": "paragraph",
"text": "With method overloading, multiple methods can have the same name with different\nparameters:"
},
{
"type": "paragraph",
"text": "Consider the following example, which has two methods that add numbers of different type:"
},
{
"type": "paragraph",
"text": "Instead of defining two methods that should do the same thing, it is better to overload one."
},
{
"type": "paragraph",
"text": "In the example below, we overload the plusMethod \nmethod to work for both int \nand double:"
},
{
"type": "header",
"level": 2,
"text": "Overloading Rules"
},
{
"type": "list",
"ordered": false,
"items": [
"Methods must have the same name",
"They must differ in number of parameters, type of parameters, or both",
"Return type alone is not enough to distinguish overloaded methods",
"Overloading is resolved at compile time (static dispatch)"
]
},
{
"type": "code",
"language": "java",
"code": "// Overloaded area() — same name, different parameters\nstatic double area(double r) {\n return Math.PI * r * r; // circle\n}\nstatic double area(double w, double h) {\n return w * h; // rectangle\n}\nstatic double area(double b, double h, boolean triangle) {\n return 0.5 * b * h; // triangle\n}\n\n// Java picks the right version automatically\nSystem.out.println(area(5.0)); // 78.54 (circle)\nSystem.out.println(area(4.0, 6.0)); // 24.0 (rectangle)"
},
{
"type": "playground",
"subtype": "method-overloading"
},
{
"type": "header",
"level": 2,
"text": "When to Use Method Overloading"
},
{
"type": "list",
"ordered": false,
"items": [
"When the same logical operation should work on different data types (e.g., add(int) vs add(double))",
"When varying numbers of arguments make sense for the same action (e.g., draw(radius) vs draw(width, height))",
"To provide convenience versions of a method with sensible defaults",
"Avoid overloading when the methods do fundamentally different things — use distinct names instead"
]
},
{
"type": "note",
"text": "Note: Multiple methods can have the same name \n as long as the number and/or type of parameters are different.
" } ] }, "scope": { "title": "Java Scope", "blocks": [ { "type": "header", "level": 2, "text": "Java Scope" }, { "type": "paragraph", "text": "In Java, variables are only accessible inside the region where they are created. This is called\nscope." }, { "type": "header", "level": 2, "text": "Method Scope" }, { "type": "paragraph", "text": "Variables declared directly inside a method are available anywhere in the method following the line of code in which they were declared:" }, { "type": "header", "level": 2, "text": "Block Scope" }, { "type": "paragraph", "text": "A block of code refers to all of the code between curly braces{ }."
},
{
"type": "paragraph",
"text": "Variables declared inside a block of code are only accessible by the code between the curly braces, and only after the line in which the variable was declared:"
},
{
"type": "header",
"level": 2,
"text": "Loop Scope"
},
{
"type": "paragraph",
"text": "Variables declared inside a for loop only exist inside the loop:"
},
{
"type": "list",
"ordered": false,
"items": [
"The for loop has its own block ({ ... }).",
"The variable i declared in the loop header (int i = 0) is only accessible inside that loop block.",
"Once the loop ends, i is destroyed, so you can't use it outside."
]
},
{
"type": "header",
"level": 3,
"text": "Why this matters"
},
{
"type": "paragraph",
"text": "Loop variables are not available outside the loop."
},
{
"type": "header",
"level": 2,
"text": "Class Scope (Fields)"
},
{
"type": "paragraph",
"text": "Variables declared at the class level (outside any method) are called fields. They are accessible from any method in the class and persist as long as the object exists."
},
{
"type": "code",
"language": "java",
"code": "class Counter {\n int count = 0; // class-scope field — visible in all methods\n\n void increment() {\n count++; // accesses the field\n }\n\n void reset() {\n count = 0; // also accesses the same field\n }\n\n void show() {\n System.out.println(\"Count: \" + count);\n }\n}\n\nCounter c = new Counter();\nc.increment();\nc.increment();\nc.show(); // Count: 2\nc.reset();\nc.show(); // Count: 0"
},
{
"type": "playground",
"subtype": "scope"
},
{
"type": "header",
"level": 2,
"text": "Scope Summary"
},
{
"type": "table",
"headers": ["Scope Level", "Declared in", "Accessible in", "Lifespan"],
"rows": [
["Class (field)", "Class body, outside methods", "All methods of the class", "As long as the object exists"],
["Method", "Directly inside a method", "Anywhere in that method (after declaration)", "Until method returns"],
["Block", "Inside { } (if, for, while…)", "Only inside that block", "Until block ends"],
["Loop", "For-loop header (int i = 0)", "Only inside the loop body", "Each iteration; destroyed when loop ends"]
]
},
{
"type": "paragraph",
"text": "You can safely reuse the same variable name (i, j, etc.) in different loops in the same method:"
}
]
},
"recursion": {
"title": "Java Recursion",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Java Recursion"
},
{
"type": "paragraph",
"text": "Recursion is the technique of making a function call itself. This technique provides a way\nto break complicated problems down into simpler problems which are easier to solve."
},
{
"type": "paragraph",
"text": "Recursion may be a bit difficult to understand. The\nbest way to figure out how it works is to experiment with it."
},
{
"type": "header",
"level": 2,
"text": "Recursion Example"
},
{
"type": "paragraph",
"text": "Adding two numbers together is easy to do, but adding a range of numbers is more\ncomplicated. In the following example, recursion is used to add a range of numbers\ntogether by breaking it down into the simple task of adding two numbers:"
},
{
"type": "header",
"level": 3,
"text": "Example Explained"
},
{
"type": "paragraph",
"text": "When the sum() method is called, it adds parameter k to the sum of all numbers smaller\nthan k and returns the result. When k becomes 0, the method just returns 0. When\nrunning, the program follows these steps:"
},
{
"type": "note",
"text": "10 + sum(9)k is 0, the program stops there and returns the\nresult."
},
{
"type": "header",
"level": 2,
"text": "Halting Condition"
},
{
"type": "paragraph",
"text": "Just as loops can run into the problem of infinite looping, recursive methods can run into\nthe problem of infinite recursion. Infinite recursion is when the method never stops calling\nitself. Every recursive method should have a halting condition, which is the condition\nwhere the method stops calling itself. In the previous example, the halting condition is\nwhen the parameter k becomes 0."
},
{
"type": "paragraph",
"text": "It is helpful to see a variety of different examples to better understand the concept. In this\nexample, the method adds a range of numbers between a start and an end. The halting\ncondition for this recursive method is when end is not greater than start:"
},
{
"type": "header",
"level": 2,
"text": "Countdown with Recursion"
},
{
"type": "paragraph",
"text": "This example demonstrates how to use recursion to create a countdown function:"
},
{
"type": "paragraph",
"text": "The method calls itself with n - 1 until n becomes 0."
},
{
"type": "header",
"level": 2,
"text": "Fibonacci Sequence with Recursion"
},
{
"type": "paragraph",
"text": "The Fibonacci sequence is a classic recursion example. Each number is the sum of the two before it: 0, 1, 1, 2, 3, 5, 8, 13 …"
},
{
"type": "code",
"language": "java",
"code": "static int fibonacci(int n) {\n if (n <= 1) return n; // base cases: fib(0)=0, fib(1)=1\n return fibonacci(n - 1) + fibonacci(n - 2);\n}\n\n// Print first 8 Fibonacci numbers\nfor (int i = 0; i < 8; i++) {\n System.out.print(fibonacci(i) + \" \");\n}\n// Output: 0 1 1 2 3 5 8 13"
},
{
"type": "header",
"level": 2,
"text": "Golden Rules of Recursion"
},
{
"type": "list",
"ordered": true,
"items": [
"Always have a base case — the condition that stops recursion (e.g., if (n <= 0) return)",
"Move toward the base case — every recursive call must bring you closer to stopping",
"Trust the recursion — assume the recursive call correctly solves the smaller sub-problem",
"Watch for stack overflow — deeply nested calls consume memory; consider iteration for large inputs"
]
},
{
"type": "header",
"level": 2,
"text": "Calculate Factorial with Recursion"
},
{
"type": "playground",
"subtype": "recursion"
},
{
"type": "paragraph",
"text": "This example uses a recursive method to calculate the factorial of 5:"
}
]
},
"oop": {
"title": "Java OOP",
"blocks": [
{
"type": "header",
"level": 2,
"text": "What is Object-Oriented Programming?"
},
{
"type": "intro",
"text": "OOP organises code around objects — bundles that combine data (attributes) and behaviour (methods) in one place, mirroring real-world things."
},
{
"type": "paragraph",
"text": "Think of a Car: it has attributes (brand, colour, speed) and methods (accelerate, brake). In OOP you define a Car class once, then create as many car objects as you need from that blueprint."
},
{
"type": "playground",
"subtype": "class-object"
},
{
"type": "header",
"level": 2,
"text": "Class vs Object"
},
{
"type": "list",
"ordered": false,
"items": [
"Class — the blueprint / template. Defined once. Describes what attributes and methods every object of that type will have.",
"Object — a real instance created from the class using new. Each object has its own copy of the attributes."
]
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "Class → Object",
"rows": [
{
"code": "// Class definition (blueprint)",
"output": ""
},
{
"code": "class Car { String brand; int speed; }",
"output": ""
},
{
"code": "",
"output": ""
},
{
"code": "// Creating objects (instances)",
"output": ""
},
{
"code": "Car car1 = new Car();",
"output": ""
},
{
"code": "car1.brand = \"Toyota\"; car1.speed = 80;",
"output": ""
},
{
"code": "Car car2 = new Car();",
"output": ""
},
{
"code": "car2.brand = \"BMW\"; car2.speed = 120;",
"output": ""
},
{
"code": "System.out.println(car1.brand);",
"output": "Toyota"
},
{
"code": "System.out.println(car2.brand);",
"output": "BMW"
}
]
}
},
{
"type": "header",
"level": 2,
"text": "The 4 Pillars of OOP"
},
{
"type": "table",
"headers": ["Pillar", "What it means", "Java feature"],
"rows": [
["Encapsulation", "Bundle data + methods; hide internal details", "private fields + public getters/setters"],
["Inheritance", "A child class reuses and extends a parent class", "extends keyword"],
["Polymorphism", "Same method name behaves differently per object", "Method overriding (@Override)"],
["Abstraction", "Expose only what the caller needs; hide complexity", "Abstract classes & interfaces"]
]
},
{
"type": "note",
"text": "Real-world analogy: A smartphone is a perfect OOP example — it encapsulates hardware, inherits common phone behaviour, supports polymorphic apps (one tap gesture, many app responses), and abstracts away battery management from the user."
},
{
"type": "header",
"level": 2,
"text": "Why OOP?"
},
{
"type": "code",
"language": "java",
"code": "// Define a class (blueprint)\nclass Car {\n String brand;\n int speed;\n\n void drive() {\n System.out.println(brand + \" driving at \" + speed + \" km/h\");\n }\n}\n\n// Create objects (instances)\nCar car1 = new Car();\ncar1.brand = \"Toyota\"; car1.speed = 80;\ncar1.drive(); // Toyota driving at 80 km/h\n\nCar car2 = new Car();\ncar2.brand = \"BMW\"; car2.speed = 120;\ncar2.drive(); // BMW driving at 120 km/h"
},
{
"type": "list",
"ordered": false,
"items": [
"Reusability — write a class once, create hundreds of objects from it",
"Organisation — related data and behaviour stay together",
"DRY principle — Don't Repeat Yourself: one place to change, all objects updated",
"Modularity — each class can be built, tested, and maintained independently"
]
}
]
},
"classes-objects": {
"title": "Java Classes and Objects",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Java Classes and Objects"
},
{
"type": "intro",
"text": "A class is the blueprint. An object is the real thing built from that blueprint. One class can produce unlimited objects, each with its own data."
},
{
"type": "playground",
"subtype": "class-object"
},
{
"type": "header",
"level": 2,
"text": "Defining a Class"
},
{
"type": "playground",
"subtype": "syntax-anatomy",
"config": {
"title": "Class Definition",
"tokens": [
{
"text": "class",
"type": "keyword",
"tip": "Keyword that defines a class"
},
{
"text": " Car",
"type": "variable",
"tip": "Class name — always start with an uppercase letter"
},
{
"text": " {",
"type": "punctuation",
"tip": "Opening brace — class body starts here"
},
{
"text": "\n String",
"type": "keyword",
"tip": "Attribute type"
},
{
"text": " brand",
"type": "variable",
"tip": "Attribute name — belongs to every Car object"
},
{
"text": ";",
"type": "punctuation"
},
{
"text": "\n int",
"type": "keyword"
},
{
"text": " speed",
"type": "variable"
},
{
"text": ";",
"type": "punctuation"
},
{
"text": "\n}",
"type": "punctuation",
"tip": "Closing brace — class body ends here"
}
]
}
},
{
"type": "header",
"level": 2,
"text": "Creating Objects"
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "Multiple objects from one class",
"rows": [
{
"code": "Car myCar = new Car();",
"output": ""
},
{
"code": "myCar.brand = \"Toyota\";",
"output": ""
},
{
"code": "myCar.speed = 100;",
"output": ""
},
{
"code": "System.out.println(myCar.brand);",
"output": "Toyota"
},
{
"code": "System.out.println(myCar.speed);",
"output": "100"
}
]
}
},
{
"type": "note",
"text": "The class name must match the file name — a class called Car must live in a file called Car.java. Class names always start with an uppercase letter by Java convention."
},
{
"type": "code",
"language": "java",
"code": "class Dog {\n String breed;\n int age;\n\n void bark() {\n System.out.println(breed + \" says: Woof!\");\n }\n}\n\nDog d = new Dog();\nd.breed = \"Labrador\";\nd.age = 3;\nSystem.out.println(d.breed + \", age \" + d.age); // Labrador, age 3\nd.bark(); // Labrador says: Woof!"
}
]
},
"class-attributes": {
"title": "Java Class Attributes",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Java Class Attributes"
},
{
"type": "intro",
"text": "Attributes (also called fields) are variables declared inside a class. Every object created from that class gets its own copy of those attributes."
},
{
"type": "playground",
"subtype": "class-object"
},
{
"type": "header",
"level": 2,
"text": "Declaring and Accessing Attributes"
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "Attributes in action",
"rows": [
{
"code": "class Car {",
"output": ""
},
{
"code": " String brand;",
"output": ""
},
{
"code": " int speed;",
"output": ""
},
{
"code": "}",
"output": ""
},
{
"code": "Car myCar = new Car();",
"output": ""
},
{
"code": "myCar.brand = \"Toyota\";",
"output": ""
},
{
"code": "myCar.speed = 120;",
"output": ""
},
{
"code": "System.out.println(myCar.brand);",
"output": "Toyota"
},
{
"code": "System.out.println(myCar.speed);",
"output": "120"
}
]
}
},
{
"type": "header",
"level": 2,
"text": "Independent Copies Per Object"
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "Two objects — independent data",
"rows": [
{
"code": "Car car1 = new Car(); car1.brand = \"Toyota\";",
"output": ""
},
{
"code": "Car car2 = new Car(); car2.brand = \"BMW\";",
"output": ""
},
{
"code": "System.out.println(car1.brand);",
"output": "Toyota"
},
{
"code": "System.out.println(car2.brand);",
"output": "BMW"
}
]
}
},
{
"type": "header",
"level": 2,
"text": "Final Fields (Constants)"
},
{
"type": "paragraph",
"text": "Use the final keyword to make an attribute a constant — its value is set once and can never be changed after that."
},
{
"type": "code",
"language": "java",
"code": "class Circle {\n final double PI = 3.14159; // constant — cannot be changed\n double radius;\n\n double area() {\n return PI * radius * radius;\n }\n}\n\nCircle c = new Circle();\nc.radius = 5;\nSystem.out.println(c.area()); // 78.53975\n\n// c.PI = 3.0; // ERROR: cannot assign a value to final variable PI"
},
{
"type": "note",
"text": "Use final to make an attribute constant — its value can never be changed after it is set: final double PI = 3.14159;"
}
]
},
"class-methods": {
"title": "Java Class Methods",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Java Class Methods"
},
{
"type": "intro",
"text": "Methods defined inside a class describe the behaviour of its objects. You call them using the dot operator: object.method()."
},
{
"type": "playground",
"subtype": "class-object"
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "Calling methods on an object",
"rows": [
{
"code": "class Car {",
"output": ""
},
{
"code": " String brand = \"Toyota\";",
"output": ""
},
{
"code": " void honk() { System.out.println(brand + \": Beep!\"); }",
"output": ""
},
{
"code": " int doubleSpeed(int s) { return s * 2; }",
"output": ""
},
{
"code": "}",
"output": ""
},
{
"code": "Car myCar = new Car();",
"output": ""
},
{
"code": "myCar.honk();",
"output": "Toyota: Beep!"
},
{
"code": "System.out.println(myCar.doubleSpeed(60));",
"output": "120"
}
]
}
},
{
"type": "note",
"text": "Use the dot operator (.) to access both attributes (obj.brand) and methods (obj.honk()) on an object. Methods with void return type perform an action but return nothing; methods with a type like int give back a value."
},
{
"type": "header",
"level": 2,
"text": "Static vs Instance Methods"
},
{
"type": "paragraph",
"text": "A static method belongs to the class itself — you call it without creating an object. An instance method belongs to an object and can access its attributes."
},
{
"type": "code",
"language": "java",
"code": "class MathHelper {\n // Static — no object needed\n static int square(int n) {\n return n * n;\n }\n}\n\nclass Car {\n String brand;\n // Instance — belongs to a specific Car object\n void describe() {\n System.out.println(\"I am a \" + brand);\n }\n}\n\n// Calling each type\nSystem.out.println(MathHelper.square(4)); // 16 — no object\nCar c = new Car();\nc.brand = \"Toyota\";\nc.describe(); // I am a Toyota"
},
{
"type": "table",
"headers": ["Feature", "Static Method", "Instance Method"],
"rows": [
["Called on", "Class name: MathHelper.square()", "Object: c.describe()"],
["Access attributes?", "No (no this)", "Yes (has this)"],
["Keyword", "static", "(no keyword needed)"],
["Best for", "Utility / helper logic", "Object behaviour"]
]
}
]
},
"constructors": {
"title": "Java Constructors",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Java Constructors"
},
{
"type": "intro",
"text": "A constructor is a special method that runs automatically when an object is created with new. It sets the object's initial state."
},
{
"type": "playground",
"subtype": "constructor"
},
{
"type": "header",
"level": 2,
"text": "Constructor Syntax"
},
{
"type": "playground",
"subtype": "syntax-anatomy",
"config": {
"title": "Constructor Definition",
"tokens": [
{
"text": "Car",
"type": "variable",
"tip": "Constructor name must exactly match the class name"
},
{
"text": "(",
"type": "punctuation"
},
{
"text": "String",
"type": "keyword",
"tip": "Parameter type"
},
{
"text": " brand",
"type": "variable",
"tip": "Parameter — used to initialise the attribute"
},
{
"text": ", ",
"type": "punctuation"
},
{
"text": "int",
"type": "keyword"
},
{
"text": " speed",
"type": "variable"
},
{
"text": ") {",
"type": "punctuation",
"tip": "No return type — not even void"
},
{
"text": "\n this",
"type": "keyword",
"tip": "this refers to the current object being created"
},
{
"text": ".brand = brand;",
"type": "plain"
},
{
"text": "\n this.speed = speed;",
"type": "plain"
},
{
"text": "\n}",
"type": "punctuation"
}
]
}
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "Constructor in action",
"rows": [
{
"code": "class Car {",
"output": ""
},
{
"code": " String brand; int speed;",
"output": ""
},
{
"code": " Car(String brand, int speed) {",
"output": ""
},
{
"code": " this.brand = brand;",
"output": ""
},
{
"code": " this.speed = speed;",
"output": ""
},
{
"code": " }",
"output": ""
},
{
"code": "}",
"output": ""
},
{
"code": "Car c = new Car(\"Toyota\", 120);",
"output": ""
},
{
"code": "System.out.println(c.brand);",
"output": "Toyota"
},
{
"code": "System.out.println(c.speed);",
"output": "120"
}
]
}
},
{
"type": "note",
"text": "The constructor name must match the class name exactly and has no return type. If you don't write one, Java silently provides an empty default constructor. Use this.field = param when the parameter name matches the field name."
},
{
"type": "code",
"language": "java",
"code": "class Person {\n String name;\n int age;\n\n // Constructor\n Person(String name, int age) {\n this.name = name; // 'this' = current object\n this.age = age;\n }\n\n void greet() {\n System.out.println(\"Hi, I'm \" + name + \", age \" + age);\n }\n}\n\nPerson p1 = new Person(\"Alice\", 25);\nPerson p2 = new Person(\"Bob\", 30);\np1.greet(); // Hi, I'm Alice, age 25\np2.greet(); // Hi, I'm Bob, age 30"
}
]
},
"modifiers": {
"title": "Java Modifiers",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Modifiers"
},
{
"type": "paragraph",
"text": "By now, you are quite familiar with the public keyword that appears in almost \nall of our examples:"
},
{
"type": "paragraph",
"text": "The public keyword is an access modifier, \nmeaning that it is used to set the access level for classes, attributes, methods and \nconstructors."
},
{
"type": "paragraph",
"text": "We divide modifiers into two groups:"
},
{
"type": "list",
"ordered": false,
"items": [
"Access Modifiers - controls the access level",
"Non-Access Modifiers - do not control access level, but provides other functionality"
]
},
{
"type": "header",
"level": 2,
"text": "Access Modifiers"
},
{
"type": "paragraph",
"text": "For classes, you can use either public or default:"
},
{
"type": "paragraph",
"text": "For attributes, methods and constructors, you can use the one of the \nfollowing:"
},
{
"type": "header",
"level": 2,
"text": "Public vs. Private Example"
},
{
"type": "paragraph",
"text": "In the example below, the class has one public attribute and one private \nattribute."
},
{
"type": "paragraph",
"text": "Think of it like real life:"
},
{
"type": "list",
"ordered": false,
"items": [
"public - a public park, everyone can enter",
"private - your house key, only you can use it"
]
},
{
"type": "header",
"level": 3,
"text": "Example explained"
},
{
"type": "playground",
"subtype": "modifiers"
},
{
"type": "paragraph",
"text": "Here, name is declared as public, so it can be accessed from outside the Person class. \nBut age is declared as private, so it can only be used inside the Person class."
},
{
"type": "header",
"level": 2,
"text": "Non-Access Modifiers"
},
{
"type": "paragraph",
"text": "Non-access modifiers don't control visibility — they change how a member behaves."
},
{
"type": "table",
"headers": ["Modifier", "Applies to", "Effect"],
"rows": [
["static", "Fields & methods", "Belongs to the class, not to any object. Call it without creating an instance."],
["final", "Fields, methods, classes", "Field: value can't change. Method: can't be overridden. Class: can't be extended."],
["abstract", "Methods & classes", "Method has no body — subclass must implement it. Class can't be instantiated."],
["synchronized", "Methods", "Only one thread can execute this method at a time (thread safety)."],
["transient", "Fields", "Field is skipped when serializing the object to a file/stream."],
["volatile", "Fields", "Value is always read from main memory, not from a thread's local cache."]
]
},
{
"type": "code",
"language": "java",
"code": "class MathConst {\n // static: shared by all instances, accessed via class name\n static final double PI = 3.14159;\n\n // static method: no object needed\n static double circleArea(double r) {\n return PI * r * r;\n }\n}\n\n// abstract: class cannot be instantiated — must be subclassed\nabstract class Shape {\n abstract double area(); // no body — subclass provides it\n}\n\nclass Square extends Shape {\n double side;\n Square(double s) { this.side = s; }\n\n @Override\n double area() { return side * side; } // concrete implementation\n}\n\nSystem.out.println(MathConst.PI); // 3.14159\nSystem.out.println(MathConst.circleArea(5)); // 78.53975\nSystem.out.println(new Square(4).area()); // 16.0"
}
]
},
"encapsulation": {
"title": "Java Encapsulation",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Encapsulation"
},
{
"type": "paragraph",
"text": "The meaning of Encapsulation, is to make sure that \"sensitive\" data is hidden \nfrom users. To achieve this, you must:"
},
{
"type": "list",
"ordered": false,
"items": [
"declare class variables/attributes as private",
"provide public get \nand set methods to access and update the value of a private \nvariable"
]
},
{
"type": "header",
"level": 2,
"text": "Get and Set"
},
{
"type": "paragraph",
"text": "You learned from the previous chapter that private variables can only be \naccessed within the same class (an outside class has no access to it). However, \nit is possible to access them if we provide public get and set methods."
},
{
"type": "paragraph",
"text": "The get method returns the variable value, and the set method sets the value."
},
{
"type": "paragraph",
"text": "Syntax for both is that they start with either get or set, followed by the \nname of the variable, with the first letter in upper case:"
},
{
"type": "header",
"level": 4,
"text": "Example explained"
},
{
"type": "paragraph",
"text": "The get method returns the value of the variable name."
},
{
"type": "paragraph",
"text": "The set method takes a parameter (newName) and assigns it to the\nname variable. The this keyword is used to refer to the current \nobject."
},
{
"type": "paragraph",
"text": "However, as the name variable is declared as private, we \ncannot access it from outside this class:"
},
{
"type": "paragraph",
"text": "If the variable was declared as public, we would expect the following output:"
},
{
"type": "paragraph",
"text": "However, as we try to access a private variable, we get an error:"
},
{
"type": "paragraph",
"text": "Instead, we use the getName() and setName() methods to access and update the variable:"
},
{
"type": "header",
"level": 2,
"text": "Why Encapsulation?"
},
{
"type": "playground",
"subtype": "encapsulation"
},
{
"type": "list",
"ordered": false,
"items": [
"Better control of class attributes and methods",
"Class attributes can be made read-only (if you only use the get method), or write-only (if you only use the set method)",
"Flexible: the programmer can change one part of the code without affecting other parts",
"Increased security of data"
]
},
{
"type": "code",
"language": "java",
"code": "class BankAccount {\n private double balance; // hidden — direct access blocked\n\n BankAccount(double initial) { this.balance = initial; }\n\n public double getBalance() { return balance; }\n public void deposit(double amount) { if (amount > 0) balance += amount; }\n public void withdraw(double amount) { if (amount <= balance) balance -= amount; }\n}\n\nBankAccount acc = new BankAccount(1000);\nacc.deposit(500);\nacc.withdraw(200);\nSystem.out.println(acc.getBalance()); // 1300.0\n// acc.balance = -9999; // ERROR: balance is private"
}
]
},
"packages": {
"title": "Java Packages",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Java Packages & API"
},
{
"type": "paragraph",
"text": "A package in Java is used to group related classes. Think of it as\na folder in a file directory. We use packages to avoid name conflicts, and \nto write a better maintainable code. Packages are divided into two categories:"
},
{
"type": "list",
"ordered": false,
"items": [
"Built-in Packages (packages from the Java API)",
"User-defined Packages (create your own packages)"
]
},
{
"type": "header",
"level": 2,
"text": "Built-in Packages"
},
{
"type": "paragraph",
"text": "The Java API is a library of prewritten classes, that are free to use, included in the\nJava Development Environment."
},
{
"type": "paragraph",
"text": "The library contains components for managing input, database programming, and much much \nmore. The complete list can be found at Oracles website: https://docs.oracle.com/javase/8/docs/api/."
},
{
"type": "paragraph",
"text": "The library is divided into packages and classes. \nMeaning you can either import a single class (along with its methods and \nattributes), or a whole package that contain \nall the classes that belong to the specified package."
},
{
"type": "paragraph",
"text": "To use a class or a package from the library, you need to use the import \nkeyword:"
},
{
"type": "header",
"level": 2,
"text": "Import a Class"
},
{
"type": "paragraph",
"text": "If you find a class you want to use, for example, the Scanner class, which is used to get \nuser input, write the following code:"
},
{
"type": "paragraph",
"text": "In the example above, java.util is a package, while Scanner is a class of \nthe java.util package."
},
{
"type": "paragraph",
"text": "To use the Scanner class, create an object of the class and use any of the available methods found in the Scanner class documentation. \nIn our example, we will use the nextLine() method, which is used to read a \ncomplete line:"
},
{
"type": "header",
"level": 2,
"text": "Import a Package"
},
{
"type": "paragraph",
"text": "There are many packages to choose from. In the previous example, we used the Scanner class from the java.util package. This package also contains date and time \nfacilities, random-number generator and other utility classes."
},
{
"type": "paragraph",
"text": "To import a whole package, end the sentence with an asterisk sign (*). \nThe following example \nwill import ALL the classes in the java.util package:"
},
{
"type": "header",
"level": 2,
"text": "Common Built-in Java Packages"
},
{
"type": "table",
"headers": ["Package", "What it provides", "Example classes"],
"rows": [
["java.lang", "Core Java classes — imported automatically", "String, Math, System, Integer"],
["java.util", "Data structures, date/time, random numbers", "ArrayList, HashMap, Scanner, Date"],
["java.io", "Reading and writing files / streams", "File, FileWriter, BufferedReader"],
["java.nio.file", "Modern file & path API (Java 7+)", "Files, Path, Paths"],
["java.net", "Networking — URLs, sockets, HTTP", "URL, HttpURLConnection"],
["java.sql", "Database connectivity (JDBC)", "Connection, Statement, ResultSet"]
]
},
{
"type": "header",
"level": 2,
"text": "User-defined Packages"
},
{
"type": "paragraph",
"text": "To create your own package, you need to understand that Java uses a file system directory to store them. Just like folders on your computer:"
},
{
"type": "paragraph",
"text": "To create a package, use the package keyword:"
},
{
"type": "paragraph",
"text": "Save the file as MyPackageClass.java, and compile it:"
},
{
"type": "example",
"title": "Example",
"code": "C:\\Users\\Your Name>javac MyPackageClass.java"
},
{
"type": "paragraph",
"text": "Then compile the package:"
},
{
"type": "example",
"title": "Example",
"code": "C:\\Users\\Your Name>javac -d . MyPackageClass.java"
},
{
"type": "note",
"text": "This forces the compiler to create the \"mypack\" package.
\nThe -d keyword specifies the destination for where to save the class file. You \n can use any directory name, like c:/user (windows), or, if you want to keep \n the package within the same directory, you can use the dot sign \".\", like in \n the example above.
Note: The package name should be written in lower case to avoid conflict with class names.
" }, { "type": "paragraph", "text": "When we compiled the package in the example above, a new folder was created, called \"mypack\"." }, { "type": "paragraph", "text": "To run the MyPackageClass.java file, write the following:" }, { "type": "example", "title": "Example", "code": "C:\\Users\\Your Name>java mypack.MyPackageClass" }, { "type": "paragraph", "text": "The output will be:" }, { "type": "header", "level": 2, "text": "Creating Your Own Package — Quick Reference" }, { "type": "code", "language": "java", "code": "// Step 1 — Declare the package at the TOP of the file\npackage com.myapp.utils;\n\n// Step 2 — Define your class\npublic class StringHelper {\n public static String shout(String s) {\n return s.toUpperCase() + \"!\";\n }\n}\n\n// Step 3 — Use it from another file\nimport com.myapp.utils.StringHelper;\n\npublic class Main {\n public static void main(String[] args) {\n System.out.println(StringHelper.shout(\"hello\"));\n // Output: HELLO!\n }\n}" }, { "type": "note", "text": "Naming convention: Package names are always lowercase and use the reverse domain pattern:com.companyname.projectname.module. This guarantees globally unique package names across all Java projects."
}
]
},
"inheritance": {
"title": "Java Inheritance",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Java Inheritance"
},
{
"type": "intro",
"text": "Inheritance lets a child class automatically gain all the attributes and methods of a parent class. Write common code once in the parent — all children get it for free."
},
{
"type": "playground",
"subtype": "inheritance"
},
{
"type": "header",
"level": 2,
"text": "The extends Keyword"
},
{
"type": "playground",
"subtype": "syntax-anatomy",
"config": {
"title": "Inheritance with extends",
"tokens": [
{
"text": "class",
"type": "keyword"
},
{
"text": " Dog",
"type": "variable",
"tip": "Child (subclass) — gets everything from Animal"
},
{
"text": " extends",
"type": "keyword",
"tip": "Keyword that sets up inheritance"
},
{
"text": " Animal",
"type": "variable",
"tip": "Parent (superclass) — the class being inherited from"
},
{
"text": " {",
"type": "punctuation"
},
{
"text": "\n // own fields and methods only",
"type": "plain"
},
{
"text": "\n}",
"type": "punctuation"
}
]
}
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "Child inherits parent methods",
"rows": [
{
"code": "class Animal {",
"output": ""
},
{
"code": " String name = \"Buddy\";",
"output": ""
},
{
"code": " void eat() { System.out.println(name + \" is eating.\"); }",
"output": ""
},
{
"code": "}",
"output": ""
},
{
"code": "class Dog extends Animal {",
"output": ""
},
{
"code": " void sound() { System.out.println(name + \" says: Woof!\"); }",
"output": ""
},
{
"code": "}",
"output": ""
},
{
"code": "Dog d = new Dog();",
"output": ""
},
{
"code": "d.eat();",
"output": "Buddy is eating."
},
{
"code": "d.sound();",
"output": "Buddy says: Woof!"
}
]
}
},
{
"type": "list",
"ordered": false,
"items": [
"Subclass / child — the class that inherits. Uses extends.",
"Superclass / parent — the class being inherited from.",
"Use protected on parent attributes so child classes can access them.",
"Use final class to prevent any class from extending it."
]
},
{
"type": "code",
"language": "java",
"code": "class Animal {\n String name;\n void eat() { System.out.println(name + \" eats.\"); }\n}\n\nclass Dog extends Animal {\n @Override\n void eat() { System.out.println(name + \" eats dog food.\"); }\n void bark() { System.out.println(name + \" says: Woof!\"); }\n}\n\nDog d = new Dog();\nd.name = \"Rex\";\nd.eat(); // Rex eats dog food.\nd.bark(); // Rex says: Woof!\n\n// Parent reference holds child object\nAnimal a = new Dog();\na.name = \"Buddy\";\na.eat(); // Buddy eats dog food. (runtime type = Dog)"
}
]
},
"polymorphism": {
"title": "Java Polymorphism",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Java Polymorphism"
},
{
"type": "intro",
"text": "Polymorphism means \"many forms\". The same method name behaves differently depending on which object calls it — each subclass provides its own implementation."
},
{
"type": "playground",
"subtype": "inheritance"
},
{
"type": "playground",
"subtype": "output",
"config": {
"title": "Same method — different behaviour",
"rows": [
{
"code": "class Animal { void sound() { System.out.println(\"...\"); } }",
"output": ""
},
{
"code": "class Dog extends Animal {",
"output": ""
},
{
"code": " @Override void sound() { System.out.println(\"Woof!\"); }",
"output": ""
},
{
"code": "}",
"output": ""
},
{
"code": "class Cat extends Animal {",
"output": ""
},
{
"code": " @Override void sound() { System.out.println(\"Meow!\"); }",
"output": ""
},
{
"code": "}",
"output": ""
},
{
"code": "new Dog().sound();",
"output": "Woof!"
},
{
"code": "new Cat().sound();",
"output": "Meow!"
}
]
}
},
{
"type": "note",
"text": "Use @Override when a child class replaces a parent method. It tells Java (and readers) that this method intentionally replaces the parent version — and the compiler will catch typos in the method signature."
},
{
"type": "header",
"level": 2,
"text": "Polymorphism in Action — List of Animals"
},
{
"type": "paragraph",
"text": "The real power of polymorphism is using a parent-type reference to hold any subclass object. You can loop over a list and call the same method — Java automatically calls the right version for each object."
},
{
"type": "code",
"language": "java",
"code": "import java.util.ArrayList;\n\nArrayList<Animal> animals = new ArrayList<>();\nanimals.add(new Dog());\nanimals.add(new Cat());\nanimals.add(new Dog());\n\nfor (Animal a : animals) {\n a.sound(); // Java calls Dog.sound() or Cat.sound() automatically\n}\n// Output:\n// Woof!\n// Meow!\n// Woof!"
},
{
"type": "header",
"level": 2,
"text": "Types of Polymorphism"
},
{
"type": "table",
"headers": ["Type", "When resolved", "Mechanism", "Example"],
"rows": [
["Compile-time (static)", "At compile time", "Method overloading", "area(r) vs area(w, h)"],
["Runtime (dynamic)", "At run time", "Method overriding (@Override)", "a.sound() dispatches to Dog or Cat"]
]
},
{
"type": "header",
"level": 2,
"text": "Why Polymorphism Matters"
},
{
"type": "list",
"ordered": false,
"items": [
"Extensibility — add a new Bird subclass and existing loop code still works without changes",
"Cleaner code — one variable type (Animal) handles all subtypes",
"Loose coupling — callers don't need to know the exact subclass",
"Open/Closed Principle — code is open for extension but closed for modification"
]
}
]
},
"inner-classes": {
"title": "Java Inner Classes",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Java Inner Classes"
},
{
"type": "paragraph",
"text": "In Java, it is also possible to nest classes (a class within a class). The purpose \nof nested classes is to group classes that belong together, which makes your code more readable and maintainable."
},
{
"type": "paragraph",
"text": "To access the inner class, create an object of the outer class, and then create an object of the inner class:"
},
{
"type": "header",
"level": 2,
"text": "Private Inner Class"
},
{
"type": "paragraph",
"text": "Unlike a \"regular\" class, an inner class can be private or protected. \nIf you don't want outside objects to access the inner class, declare \nthe class as private:"
},
{
"type": "header",
"level": 2,
"text": "Static Inner Class"
},
{
"type": "paragraph",
"text": "An inner class can also be static, which means that you can access it without \ncreating an object of the outer class:"
},
{
"type": "note",
"text": "Note: just like static attributes and methods, a static inner class does not have access to members of the outer class.
abstract keyword is a non-access modifier, used for classes and methods:"
},
{
"type": "list",
"ordered": false,
"items": [
"Abstract class: is a restricted class that cannot be used to create objects (to access it, it must be inherited from another class).",
"Abstract method: can only be used in an abstract class, and it does not have a body. The body is provided by the subclass (inherited from)."
]
},
{
"type": "paragraph",
"text": "An abstract class can have both abstract and regular methods:"
},
{
"type": "paragraph",
"text": "From the example above, it is not possible to create an object of the Animal class:"
},
{
"type": "paragraph",
"text": "To access the abstract class, it must be inherited from another class. Let's convert the Animal class we used in the Polymorphism chapter to an abstract class:"
},
{
"type": "note",
"text": "Remember from the Inheritance chapter that we use the extends keyword to inherit from a class.
To achieve security - hide certain details and only show the important \ndetails of an object.
\nNote: Abstraction can also be achieved with Interfaces, which you will learn more about in the next chapter.
" }, { "type": "code", "language": "java", "code": "abstract class Shape {\n String color;\n abstract double area(); // no body \u2014 subclasses must provide it\n\n void describe() {\n System.out.println(color + \" shape, area = \" + area());\n }\n}\n\nclass Circle extends Shape {\n double r;\n Circle(String c, double r) { this.color = c; this.r = r; }\n double area() { return 3.14159 * r * r; }\n}\n\nclass Rectangle extends Shape {\n double w, h;\n Rectangle(String c, double w, double h) { this.color = c; this.w = w; this.h = h; }\n double area() { return w * h; }\n}\n\nnew Circle(\"red\", 5).describe(); // red shape, area = 78.53975\nnew Rectangle(\"blue\", 4, 6).describe(); // blue shape, area = 24.0" } ] }, "interface": { "title": "Java Interface", "blocks": [ { "type": "header", "level": 2, "text": "Interfaces" }, { "type": "paragraph", "text": "Another way to achieve abstraction in Java, is with interfaces." }, { "type": "paragraph", "text": "Aninterface is a completely \"abstract class\" \nthat is used to group related methods with empty bodies:"
},
{
"type": "paragraph",
"text": "To access the interface methods, the interface must be \"implemented\" \n(kinda like inherited) by another class with the implements \nkeyword (instead of extends). The body of the \ninterface method is provided by the \"implement\" class:"
},
{
"type": "note",
"text": "abstract and \n publicpublic, \n static and final1) To achieve security - hide certain details and only show the important \ndetails of an object (interface).
\n2) Java does not support \"multiple inheritance\" (a class can only inherit from one superclass). However, it can be achieved \n with interfaces, because the class can implement multiple interfaces.\n Note: To implement multiple interfaces, separate them with a comma (see example below).
" }, { "type": "header", "level": 2, "text": "Multiple Interfaces" }, { "type": "playground", "subtype": "interface" }, { "type": "paragraph", "text": "To implement multiple interfaces, separate them with a comma:" }, { "type": "code", "language": "java", "code": "interface Drawable {\n void draw(); // abstract by default\n default String type() { return \"2D\"; } // default method\n}\n\ninterface Resizable {\n void resize(int factor);\n}\n\nclass Square implements Drawable, Resizable {\n int side;\n Square(int s) { this.side = s; }\n public void draw() { System.out.println(\"Square \" + side + \"x\" + side); }\n public void resize(int f) { side *= f; }\n}\n\nSquare sq = new Square(4);\nsq.draw(); // Square 4x4\nsq.resize(3);\nsq.draw(); // Square 12x12\nSystem.out.println(sq.type()); // 2D" } ] }, "enums": { "title": "Java Enums", "blocks": [ { "type": "header", "level": 2, "text": "Enums" }, { "type": "paragraph", "text": "Anenum is a special \"class\" that represents a group of \nconstants (unchangeable variables, like final variables)."
},
{
"type": "paragraph",
"text": "To create an enum, use the enum keyword (instead of class or interface), and separate \nthe constants with a comma. Note that they should be in uppercase letters:"
},
{
"type": "example",
"title": "Example",
"code": "Level myVar = Level.MEDIUM;"
},
{
"type": "note",
"text": "Enum is short for \"enumerations\", which means \"specifically listed\".
" }, { "type": "header", "level": 2, "text": "Enum inside a Class" }, { "type": "paragraph", "text": "You can also have anenum inside a class:"
},
{
"type": "header",
"level": 2,
"text": "Enum in a Switch Statement"
},
{
"type": "paragraph",
"text": "Enums are often used in switch statements to check for corresponding values:"
},
{
"type": "header",
"level": 2,
"text": "Loop Through an Enum"
},
{
"type": "paragraph",
"text": "The enum type has a values() method, which returns an array of all enum constants. This method is useful when you want to loop through the constants of an enum:"
},
{
"type": "playground",
"subtype": "enum"
},
{
"type": "code",
"language": "java",
"code": "enum Day { MON, TUE, WED, THU, FRI, SAT, SUN }\n\nDay today = Day.WED;\nSystem.out.println(today); // WED\nSystem.out.println(today.name()); // WED\nSystem.out.println(today.ordinal()); // 2 (0-based index)\n\n// Enum in switch\nswitch (today) {\n case SAT: case SUN:\n System.out.println(\"Weekend!\"); break;\n default:\n System.out.println(\"Weekday\");\n}\n// Output: Weekday\n\n// Loop through all enum values\nfor (Day d : Day.values()) {\n System.out.print(d + \" \");\n}\n// MON TUE WED THU FRI SAT SUN"
},
{
"type": "note",
"text": "An enum can, just like a class, have attributes and methods. The only \ndifference is that enum constants are public, static and final \n(unchangeable - cannot be overridden).
An enum cannot be used to create objects, and it cannot extend other classes (but it can implement interfaces).
Use enums when you have values that you know aren't going to change, like month days, days, colors, deck of cards, etc.
" } ] }, "user-input": { "title": "Java User Input (Scanner)", "blocks": [ { "type": "header", "level": 2, "text": "Java User Input" }, { "type": "paragraph", "text": "TheScanner class is used to get \nuser input, and it is found in the java.util package."
},
{
"type": "paragraph",
"text": "To use the Scanner class, create an object of the class and use any of the available methods found in the Scanner class documentation. \nIn our example, we will use the nextLine() method, which is used to read Strings:"
},
{
"type": "note",
"text": "If you don't know what a package is, read our Java Packages Tutorial.
" }, { "type": "header", "level": 2, "text": "Input Types" }, { "type": "paragraph", "text": "In the example above, we used thenextLine() method, which is used to read Strings. To read other types, look at the table below:"
},
{
"type": "paragraph",
"text": "In the example below, we use different methods to read data of various types:"
},
{
"type": "playground",
"subtype": "user-input"
},
{
"type": "code",
"language": "java",
"code": "import java.util.Scanner;\n\nScanner sc = new Scanner(System.in);\n\nSystem.out.print(\"Enter your name: \");\nString name = sc.nextLine(); // reads a String\n\nSystem.out.print(\"Enter your age: \");\nint age = sc.nextInt(); // reads an int\n\nSystem.out.print(\"Enter your GPA: \");\ndouble gpa = sc.nextDouble(); // reads a double\n\nSystem.out.println(\"Hi \" + name + \"! Age: \" + age + \", GPA: \" + gpa);\nsc.close();\n// Sample output: Hi Alice! Age: 20, GPA: 3.8"
},
{
"type": "note",
"text": "Note: If you enter wrong input (e.g. text in a numerical input), you will get an exception/error message (like \"InputMismatchException\").
\nYou can read more about exceptions and how to handle errors in the Exceptions chapter.
" } ] }, "date": { "title": "Java Date and Time", "blocks": [ { "type": "header", "level": 2, "text": "Java Dates" }, { "type": "paragraph", "text": "Java does not have a built-in Date class, but we can import thejava.time \npackage to work with the date and time API. The package includes many date and time classes. \nFor example:"
},
{
"type": "note",
"text": "If you don't know what a package is, read our Java Packages Tutorial.
" }, { "type": "header", "level": 2, "text": "Display Current Date" }, { "type": "paragraph", "text": "To display the current date, import thejava.time.LocalDate class, and use its now() method:"
},
{
"type": "header",
"level": 2,
"text": "Display Current Time"
},
{
"type": "paragraph",
"text": "To display the current time (hour, minute, second, and nanoseconds), import the java.time.LocalTime class, and use its now() method:"
},
{
"type": "header",
"level": 2,
"text": "Display Current Date and Time"
},
{
"type": "paragraph",
"text": "To display the current date and time, import the java.time.LocalDateTime class, and use its now() method:"
},
{
"type": "header",
"level": 2,
"text": "Formatting Date and Time"
},
{
"type": "paragraph",
"text": "The \"T\" in the example above is used to separate the date from the time. You can use the DateTimeFormatter class \nwith the ofPattern() method in the same package to format or parse date-time objects. \nThe following example will remove both the \"T\" and nanoseconds from the date-time:"
},
{
"type": "playground",
"subtype": "date"
},
{
"type": "paragraph",
"text": "The ofPattern() method accepts all sorts of values, if you want to display \nthe date and time in a different format. For example:"
},
{
"type": "header",
"level": 2,
"text": "Common Date Format Patterns"
},
{
"type": "table",
"headers": ["Pattern", "Meaning", "Example output"],
"rows": [
["yyyy", "4-digit year", "2025"],
["MM", "2-digit month (01–12)", "04"],
["dd", "2-digit day (01–31)", "14"],
["HH", "Hour in 24-hour format (00–23)", "15"],
["mm", "Minutes (00–59)", "30"],
["ss", "Seconds (00–59)", "05"],
["EEEE", "Full day name", "Monday"],
["MMMM", "Full month name", "April"]
]
},
{
"type": "code",
"language": "java",
"code": "import java.time.LocalDateTime;\nimport java.time.format.DateTimeFormatter;\n\nLocalDateTime now = LocalDateTime.now();\n\n// Different format patterns\nDateTimeFormatter f1 = DateTimeFormatter.ofPattern(\"dd/MM/yyyy\");\nDateTimeFormatter f2 = DateTimeFormatter.ofPattern(\"EEEE, MMMM dd yyyy\");\nDateTimeFormatter f3 = DateTimeFormatter.ofPattern(\"hh:mm a\"); // 12-hour with AM/PM\nDateTimeFormatter f4 = DateTimeFormatter.ofPattern(\"dd-MM-yyyy HH:mm:ss\");\n\nSystem.out.println(now.format(f1)); // 14/04/2025\nSystem.out.println(now.format(f2)); // Monday, April 14 2025\nSystem.out.println(now.format(f3)); // 03:30 PM\nSystem.out.println(now.format(f4)); // 14-04-2025 15:30:05"
},
{
"type": "note",
"text": "Prefer java.time over java.util.Date: The java.time package (introduced in Java 8) is immutable, thread-safe, and much easier to use than the older Date and Calendar classes."
}
]
},
"arraylist": {
"title": "Java ArrayList",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Java ArrayList"
},
{
"type": "paragraph",
"text": "An ArrayList is like a resizable array."
},
{
"type": "paragraph",
"text": "It is part of the java.util package and implements the List interface."
},
{
"type": "paragraph",
"text": "The difference between a built-in array and an ArrayList in Java, is that the size of an array cannot be modified (if you want to \nadd or remove elements to/from an array, you have to create a new one). While elements can be added and removed from an ArrayList whenever you want."
},
{
"type": "header",
"level": 2,
"text": "Create an ArrayList"
},
{
"type": "paragraph",
"text": "To use an ArrayList, you must first import it from java.util:"
},
{
"type": "paragraph",
"text": "Now you can use methods like add(), get(), set(), and remove() to manage your list of elements."
},
{
"type": "header",
"level": 2,
"text": "Add Elements"
},
{
"type": "paragraph",
"text": "To add elements to an \nArrayList, use the add() method:"
},
{
"type": "paragraph",
"text": "You can also add an element at a specified position by referring to the index \nnumber:"
},
{
"type": "note",
"text": "An ArrayList keeps elements in the same order you add them, so the first item you add will be at index 0, the next at index 1, and so on.
ArrayList, use the get() method and refer to the index number:"
},
{
"type": "header",
"level": 2,
"text": "Change an Element"
},
{
"type": "paragraph",
"text": "To modify an element, use the set() method \nand refer to the index number:"
},
{
"type": "header",
"level": 2,
"text": "Remove an Element"
},
{
"type": "paragraph",
"text": "To remove an element, use the remove() method \nand refer to the index number:"
},
{
"type": "paragraph",
"text": "To remove all the elements in the ArrayList, use the clear() method:"
},
{
"type": "header",
"level": 2,
"text": "ArrayList Size"
},
{
"type": "paragraph",
"text": "To find out how many elements an ArrayList have, use the size method:"
},
{
"type": "header",
"level": 2,
"text": "Loop Through an ArrayList"
},
{
"type": "paragraph",
"text": "Loop through the elements of an ArrayList with a for loop, and use the \nsize() method to specify how many times the loop should run:"
},
{
"type": "paragraph",
"text": "You can also loop through an ArrayList with the for-each loop:"
},
{
"type": "header",
"level": 2,
"text": "Other Types"
},
{
"type": "paragraph",
"text": "Elements in an ArrayList are actually objects. In the examples above, we created elements \n(objects) of type \"String\". Remember that a String in Java is an object (not a primitive type). To use other types, such as int, you must specify an equivalent wrapper class: Integer. For other primitive types, \nuse: Boolean for boolean, Character for char, Double for double, \netc:"
},
{
"type": "header",
"level": 2,
"text": "Sort an ArrayList"
},
{
"type": "paragraph",
"text": "Another useful class in the java.util package is the Collections class, which include the sort() method for sorting lists \nalphabetically or numerically:"
},
{
"type": "header",
"level": 2,
"text": "The var Keyword"
},
{
"type": "paragraph",
"text": "From Java 10, you can use the var keyword to declare an ArrayList variable without writing the type twice. \nThe compiler figures out the type from the value you assign."
},
{
"type": "paragraph",
"text": "This makes code shorter, but many developers still use the full type for clarity. \nSince var is valid Java, you may see it in other code, so it's good to know that it exists:"
},
{
"type": "header",
"level": 2,
"text": "The List Interface"
},
{
"type": "paragraph",
"text": "Note: Sometimes you will see both List and ArrayList in Java code, like this:"
},
{
"type": "paragraph",
"text": "This means the variable (cars) is declared as a List (the interface), but it stores an ArrayList object (the actual list). Since ArrayList implements the List interface, this is possible."
},
{
"type": "playground",
"subtype": "arraylist"
},
{
"type": "header",
"level": 2,
"text": "ArrayList Quick-Reference Methods"
},
{
"type": "table",
"headers": ["Method", "Description", "Example"],
"rows": [
["add(e)", "Append element to end", "list.add(\"Java\")"],
["add(i, e)", "Insert at index", "list.add(0, \"First\")"],
["get(i)", "Retrieve element at index", "list.get(2)"],
["set(i, e)", "Replace element at index", "list.set(1, \"New\")"],
["remove(i)", "Remove element at index", "list.remove(0)"],
["remove(obj)", "Remove first occurrence of object", "list.remove(\"Java\")"],
["size()", "Number of elements", "list.size()"],
["contains(e)", "Check if element exists", "list.contains(\"Python\")"],
["indexOf(e)", "Index of first occurrence (−1 if absent)", "list.indexOf(\"Java\")"],
["clear()", "Remove all elements", "list.clear()"],
["isEmpty()", "True if no elements", "list.isEmpty()"]
]
},
{
"type": "header",
"level": 2,
"text": "Sorting and Filtering with Streams"
},
{
"type": "code",
"language": "java",
"code": "import java.util.ArrayList;\nimport java.util.Collections;\nimport java.util.stream.Collectors;\n\nArrayList<String> names = new ArrayList<>();\nnames.add(\"Charlie\"); names.add(\"Alice\"); names.add(\"Bob\"); names.add(\"Anna\");\n\n// Sort alphabetically\nCollections.sort(names);\nSystem.out.println(names); // [Alice, Anna, Bob, Charlie]\n\n// Sort in reverse\nCollections.sort(names, Collections.reverseOrder());\nSystem.out.println(names); // [Charlie, Bob, Anna, Alice]\n\n// Stream: filter names starting with 'A'\nvar filtered = names.stream()\n .filter(n -> n.startsWith(\"A\"))\n .collect(Collectors.toList());\nSystem.out.println(filtered); // [Anna, Alice]\n\n// Stream: uppercase all\nnames.stream()\n .map(String::toUpperCase)\n .forEach(System.out::println);"
},
{
"type": "paragraph",
"text": "It works the same way, but some developers prefer this style because it gives them more flexibility to change the type later."
}
]
},
"linkedlist": {
"title": "Java LinkedList",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Java LinkedList"
},
{
"type": "paragraph",
"text": "In the previous chapter, you learned about the ArrayList class. The LinkedList class is \nalmost identical to the \nArrayList:"
},
{
"type": "header",
"level": 2,
"text": "ArrayList vs. LinkedList"
},
{
"type": "paragraph",
"text": "The LinkedList class is a collection which can contain many objects of the same type,\njust like the ArrayList."
},
{
"type": "paragraph",
"text": "The LinkedList class has the same methods as ArrayList because both follow the List interface.\nThis means you can add, change, remove, or clear elements in a LinkedList just like you would with an ArrayList."
},
{
"type": "paragraph",
"text": "However, while the ArrayList class and the LinkedList class can be used in the same way,\nthey are built very differently."
},
{
"type": "header",
"level": 3,
"text": "How the ArrayList works"
},
{
"type": "paragraph",
"text": "The ArrayList class has a regular array inside it. When an element is added, it is placed\ninto the array. If the array is not big enough, a new, larger array is created to replace the\nold one and the old one is removed."
},
{
"type": "header",
"level": 3,
"text": "How the LinkedList works"
},
{
"type": "paragraph",
"text": "The LinkedList stores its elements in \"containers.\" The list has a link to the first container\nand each container has a link to the next container in the list. To add an element to the list,\nthe element is placed into a new container and that container is linked to one of the other\ncontainers in the list."
},
{
"type": "note",
"text": "Use an ArrayList for storing and accessing data, and LinkedList to \nmanipulate data.
ArrayList is more efficient as it is common to need access to\nrandom elements in the list, but the LinkedList provides several methods to do certain\noperations more efficiently:"
},
{
"type": "header",
"level": 2,
"text": "The var Keyword"
},
{
"type": "paragraph",
"text": "From Java 10, you can use the var keyword to declare a LinkedList variable without writing the type twice. \nThe compiler figures out the type from the value you assign."
},
{
"type": "paragraph",
"text": "This makes code shorter, but many developers still use the full type for clarity. \nSince var is valid Java, you may see it in other code, so it's good to know that it exists:"
},
{
"type": "header",
"level": 2,
"text": "The List Interface"
},
{
"type": "paragraph",
"text": "Note: Sometimes you will see both List and LinkedList in Java code, like this:"
},
{
"type": "paragraph",
"text": "This means the variable (cars) is declared as a List (the interface), but it stores a LinkedList object (the actual list). Since LinkedList implements the List interface, this is possible."
},
{
"type": "playground",
"subtype": "linkedlist"
},
{
"type": "code",
"language": "java",
"code": "LinkedList<String> cars = new LinkedList<>();\ncars.add(\"Volvo\");\ncars.add(\"BMW\");\ncars.add(\"Ford\");\n\n// LinkedList-specific methods\ncars.addFirst(\"Mazda\"); // insert at start\ncars.addLast(\"Toyota\"); // insert at end\ncars.removeFirst(); // remove first element\ncars.removeLast(); // remove last element\n\nSystem.out.println(cars.getFirst()); // Volvo\nSystem.out.println(cars.getLast()); // Ford\nSystem.out.println(cars); // [Volvo, BMW, Ford]"
},
{
"type": "paragraph",
"text": "It works the same way, but some developers prefer this style because it gives them more flexibility to change the type later."
}
]
},
"hashmap": {
"title": "Java HashMap",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Java HashMap"
},
{
"type": "paragraph",
"text": "A HashMap stores items in key/value pairs, where each key maps to a specific value."
},
{
"type": "paragraph",
"text": "It is part of the java.util package and implements the \n Map interface."
},
{
"type": "paragraph",
"text": "Instead of accessing elements by an index (like with ArrayList), you use a key to retrieve its associated value."
},
{
"type": "paragraph",
"text": "A HashMap can store many different combinations, such as:"
},
{
"type": "list",
"ordered": false,
"items": [
"String keys and Integer values",
"String keys and String values"
]
},
{
"type": "header",
"level": 2,
"text": "Create a HashMap"
},
{
"type": "paragraph",
"text": "Create a HashMap object called capitalCities that will store \n String keys and String values:"
},
{
"type": "paragraph",
"text": "Now you can use methods like put() to add key/value pairs, \n get() to retrieve a value by key, \n and remove() to delete an entry - all by using keys instead of index numbers."
},
{
"type": "header",
"level": 2,
"text": "Add Items"
},
{
"type": "paragraph",
"text": "To add items to a HashMap, use the put() method:"
},
{
"type": "paragraph",
"text": "Note: In the example above, if the same key (like \"Norway\") is added more than once, the latest value will overwrite the previous one, because keys in a HashMap must be unique."
},
{
"type": "header",
"level": 2,
"text": "Access an Item"
},
{
"type": "paragraph",
"text": "To access a value in the HashMap, use the get() method and refer to \nits key:"
},
{
"type": "header",
"level": 2,
"text": "Remove an Item"
},
{
"type": "paragraph",
"text": "To remove an item, use the remove() method \nand refer to the key:"
},
{
"type": "paragraph",
"text": "To remove all items, use the clear() method:"
},
{
"type": "header",
"level": 2,
"text": "HashMap Size"
},
{
"type": "paragraph",
"text": "To find out how many items there are, use the size() method:"
},
{
"type": "paragraph",
"text": "Note: The size only counts unique keys. If a key is added more than once, only the latest value is kept."
},
{
"type": "header",
"level": 2,
"text": "Loop Through a HashMap"
},
{
"type": "paragraph",
"text": "Loop through the items of a HashMap with a for-each loop."
},
{
"type": "paragraph",
"text": "Note: Use the keySet() method if you only want the keys, and use the values() method if you only want the values:"
},
{
"type": "header",
"level": 2,
"text": "Other Types"
},
{
"type": "paragraph",
"text": "Keys and values in a HashMap are actually objects. In the examples above, we used objects of type \"String\". Remember that a String in Java is an object (not a primitive type). To use other types, such as int, you must specify an equivalent wrapper class: Integer. For other primitive types, \nuse: Boolean for boolean, Character for char, Double for double, \netc:"
},
{
"type": "header",
"level": 2,
"text": "When Order Matters"
},
{
"type": "paragraph",
"text": "In the next chapter, you will learn about TreeMap, which stores key/value pairs in sorted order by key."
},
{
"type": "header",
"level": 2,
"text": "The var Keyword"
},
{
"type": "paragraph",
"text": "From Java 10, you can use the var keyword to declare a HashMap variable without writing the type twice. \nThe compiler figures out the type from the value you assign."
},
{
"type": "paragraph",
"text": "This makes code shorter, but many developers still use the full type for clarity. \nSince var is valid Java, you may see it in other code, so it's good to know that it exists:"
},
{
"type": "header",
"level": 2,
"text": "The Map Interface"
},
{
"type": "paragraph",
"text": "Note: Sometimes you will see both Map and HashMap in Java code, like this:"
},
{
"type": "paragraph",
"text": "This means the variable (capitalCities) is declared as a Map (the interface), but it stores a HashMap object (the actual map). Since HashMap implements the Map interface, this is possible."
},
{
"type": "playground",
"subtype": "hashmap"
},
{
"type": "header",
"level": 2,
"text": "HashMap Time Complexity"
},
{
"type": "table",
"headers": ["Operation", "Average case", "Worst case", "Notes"],
"rows": [
["put(key, val)", "O(1)", "O(n)", "O(n) only if many hash collisions"],
["get(key)", "O(1)", "O(n)", "Hash collisions degrade to O(n)"],
["containsKey(key)", "O(1)", "O(n)", "Same as get()"],
["remove(key)", "O(1)", "O(n)", "—"],
["Iteration (all entries)", "O(n)", "O(n)", "Must visit every bucket"]
]
},
{
"type": "header",
"level": 2,
"text": "Iterating a HashMap"
},
{
"type": "code",
"language": "java",
"code": "HashMap<String, Integer> scores = new HashMap<>();\nscores.put(\"Alice\", 95);\nscores.put(\"Bob\", 87);\nscores.put(\"Carol\", 92);\n\n// entrySet() — iterate over key+value pairs\nfor (Map.Entry<String, Integer> entry : scores.entrySet()) {\n System.out.println(entry.getKey() + \" → \" + entry.getValue());\n}\n\n// forEach() — lambda shorthand (Java 8+)\nscores.forEach((name, score) ->\n System.out.println(name + \" scored \" + score)\n);\n\n// getOrDefault() — safe access, no NullPointerException\nint davidScore = scores.getOrDefault(\"David\", 0);\nSystem.out.println(\"David: \" + davidScore); // David: 0"
},
{
"type": "paragraph",
"text": "It works the same way, but some developers prefer this style because it gives them more flexibility to change the type later."
}
]
},
"hashset": {
"title": "Java HashSet",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Java HashSet"
},
{
"type": "paragraph",
"text": "A HashSet is a collection of elements where every element is \nunique."
},
{
"type": "paragraph",
"text": "It is part of the java.util package and implements the Set interface."
},
{
"type": "header",
"level": 2,
"text": "Create a HashSet"
},
{
"type": "paragraph",
"text": "Now you can use methods like add(), contains(), and remove() to manage your collection of unique elements."
},
{
"type": "header",
"level": 2,
"text": "Add Elements"
},
{
"type": "paragraph",
"text": "To add elements to a HashSet, use the add() method:"
},
{
"type": "paragraph",
"text": "Note: In the example above, even though \"BMW\" is added twice, it only appears once in the set because sets do not allow duplicate elements."
},
{
"type": "header",
"level": 2,
"text": "Check If an Element Exists"
},
{
"type": "paragraph",
"text": "To check whether an element exists in a HashSet, use the contains() method:"
},
{
"type": "header",
"level": 2,
"text": "Remove an Element"
},
{
"type": "paragraph",
"text": "To remove an element, use the remove() method:"
},
{
"type": "paragraph",
"text": "To remove all elements, use the clear() method:"
},
{
"type": "header",
"level": 2,
"text": "HashSet Size"
},
{
"type": "paragraph",
"text": "Use size() to count how many unique elements are in the set:"
},
{
"type": "paragraph",
"text": "Note: Duplicate values are not counted - only unique elements are included in the size."
},
{
"type": "header",
"level": 2,
"text": "Loop Through a HashSet"
},
{
"type": "paragraph",
"text": "Loop through the elements of an HashSet with a for-each loop:"
},
{
"type": "header",
"level": 2,
"text": "Other Types"
},
{
"type": "paragraph",
"text": "Elements in an HashSet are actually objects. In the examples above, we created \nelements \n(objects) of type \"String\". Remember that a String in Java is an object (not a primitive type). To use other types, such as int, you must specify an equivalent wrapper class: Integer. For other primitive types, \nuse: Boolean for boolean, Character for char, Double for double, \netc:"
},
{
"type": "header",
"level": 2,
"text": "The var Keyword"
},
{
"type": "paragraph",
"text": "From Java 10, you can use the var keyword to declare a HashSet variable without writing the type twice. \nThe compiler figures out the type from the value you assign."
},
{
"type": "paragraph",
"text": "This makes code shorter, but many developers still use the full type for clarity. \nSince var is valid Java, you may see it in other code, so it's good to know that it exists:"
},
{
"type": "header",
"level": 2,
"text": "The Set Interface"
},
{
"type": "paragraph",
"text": "Note: Sometimes you will see both Set and HashSet in Java code, like this:"
},
{
"type": "paragraph",
"text": "This means the variable (cars) is declared as a Set (the interface), but it stores a HashSet object (the actual set). Since HashSet implements the Set interface, this is possible."
},
{
"type": "paragraph",
"text": "It works the same way, but some developers prefer this style because it gives them more flexibility to change the type later."
},
{
"type": "header",
"level": 2,
"text": "When Order Matters"
},
{
"type": "playground",
"subtype": "hashset"
},
{
"type": "code",
"language": "java",
"code": "HashSet<String> cars = new HashSet<>();\ncars.add(\"Volvo\");\ncars.add(\"BMW\");\ncars.add(\"Ford\");\ncars.add(\"BMW\"); // duplicate — silently ignored\n\nSystem.out.println(cars.size()); // 3\nSystem.out.println(cars.contains(\"BMW\")); // true\n\ncars.remove(\"Ford\");\nSystem.out.println(cars); // [Volvo, BMW] (order not guaranteed)\n\n// Loop through all elements\nfor (String c : cars) {\n System.out.println(c);\n}"
},
{
"type": "paragraph",
"text": "In the next chapter, you will learn about TreeSet, which stores unique elements in sorted order."
}
]
},
"iterator": {
"title": "Java Iterator",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Java Iterator"
},
{
"type": "paragraph",
"text": "An Iterator is an object that can be used to loop through collections, like ArrayList\nand HashSet."
},
{
"type": "paragraph",
"text": "It is called an \"iterator\" because \"iterating\" is the technical term for looping."
},
{
"type": "paragraph",
"text": "To use an Iterator, you must import it from the java.util package."
},
{
"type": "header",
"level": 2,
"text": "Getting an Iterator"
},
{
"type": "paragraph",
"text": "The iterator() method can be used to get an Iterator for any collection:"
},
{
"type": "header",
"level": 2,
"text": "Looping Through a Collection"
},
{
"type": "paragraph",
"text": "To loop through a collection, use the hasNext() and next() methods of the Iterator:"
},
{
"type": "header",
"level": 2,
"text": "Removing Items from a Collection"
},
{
"type": "paragraph",
"text": "Iterators are designed to easily change the collections that they loop through. The remove() method can remove items from a collection while looping."
},
{
"type": "note",
"text": "Note: Trying to remove items using a for loop or a \nfor-each loop would not work correctly\nbecause the collection is changing size at the same time that the code is trying to loop.
" }, { "type": "header", "level": 2, "text": "The var Keyword with Iterators" }, { "type": "paragraph", "text": "You can also use thevar keyword with iterators. \nThis avoids repeating the long type name Iterator<String>, since the compiler already knows the type from the collection."
},
{
"type": "paragraph",
"text": "This makes code shorter, but many developers still use the full type for clarity. \nSince var is valid from Java version 10, you may see it in other code, so it's good to know that it exists:"
},
{
"type": "playground",
"subtype": "iterator"
},
{
"type": "code",
"language": "java",
"code": "ArrayList<String> cars = new ArrayList<>();\ncars.add(\"Volvo\");\ncars.add(\"BMW\");\ncars.add(\"Ford\");\n\n// Get an iterator and loop\nIterator<String> it = cars.iterator();\nwhile (it.hasNext()) {\n System.out.println(it.next());\n}\n// Volvo, BMW, Ford\n\n// Safe removal during iteration\nArrayList<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4, 5));\nIterator<Integer> iter = nums.iterator();\nwhile (iter.hasNext()) {\n if (iter.next() < 3) iter.remove(); // removes 1 and 2\n}\nSystem.out.println(nums); // [3, 4, 5]"
},
{
"type": "paragraph",
"text": "Here, var makes the iterator declaration shorter, \nbut the actual type is still Iterator<String>."
}
]
},
"wrapper-classes": {
"title": "Java Wrapper Classes",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Java Wrapper Classes"
},
{
"type": "paragraph",
"text": "Wrapper classes provide a way to use primitive data types (int, boolean, \netc..) as objects."
},
{
"type": "paragraph",
"text": "The table below shows the primitive type and the equivalent wrapper class:"
},
{
"type": "table",
"headers": [
"Primitive Data Type",
"Wrapper Class"
],
"rows": [
[
"byte",
"Byte"
],
[
"short",
"Short"
],
[
"int",
"Integer"
],
[
"long",
"Long"
],
[
"float",
"Float"
],
[
"double",
"Double"
],
[
"boolean",
"Boolean"
],
[
"char",
"Character"
]
]
},
{
"type": "paragraph",
"text": "Sometimes you must use wrapper classes, for example when working with Collection objects, such \nas ArrayList, where primitive types cannot be \nused (the list can only store objects):"
},
{
"type": "header",
"level": 2,
"text": "Creating Wrapper Objects"
},
{
"type": "paragraph",
"text": "To create a wrapper object, use the wrapper class instead of the primitive \ntype. To get the value, you can just print the object:"
},
{
"type": "paragraph",
"text": "Since you're now working with objects, you can use certain methods to get \ninformation about the specific object."
},
{
"type": "paragraph",
"text": "For example, the following methods are used to get the value associated with \nthe corresponding wrapper object: intValue(), byteValue(), shortValue(), longValue(), \nfloatValue(), doubleValue(), charValue(), \nbooleanValue()."
},
{
"type": "paragraph",
"text": "This example will output the same result as the example above:"
},
{
"type": "paragraph",
"text": "Another useful method is the toString() method, which is used to convert wrapper objects to strings."
},
{
"type": "playground",
"subtype": "wrapper-classes"
},
{
"type": "code",
"language": "java",
"code": "// Auto-boxing: primitive → wrapper (automatic)\nint num = 42;\nInteger boxed = num; // autoboxing\nint unboxed = boxed; // unboxing\n\n// Useful static methods\nSystem.out.println(Integer.MAX_VALUE); // 2147483647\nSystem.out.println(Integer.MIN_VALUE); // -2147483648\nSystem.out.println(Integer.parseInt(\"123\")); // 123\nSystem.out.println(Double.parseDouble(\"3.14\")); // 3.14\nSystem.out.println(Integer.toBinaryString(10)); // 1010\n\n// Convert wrapper to String\nString s = Integer.toString(255);\nSystem.out.println(s.length()); // 3 (length of \"255\")"
},
{
"type": "paragraph",
"text": "In the following example, we convert an Integer to a String, and use the length() method of the String class to output the length of the \"string\":"
}
]
},
"exceptions": {
"title": "Java Exceptions - Try...Catch",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Java Exceptions"
},
{
"type": "paragraph",
"text": "As mentioned in the Errors chapter, different types of errors can occur while running a program - such as coding mistakes, invalid input, or unexpected situations."
},
{
"type": "paragraph",
"text": "When an error occurs, Java will normally stop and generate an error message. The technical term for this is: Java will throw an exception (throw an error)."
},
{
"type": "header",
"level": 2,
"text": "Exception Handling (try and catch)"
},
{
"type": "paragraph",
"text": "Exception handling lets you catch and handle errors during runtime - so your program doesn't crash."
},
{
"type": "paragraph",
"text": "It uses different keywords:"
},
{
"type": "paragraph",
"text": "The try statement allows you to define a block of code to be \ntested for errors while it is being executed."
},
{
"type": "paragraph",
"text": "The catch statement allows you to define a block of code to \nbe executed, if an error occurs in the try block."
},
{
"type": "paragraph",
"text": "The try and catch keywords \ncome in pairs:"
},
{
"type": "paragraph",
"text": "Consider the following example:"
},
{
"type": "paragraph",
"text": "If an error occurs, we can use try...catch to catch the error and execute some code to handle it:"
},
{
"type": "header",
"level": 2,
"text": "Finally"
},
{
"type": "paragraph",
"text": "The finally statement lets you execute code, after try...catch, regardless of the result:"
},
{
"type": "header",
"level": 2,
"text": "The throw keyword"
},
{
"type": "paragraph",
"text": "The throw statement allows you to create a custom error."
},
{
"type": "paragraph",
"text": "The throw statement is used together with an exception type. There are many exception types available in Java: ArithmeticException, \nFileNotFoundException, ArrayIndexOutOfBoundsException, SecurityException, etc:"
},
{
"type": "paragraph",
"text": "If age was 20, you would not get an exception:"
},
{
"type": "header",
"level": 2,
"text": "Errors and Exception Types"
},
{
"type": "paragraph",
"text": "The table below shows some of the most common errors and exceptions in Java, with a short description of each:"
},
{
"type": "playground",
"subtype": "exceptions"
},
{
"type": "header",
"level": 2,
"text": "Exception Hierarchy"
},
{
"type": "table",
"headers": ["Exception Type", "Checked?", "Common cause", "Example"],
"rows": [
["ArithmeticException", "Unchecked", "Division by zero", "int x = 5 / 0;"],
["NullPointerException", "Unchecked", "Using a null reference", "str.length() when str is null"],
["ArrayIndexOutOfBoundsException", "Unchecked", "Accessing invalid array index", "arr[10] on a 5-element array"],
["NumberFormatException", "Unchecked", "Invalid string-to-number parse", "Integer.parseInt(\"abc\")"],
["IOException", "Checked", "File not found / read error", "Reading a missing file"]
]
},
{
"type": "header",
"level": 2,
"text": "throw vs throws"
},
{
"type": "code",
"language": "java",
"code": "// throw — explicitly throws an exception inside a method\nvoid setAge(int age) {\n if (age < 0 || age > 150) {\n throw new IllegalArgumentException(\"Invalid age: \" + age);\n }\n this.age = age;\n}\n\n// throws — declares that a method MAY throw a checked exception\nvoid readFile(String path) throws IOException {\n BufferedReader reader = new BufferedReader(new FileReader(path));\n System.out.println(reader.readLine());\n reader.close(); // caller must handle or re-declare IOException\n}\n\n// Multi-catch — handle multiple exception types at once (Java 7+)\ntry {\n int[] arr = new int[3];\n arr[10] = 1;\n} catch (ArrayIndexOutOfBoundsException | NullPointerException e) {\n System.out.println(\"Caught: \" + e.getMessage());\n} finally {\n System.out.println(\"Always runs\");\n}"
},
{
"type": "note",
"text": "Best practices: Catch the most specific exception first (e.g., FileNotFoundException before IOException). Always close resources in finally — or better, use try-with-resources: try (var r = new FileReader(\"f.txt\")) { ... } — it closes automatically."
},
{
"type": "paragraph",
"text": "Tip: For a list of all errors and exception types, go to our Java Errors and Exception Types Reference."
}
]
},
"regex": {
"title": "Java Regular Expressions",
"blocks": [
{
"type": "header",
"level": 2,
"text": "What is a Regular Expression?"
},
{
"type": "paragraph",
"text": "A regular expression is a sequence of characters that forms a search pattern.\nWhen you search for data in a text, you can use this search pattern to describe what you\nare searching for."
},
{
"type": "paragraph",
"text": "A regular expression can be a single character, or a more complicated pattern."
},
{
"type": "paragraph",
"text": "Regular expressions can be used to perform all types of text search and text replace\noperations."
},
{
"type": "paragraph",
"text": "Java does not have a built-in Regular Expression class, but we can import the java.util.regex \npackage to work with regular expressions. The package includes the following \nclasses:"
},
{
"type": "list",
"ordered": false,
"items": [
"Pattern Class - Defines a pattern (to be used in a search)",
"Matcher Class - Used to search for the \npattern",
"PatternSyntaxException Class - Indicates syntax error in a regular \nexpression pattern"
]
},
{
"type": "header",
"level": 3,
"text": "Example Explained"
},
{
"type": "paragraph",
"text": "In this example, The word \"codingtamilan\" is being searched for in a sentence."
},
{
"type": "paragraph",
"text": "First, the pattern is created using the Pattern.compile() method. The first parameter\nindicates which pattern is being searched for and the second parameter has a flag to\nindicates that the search should be case-insensitive. The second parameter is optional."
},
{
"type": "paragraph",
"text": "The matcher() method is used to search for the pattern in a string. It returns a Matcher\nobject which contains information about the search that was performed."
},
{
"type": "paragraph",
"text": "The find() method returns true if the pattern was found in the string and false if it was not\nfound."
},
{
"type": "code",
"language": "java",
"code": "import java.util.regex.*;\n\n// Basic match\nPattern p = Pattern.compile(\"codingtamilan\", Pattern.CASE_INSENSITIVE);\nMatcher m = p.matcher(\"I love CodingTamilan!\");\nSystem.out.println(m.find()); // true\n\n// Full-string match\nSystem.out.println(\"Hello\".matches(\"[A-Z][a-z]+\")); // true\n\n// Find all occurrences\nPattern pAll = Pattern.compile(\"cat\");\nMatcher mAll = pAll.matcher(\"cat and cats and catch\");\nwhile (mAll.find()) {\n System.out.println(\"Found at index \" + mAll.start());\n}\n// Found at index 0\n// Found at index 8\n// Found at index 17"
},
{
"type": "header",
"level": 2,
"text": "Flags"
},
{
"type": "paragraph",
"text": "Flags in the compile() method change how the search is performed. Here are a few of\nthem:"
},
{
"type": "list",
"ordered": false,
"items": [
"Pattern.CASE_INSENSITIVE - The case of letters will be ignored when performing\na search.",
"Pattern.LITERAL - Special characters in the pattern will not have any special\nmeaning and will be treated as ordinary characters when performing a search.",
"Pattern.UNICODE_CASE - Use it together with the CASE_INSENSITIVE flag to\nalso ignore the case of letters outside of the English alphabet"
]
},
{
"type": "header",
"level": 2,
"text": "Regular Expression Patterns"
},
{
"type": "paragraph",
"text": "The first parameter of the Pattern.compile() method is the pattern. It describes what\nis being searched for."
},
{
"type": "paragraph",
"text": "Brackets are used to find a range of characters:"
},
{
"type": "table",
"headers": [
"Expression",
"Description"
],
"rows": [
[
"[abc]",
"Find one character from the options between the brackets"
],
[
"[^abc]",
"Find one character NOT between the brackets"
],
[
"[0-9]",
"Find one character from the range 0 to 9"
]
]
},
{
"type": "header",
"level": 2,
"text": "Metacharacters"
},
{
"type": "paragraph",
"text": "Metacharacters are characters with a special meaning:"
},
{
"type": "table",
"headers": [
"Metacharacter",
"Description"
],
"rows": [
[
"|",
"Find a match for any one of the patterns separated by | as in: cat|dog|fish"
],
[
".",
"Find just one instance of any character"
],
[
"^",
"Finds a match as the beginning of a string as in: ^Hello"
],
[
"$",
"Finds a match at the end of the string as in: World$"
],
[
"\\d",
"Find a digit"
],
[
"\\s",
"Find a whitespace character"
],
[
"\\b",
"Find a match at the beginning of a word like this: \\bWORD, or at the end of a word like this: WORD\\b"
],
[
"\\uxxxx",
"Find the Unicode character specified by the hexadecimal number xxxx"
]
]
},
{
"type": "header",
"level": 2,
"text": "Quantifiers"
},
{
"type": "paragraph",
"text": "Quantifiers define quantities:"
},
{
"type": "playground",
"subtype": "regex"
},
{
"type": "table",
"headers": [
"Quantifier",
"Description"
],
"rows": [
[
"n+",
"Matches any string that contains at least one n"
],
[
"n*",
"Matches any string that contains zero or more occurrences of n"
],
[
"n?",
"Matches any string that contains zero or one occurrences of n"
],
[
"n{x}",
"Matches any string that contains a sequence of X n's"
],
[
"n{x,y}",
"Matches any string that contains a sequence of X to Y n's"
],
[
"n{x,}",
"Matches any string that contains a sequence of at least X n's"
]
]
},
{
"type": "header",
"level": 2,
"text": "Real-World Regex Examples"
},
{
"type": "table",
"headers": ["Use case", "Pattern", "Notes"],
"rows": [
["Email", "[\\w.-]+@[\\w.-]+\\.[a-zA-Z]{2,}", "Basic; use a library for production"],
["Indian phone", "[6-9]\\d{9}", "10-digit, starts 6–9"],
["Digits only", "\\d+", "One or more digits"],
["Alphanumeric", "[a-zA-Z0-9]+", "Letters and digits"],
["Date dd/mm/yyyy", "(0[1-9]|[12]\\d|3[01])/(0[1-9]|1[0-2])/\\d{4}", "Strict day/month range"]
]
},
{
"type": "code",
"language": "java",
"code": "// String.matches() — full-string regex test\nString email = \"user@example.com\";\nSystem.out.println(email.matches(\"[\\\\w.-]+@[\\\\w.-]+\\\\.[a-zA-Z]{2,}\")); // true\n\n// replaceAll — remove all non-digits\nString cleaned = \"Phone: 98-765-43210\".replaceAll(\"\\\\D\", \"\");\nSystem.out.println(cleaned); // 9876543210\n\n// split by whitespace\nString[] words = \"hello world java\".split(\"\\\\s+\");\nSystem.out.println(Arrays.toString(words)); // [hello, world, java]"
}
]
},
"threads": {
"title": "Java Threads",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Java Threads"
},
{
"type": "paragraph",
"text": "Threads allows a program to operate more efficiently by doing multiple things at the same\ntime."
},
{
"type": "paragraph",
"text": "Threads can be used to perform complicated tasks in the background without interrupting\nthe main program."
},
{
"type": "header",
"level": 2,
"text": "Creating a Thread"
},
{
"type": "paragraph",
"text": "There are two ways to create a thread."
},
{
"type": "paragraph",
"text": "It can be created by extending the Thread class and overriding its run() \nmethod:"
},
{
"type": "paragraph",
"text": "Another way to create a thread is to implement the Runnable interface:"
},
{
"type": "header",
"level": 2,
"text": "Running Threads"
},
{
"type": "paragraph",
"text": "If the class extends the Thread class, the thread can be run by creating an instance of the\nclass and call its start() method:"
},
{
"type": "paragraph",
"text": "If the class implements the Runnable interface, the thread can be run by passing an\ninstance of the class to a Thread object's constructor and then calling the thread's\nstart() method:"
},
{
"type": "note",
"text": "Differences between \"extending\" and \"implementing\" Threads
\nThe major difference is that when a class extends the Thread class, you cannot extend any other class, but by implementing the Runnable interface, \nit is possible to extend from another class as well, like: class MyClass extends OtherClass implements Runnable.
new Thread(task)"],
["RUNNABLE", "Ready to run (waiting for CPU time)", "thread.start()"],
["RUNNING", "Currently executing run()", "JVM scheduler selects it"],
["BLOCKED/WAITING", "Paused — waiting for lock or another thread", "sleep(), wait(), join()"],
["TERMINATED", "run() method has finished", "Normal completion or exception"]
]
},
{
"type": "note",
"text": "start() vs run(): Always call start() — it creates a new thread and calls run() on it. Calling run() directly just executes the method on the current thread — no new thread is created."
},
{
"type": "paragraph",
"text": "To avoid concurrency problems, it is best to share as few attributes between threads as\npossible. If attributes need to be shared, one possible solution is to use the isAlive()\nmethod of the thread to check whether the thread has finished running before using any \nattributes that the thread can change."
}
]
},
"lambda": {
"title": "Java Lambda Expressions",
"blocks": [
{
"type": "header",
"level": 2,
"text": "Java Lambda Expressions"
},
{
"type": "paragraph",
"text": "Lambda Expressions were added in Java 8."
},
{
"type": "paragraph",
"text": "A lambda expression is a short block of code that takes in parameters and returns a value. \nLambdas look similar to methods, but they do not need a name, and they can be written right inside a method body."
},
{
"type": "header",
"level": 2,
"text": "Syntax"
},
{
"type": "paragraph",
"text": "The simplest lambda expression contains a single parameter and an expression:"
},
{
"type": "paragraph",
"text": "To use more than one parameter, wrap them in parentheses:"
},
{
"type": "paragraph",
"text": "Simple expressions must return a value immediately. They cannot contain multiple statements, such as loops or if conditions. \nTo do more complex work, use a code block with curly braces. If the lambda should return a value, use the return keyword:"
},
{
"type": "header",
"level": 2,
"text": "Using Lambda Expressions"
},
{
"type": "paragraph",
"text": "Lambdas are often passed as arguments to methods. For example, you can use a lambda in the \nforEach() method of an ArrayList:"
},
{
"type": "header",
"level": 2,
"text": "Lambdas in Variables"
},
{
"type": "paragraph",
"text": "A lambda expression can be stored in a variable. The variable's type must be an interface with exactly one method \n(a functional interface). The lambda must match that method's parameters and return type."
},
{
"type": "paragraph",
"text": "Java includes many built-in functional interfaces, such as Consumer (from the java.util package) used with lists."
},
{
"type": "header",
"level": 2,
"text": "Lambdas as Method Parameters"
},
{
"type": "paragraph",
"text": "You can also pass a lambda expression to a method. The method's parameter must be a functional interface. \nCalling the interface's method will then run the lambda expression:"
},
{
"type": "header",
"level": 2,
"text": "Anonymous Class vs. Lambda Expression"
},
{
"type": "playground",
"subtype": "lambda"
},
{
"type": "header",
"level": 2,
"text": "Lambdas with the Stream API"
},
{
"type": "paragraph",
"text": "Lambdas shine brightest with the Stream API — a powerful way to process collections with a pipeline of operations: filter, transform, and collect in one readable chain."
},
{
"type": "code",
"language": "java",
"code": "import java.util.List;\nimport java.util.stream.Collectors;\n\nList<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);\n\n// Pipeline: filter evens → square them → collect to list\nList<Integer> evenSquares = numbers.stream()\n .filter(n -> n % 2 == 0) // keep even numbers\n .map(n -> n * n) // square each\n .collect(Collectors.toList());\nSystem.out.println(evenSquares); // [4, 16, 36, 64, 100]\n\n// Sum all numbers\nint total = numbers.stream()\n .reduce(0, Integer::sum);\nSystem.out.println(\"Sum: \" + total); // Sum: 55\n\n// Find any number greater than 7\nnumbers.stream()\n .filter(n -> n > 7)\n .findFirst()\n .ifPresent(n -> System.out.println(\"Found: \" + n)); // Found: 8"
},
{
"type": "header",
"level": 2,
"text": "Method References"
},
{
"type": "paragraph",
"text": "When a lambda just calls an existing method, you can replace it with a method reference using :: — more concise and easier to read."
},
{
"type": "table",
"headers": ["Type", "Syntax", "Lambda equivalent"],
"rows": [
["Static method", "ClassName::methodName", "n -> Integer.parseInt(n) → Integer::parseInt"],
["Instance method (specific object)", "obj::methodName", "s -> obj.startsWith(s) → obj::startsWith"],
["Instance method (any object)", "ClassName::methodName", "s -> s.toUpperCase() → String::toUpperCase"],
["Constructor", "ClassName::new", "() -> new StringBuilder() → StringBuilder::new"]
]
},
{
"type": "paragraph",
"text": "In Java 8+, you can often replace an \nanonymous class with a lambda expression - \nbut only if the interface is a functional interface (one abstract method)."
}
]
},
"files": {
"title": "Java Files",
"blocks": [
{
"type": "intro",
"text": "File handling is an important part of any application."
},
{
"type": "intro",
"text": "Java has several methods for creating, reading, updating, and \ndeleting files."
},
{
"type": "header",
"level": 2,
"text": "Java File Handling"
},
{
"type": "paragraph",
"text": "The File class from the java.io package, allows \nus to work with files."
},
{
"type": "paragraph",
"text": "To use the File class, create an object of \nthe class, and specify the filename or directory name:"
},
{
"type": "note",
"text": "If you don't know what a package is, read our Java Packages Tutorial.
" }, { "type": "paragraph", "text": "TheFile class has many useful methods for creating and getting information \nabout files. \nFor example:"
},
{
"type": "playground",
"subtype": "files"
},
{
"type": "header",
"level": 2,
"text": "Modern File API — java.nio.file.Files"
},
{
"type": "paragraph",
"text": "Since Java 7, java.nio.file.Files provides a cleaner, more powerful file API with less boilerplate than the old java.io approach."
},
{
"type": "code",
"language": "java",
"code": "import java.nio.file.Files;\nimport java.nio.file.Path;\nimport java.util.List;\n\n// Write to a file (creates or overwrites)\nPath file = Path.of(\"notes.txt\");\nFiles.writeString(file, \"Hello from NIO!\");\n\n// Read entire file as a String\nString content = Files.readString(file);\nSystem.out.println(content); // Hello from NIO!\n\n// Read all lines as a List\nList<String> lines = Files.readAllLines(file);\nlines.forEach(System.out::println);\n\n// Check if file exists\nif (Files.exists(file)) {\n System.out.println(\"File size: \" + Files.size(file) + \" bytes\");\n}\n\n// Delete the file\nFiles.deleteIfExists(file);"
},
{
"type": "table",
"headers": ["Approach", "Package", "Best for", "Complexity"],
"rows": [
["Files.writeString() / readString()", "java.nio.file", "Quick file read/write (Java 11+)", "Low"],
["FileWriter / BufferedReader", "java.io", "Fine-grained streaming, append mode", "Medium"],
["Scanner", "java.util", "Reading line-by-line interactively", "Low"],
["Files.readAllLines()", "java.nio.file", "Reading all lines into a List (Java 7+)", "Low"]
]
},
{
"type": "paragraph",
"text": "You will learn how to create, write, read and delete files in the next chapters:"
}
]
}
}