Java Programming Introduction for Beginners

Explore conditionals in Java using if/else, boolean conditions, and user input with scanner; practice voting age checks, class count ranges, nested ifs, modulus for even/odd, and exam score tiers.

Explore the ternary operator as a shorthand for if/else in Java, with syntax, true/false outcomes, and readability considerations using a voting-age example.

Apply if/else conditionals in java to check voting eligibility against a minimum age of 18. See hard-coded values, print statements, and a future move to user input with a scanner.

Demonstrate reading user input with a scanner and applying if/else to determine voting eligibility based on age; refactor into a boolean variable and avoid redundant comparisons.

Master Java conditionals with if/else compounds and nested if to validate an enrollment class count using a scanner and check min and max bounds.

Implement a nested if else to determine whether a user count is even or odd using the modulus operator, and print corresponding messages for each case.

Apply if else if conditions in Java to assign exam score tiers using 90% and 80% minimums, and print the corresponding tier or a low grade.

Use the ternary operator to replace an if-else with a concise boolean expression that checks if age is at least the voting age, printing whether you are eligible to vote.

Learn how to compare strings in Java using dot equals for content equality and avoid the memory-address based double equals, with explanations of string interning and the new string keyword.

Explore how the double equals operator compares memory addresses rather than string contents by coding a compare strings demo with S1, S2, and S3 in Java.

Learn to compare strings using the dot equals method to check contents rather than memory addresses, and use equals ignore case for case-insensitive matches; avoid the double equal operator.

Discover how the switch statement chooses code blocks based on a value, replacing long if-else chains. Master syntax, break, default, and supported types: primitive numbers, characters, wrappers, strings, and enums.

Learn switch statements in Java by handling smartphone, tablet, laptop, and desktop with break and a default case, then transition from hard coded data to user input with a scanner.

Master switch statements and the importance of breaks to prevent fall-through. Convert user input to lowercase to match cases, and rely on a default for unknown values.

Demonstrates using a Java switch statement with fall through to map month numbers to quarters, handling invalid months and sharing logic across Q1–Q4 with a scanner input.

Explore the modern switch statement in Java 14, with arrow syntax and no repeated breaks. Discover reduced boilerplate, improved readability, broader type support, null handling, and value returns.

Build a Java program that uses the modern switch with arrow syntax to handle smartphone, tablet, laptop, and desktop, with a default case and input normalized to lowercase.

Modify the switch statement to return a value by assigning a string description, refactor to remove repeated print lines, and run the app to confirm unchanged behavior.

Explore enums as a type-safe collection of related constants in Java, enabling compile-time checks, and use them in a switch statement with example values smartphone, tablet, laptop, and desktop.

Create a Java enum named ComputerType with values smartphone, tablet, laptop, and desktop, integrate it in an enumDemo class using a switch on the enum, and print results.

Prompt users for a computer type, read and sanitize input, convert to an enum, and use a switch statement to display the result, with error handling for invalid input.

For loops teach repeating code efficiently, covering initialization, condition, and update, with examples like printing hello world and a nested five by five multiplication table using a tab.

Discover how to use for loops in Java by creating a new project, writing a class that prints hello world 100 times, and exploring initialization, condition, and update.

Demonstrates creating a 5x5 multiplication table with nested for loops, using an outer loop for rows and an inner loop for columns, and printing aligned values with tab.

Explore while loops in Java, learn their syntax and use cases, and compare with do while. See prompts, user input, and exit conditions drive loop control.

Demonstrates Java loops by implementing a while loop that prompts the user until done, using a scanner and a boolean, then shows a do-while variant to illustrate end-of-loop checks.

Explore the break and continue statements within Java loops, showing how break exits the current loop and continue skips the remaining code of an iteration, including while and do-while usage.

Learn break and continue in a Java for loop. The demo shows breaking at five to exit the loop and skipping remaining statements in the current iteration.

Learn how Java methods function as reusable blocks of code defined and called to perform actions, with static and void return types and parameters, illustrated by a display greetings example.

Learn how to create and call a static void method in Java, define a method display greetings, call it from main, and view outputs like hello, world and welcome messages.

Explore method parameters and overloading in Java, learning to pass inputs to a method, reuse code via calls, and understand how overloaded methods are chosen by parameter types and counts.

Define a method with an int parameter to display greetings, then call it from main to print three times. Refactor to remove duplicate code and follow the dry principle.

Explore Java method overloading with display greetings, where the same name handles different parameters. Java resolves calls by parameters, while ambiguity triggers a compilation error; the demo shows five outputs.

Explore Java methods that return values, including int, double, and custom classes. See summation and inventory count examples, plus using a for loop or the n(n+1)/2 formula.

Define a static summation method that adds numbers from 1 to num with a for loop, returns the result, and refactors to the num*(num+1)/2 formula by inlining the return.

Explore recursion with methods, focusing on base case and recursive case, and solving smaller problems. See how the factorial example uses recursion to compute n factorial via self calls.

Define a Java class recursion demo with a static int factorial(num) using a base case of zero returns one, and a recursive case num*factorial(num-1); main prints 120 for 5.

Explore arrays as fixed-size data structures for storing elements of the same type, learn initialization, zero-based indexing, length attribute, and two looping methods (for and enhanced for) with practical examples.

Create and initialize a string array colors with red, green, blue, and yellow, then print each element using zero-based indexing and display the array length.

Learn to loop through arrays in Java using a basic for loop and an enhanced for loop, with dynamic sizing and zero-based indexing.

Explore arrays initialization by size, assign values, and print elements with loops; learn zero-based indexing, default 0.0, and reading user input to size and populate a double array of grades.

Create a Java class, initialize a double array grades of size 3 to demonstrate zero-based indexing, assign 100.0, 76.7, and 89.0, then print them with an enhanced for loop.

Prompt users for the number of grades, allocate a double array accordingly, read each grade with a scanner, and then print the array elements using an enhanced for loop.

Pass a double array into a newly defined method, compute the sum with a for loop, divide by the array length, and return the grade average.

Pass arrays into methods by computing a grade average with a for loop, using the array length, and printing the result.

Refactor a Java program to return a 2d array of grades from a dedicated method, prompting for the number of grades and processing the results.

Refactor a grade average demo by extracting read user input grades and display grades into separate methods, returning an array of doubles and streamlining the main workflow.

Explore Java array utilities, learn how to fill an array with a value using Arrays.fill, and initialize and print arrays from user input, while noting sorting, searching, copying, and conversions.

Create a Java class Fill Array Demo, prompt for array size and fill value with a scanner, initialize the array, fill it with Arrays.fill, and display the contents.

Sort an array using Arrays.sort and observe before-and-after results for any data type, from primitive numbers to strings or custom classes, with user-provided input and a display helper.

Read user input into an array, sort it with Arrays.sort, and display the data before and after sorting. Learn about zero-based indexing and extracting a display method for reuse.

Learn to search a java array using Arrays.binarySearch after sorting, and understand why unsorted data yields undefined results. See a coding example that prompts input, sorts, and searches.

Prompt the user for a search key, sort the array, perform a binary search with Arrays.binarySearch, and display whether the key is found and its index.

Explore two-dimensional arrays in Java, initialize and populate a multiplication table, index by row and column, and apply 2D grids to seating charts, scheduling, board games, and image processing.

Learn to create and initialize a two-dimensional (2d) array in Java based on user-specified rows and columns, fill it with a multiplication table using nested loops, and print the results.

Learn to build a Java number guessing game that generates a random secret number within a range and uses three guessing attempts with feedback.

Create a Java number guessing game by initializing a class, generating a secret number (1–5) with random, and looping three attempts with a scanner to guess and reveal the secret.

Create a word quest game that selects a random word from an array, reveals characters with underscores, and lets players guess letters within ten attempts, decrementing only on wrong guesses.

Implement a Java word quest game loop that reads a single uppercase letter, updates the game board, and tracks remaining attempts until the word is revealed or no attempts remain.

Create a Java class Word Quest Demo that selects a random uppercase secret word and initializes a game board of underscores using a char array, introducing Arrays.fill.

Set up a Word Quest style word-guess game loop in Java by reading uppercase letter guesses with a scanner, displaying the current word state, and tracking remaining attempts until solved.

Iterate the secret word to compare each letter with the user's guess, reveal matches on the game board, and use a contains underscores check to determine completion.

Develop a word-guess game in Java that handles incorrect guesses, updates remaining attempts after each guess, and shows a closing message with the secret word when the game ends.

Refactor the word quest game: rename the boolean to has missing letters, replace underscores with dashes, and read words from a file instead of a hard-coded array.

Learn to read words from a file in Java using java.io utilities, convert a list to an array, and retrieve a random word while handling paths and exceptions.

Refactor the word quest demo by renaming the has missing letters variable, introduce an empty placeholder dash as a constant, and rename the contains method for clarity, then run.

Create a data directory and place sample words.txt in the data folder. Read all lines from the file with Java NIO and import lists, throwing IOException.

Learn to convert a list to an array, read words from a file, and pick a random word in Java, with io exception handling and testing.

Explore object oriented programming as the core paradigm of java, learn how objects combine data and code, and review the four pillars: encapsulation, abstraction, inheritance, and polymorphism.

Create an enemy class with health points and attack damage, then spawn two fighters such as zombie and ogre to battle in an arena, illustrating encapsulation, abstraction, inheritance, and polymorphism.

Create a java battle arena project, define an enemy class with health points, attack damage, and type, instantiate an enemy in main, set type to zombie, and print stats.

Discover how abstraction hides implementation details in Java by exposing simple enemy behaviors, such as talk, walk forward, and attack, to create reusable, scalable code and follow the dry principle.

Learn to apply abstraction in Java by hiding implementation in an enemy class and exposing talk, walk forward, and attack methods for reusable, scalable code and the dry principle.

Explore encapsulation in Java by making fields private and using getters and setters to protect data and control access to enemy properties like type, health points, and attack damage.

Encapsulate the enemy object by making its fields private and exposing data only through getters and setters for type of enemy, health points, and attack damage.

Explore constructors in Java, including default empty, no-argument, and parameter constructors, and learn how they initialize objects and support encapsulation with getters.

Learn how encapsulation uses getters and setters to manage health points and attack damage, and how default empty constructors, no-argument constructors, and parameterized constructors initialize objects.

Explore object oriented programming basics, naming conventions and references, using camelCase and new to instantiate distinct objects like zombie and ogre with constructor values, avoiding shared references.

Create distinct enemy objects, such as zombie and ogre, with separate health points and attack values, and see how shared memory references can cause unintended changes without new instances.

Explore plain old Java objects, or pojo: public classes with a default no-argument constructor, private fields with getters and setters, no business logic or external dependencies, and encapsulation.

Explore how inheritance creates a class hierarchy by extending a parent animal class into dog and bird subclasses, reusing attributes and methods, and demonstrating method overriding.

Learn how this refers to the current object and super calls the parent class, including usage in constructors and instance methods, demonstrated with a person and a student example.

Implement inheritance in the battle app by turning enemy into a parent class and creating zombie and ogre as children, overriding talk and adding zombie-specific spread disease.

Explore the override annotation in Java, which improves readability and enables compiler warnings by confirming actual method overrides, demonstrated by an ogre class overriding talk from its enemy superclass.

Learn how inheritance works in Java by extending an enemy base class to create a zombie, using super to initialize health points and attack damage while reusing encapsulated behavior.

Override the zombie's talk method to print grumbling and apply the @Override annotation to confirm overriding. Create an ogre that extends enemy, calls super in constructor, and overrides talk.

Use static variables to belong to the class rather than objects, track the total number of enemies, and assign the running total to each new enemy's ID.

Learn how static variables function as class variables shared by all instances, using a private static counter to assign an id and expose getters for id and number of enemies.

Explore polymorphism by storing dogs, birds, and lions in an animal array and invoking talk to produce bark, chirp, or roar at runtime.

Explore polymorphism in java by implementing a battle function in Main.java that accepts an enemy and calls talk and attack on zombie and ogre instances, demonstrating runtime polymorphism.

Explore polymorphism in Java by creating a battle method that accepts an enemy and calls talk and attack, demonstrated with zombie and ogre objects at runtime.

Create a base enemy class in Java and extend it to ogre and zombie with their own special attacks. Run a battle loop to determine the winner.

Implement object oriented battle mechanics by adding special attacks to enemies—zombies that regenerate health points and ogres that boost attack damage—using constructors, health points remaining, getters and setters, and overrides.

Design and run a two-enemy battle in Java oop, simulating health points, special attacks, and attack damage until a winner emerges.

Demonstrates using a static get number of enemies to count and print two enemies ready to fight, while contrasting static versus instance methods like spread disease.

Discover how Java interfaces serve as blueprints for class behavior, with no method bodies or constructors; implement talk, TAC, getters, setters, and ID in enemy, using override for clarity.

Explore how to implement interfaces in Java by creating enemy, zombie, and ogre interfaces, then implement battle stance and stare down methods in their classes, linking through inheritance.

Explore Java interfaces as abstract blueprints that define enemy behavior, and learn how to implement them in ogre and zombie classes, highlighting is-a relationships and the required methods.

Create and implement interfaces for zombie and ogre in a Java OOP project, extending enemy and implementing AI interfaces to define battle stance and stare down behaviors.

Explore abstract classes in Java by showing how they cannot be instantiated and must be subclassed, turning a generic enemy into concrete types like zombie or ogre.

Learn how abstract classes work in Java by using an abstract enemy that cannot be instantiated and must be subclassed like zombie or ogre, or used as a type.

Explore composition in Java object-oriented programming, showing how a vehicle contains an engine to form a has a relationship, with constructors and methods to start and stop the engine.

Learn how to implement composition in Java by building a hero with a weapon, using AI interfaces for hero and weapon, and equipping weapons to boost attack in battles.

Build a hero class that uses a weapon object via the AI weapon interface, demonstrating composition and a has-a relationship, encapsulation, and getters to expose type and attack increase.

Build a Java OOP hero using composition by creating an AI hero interface and a hero class with health points, attack damage, and a weapon, including getters, setters, and attack.

Create a hero battle that pits a hero against an enemy using composition, a sword that increases attack by five, and health points to guide the fight.

Organize your Java project by creating dedicated packages for enemies, heroes, weapons, and implementation, and learn how to import classes across packages.

Organize and refactor the Battle Arena project by creating enemies and heroes packages, moving classes, and updating imports for a clean, nested package structure.

Explore the Java collections framework, its interfaces (list, set, deque, map) and common implementations (ArrayList, LinkedList, HashSet, ArrayDeque, HashMap) to reduce programming effort and simplify API learning.

Explore the list interface and array list in the Java collections framework. Learn how array lists resize automatically, manage size and capacity, and use generics like string and integer.

Learn how to replace fixed-size arrays with array lists in Java, using the List interface for dynamic capacity. Add, get, set, and iterate over items with for-each loops.

Explore ArrayList methods for adding, getting, setting, and removing elements, plus size, contains, indexOf, lastIndexOf, remove, and unmodifiable lists with List.of.

Master array list methods in Java by creating a numbers list with a for-each loop, using add, size, contains, indexOf, remove, sort, and clear, plus List.of usage.

Learn to store TodoItem objects in an ArrayList by using a class with private fields and a public constructor, then add items like 'walk the dog' with priority 3.

Learn how to store custom objects in a Java ArrayList by creating a TodoItem class with title and priority, encapsulating fields with getters, and iterating to print each item's details.

Explore how a doubly linked list in the Java collections framework uses nodes that reference one another, an implementation of List and Deque interfaces, contrasting with array lists.

Explore how linked lists differ from array lists, create and manipulate a linked list, and use get, set, size, and various add methods along with list and deck interface concepts.

Explore common linked list methods in Java, including add, get, remove, and peek operations, along with unmodifiable lists and deque features that show how LinkedList implements List, Deque, and Queue.

Explore practical linked list methods in Java, including contains, contains all, index of, last index of, remove, retain all, sort with natural and reverse order, and peek first.

Explore sets and hash sets in the Java collections framework, where sets avoid duplicates and hash sets are unordered, with iteration order that can change.

Learn how hash sets store unique elements, use add, contains, remove, size, and clear, and why sets are unordered and do not support get by index.

Learn Java sets and hash sets, including instantiation, adding items, and printing, with emphasis on unordered storage and no duplicates; use remove, contains, size, and clear for management.

Explore queues and deques in Java, including fifo behavior, tail insertion, and head-to-tail retrieval. Learn ArrayDeque implementation, null handling guidance, and using var for concise code.

Explore array deck methods for managing the head and tail, including add, add first, add last, remove first, remove last, peek first, peek last, get first, get last, and contains.

Explore deques, a double ended queue in Java, using array deque from java.util to manage a deck of cards with add first, add last, and get first.

Explore maps and hash maps in Java, focusing on key-value pairs, key uniqueness, and how HashMap provides a Map implementation with put and get, no indexed access or guaranteed order.

Learn to create a hash map, add pairs using put, fetch with get, check keys with contains key and values with contains value, use put if absent, replace, remove, clear.

Learn to use maps and hash maps in Java by creating a string-to-string HashMap, adding keys with put, and retrieving values with get.

Explore exception handling in Java to manage runtime errors and keep the app flow intact, using try and catch blocks to handle null pointer, array index, parsing, and arithmetic exceptions.

Explore Java exception handling by parsing strings to integers with Integer.parseInt and using a try-catch block to gracefully handle NumberFormatException and print friendly error messages.

Explore how to use try and multiple catch statements in Java to differentiate null pointer and number format exceptions when parsing strings, and print specific error messages for invalid input.

Learn how to use multiple catch blocks to handle specific exceptions like number format exception and null pointer exception, and implement a multi catch to simplify error handling.

Explore how the finally block always runs after a try or catch. See how the finally block closes file or database connections and handles null pointer and number format exceptions.

explain how the finally block always runs after try and catch, regardless of exceptions, and demonstrate its use with print statements like 'in the finally block'.

Learn how to read files in Java using the file reader class, handle checked exceptions with try catch, and use the throws keyword to propagate file not found errors.

Learn to read files in Java with a file reader, handle checked exceptions via try-catch, and use throws to propagate file not found exceptions.

Learn how to use a file reader to read a file from disk character by character, handle io exceptions, and close the reader to prevent resource leaks.

Learn to read a text file in java using a file reader by loading the story.txt file. Iterate characters, handle end-of-file with -1, print the contents, and manage resources.

Learn how a buffered reader buffers characters for line-by-line reading from a file by wrapping a file reader and using readLine, with end-of-file as null and printStackTrace aiding debugging.

Learn how to use a buffered reader to read a text file line by line, improving performance over a file reader, with proper exception handling and cleanup.

Explore the try-with-resources syntax and learn how Java automatically closes file resources, like BufferedReader and FileReader, by using resources in the try block.

Learn try with resources syntax by instantiating a BufferedReader in the try. Let Java auto-close the resource and remove the finally block after execution.

Create and write files in Java using buffered writer and file writer to produce file.txt, then read it with a buffered reader. Use try-with-resources and handle exceptions.

learn to create and write to a text file using a buffered writer in java, including try-with-resources, handling io exceptions, and reading the file back to print to the terminal.

Discover how Java lambdas express single method instances for concise functional programming, enabling iteration, filtering, and data extraction with the stream API, including examples with foreach and for each.

Discover how Java lambdas work by converting a for-each loop to a one-line lambda with list.forEach, printing names from an array list and exploring functional interfaces and arrow syntax.

Explore functional interfaces in Java and create lambdas from single-method interfaces. Use predicates with chaining, or, and negate to build flexible logic.

Learn how to create a Java lambda from scratch by defining a functional interface with a single method, implementing it with a lambda, and print hello Java developers.

Explore lambdas by building functional interfaces for string endings and string comparison, and using a Java predicate to test numbers, chain conditions with and, or, and negate.

Explore how lambdas use try and catch to handle runtime errors gracefully. See a divide lambda that catches arithmetic exceptions, prints the stack trace, and returns -1.

Learn to implement try and catch inside a Java lambda by using a functional interface calculate, handling arithmetic exceptions, printing the stack trace, and returning -1 on error.

Understand method referencing in Java, using the double colon operator to pass methods as arguments to functions. See functional interfaces like function and predicate with parse int and foreach examples.

Demonstrate method referencing in Java by counting vowels with a vowels class and a function of string to integer, using java.util.function.Function and the double colon with umbrella.

Explore streams as an abstraction, with intermediate and terminal operations. Leverage lambdas and method references to filter, map, sort, and collect results from collections, arrays, input outputs, or generators.

Learn how to use Java streams, including intermediate and terminal operations, to filter, map, sort, and print a list of strings with lambdas and method references.

Discover how streams improve readability with Java objects, filtering employees by years of service and names starting with E, using lambdas and method references to reduce code.

Learn how to use Java streams with an employee class, filtering by years of service and by first name starting with E, using lambdas for cleaner, shorter code.

Learn how to replace manual testing with automated unit tests. Construct test cases for add and capitalize methods; explore JUnit, Mockito, and IDEs like IntelliJ and Eclipse.

Learn JUnit fundamentals through simple unit tests using a demo utils add method, covering setup, execute, and assert, Maven dependencies, test packaging, and running tests in an IDE.

Learn how to use JUnit assertions to validate expected and actual values, nulls, and non-nulls, with static imports and concise one-line checks in unit tests.

Download and unzip the starter code, import the 1.0 starting project, and add the Maven JUnit Jupiter dependency in pom.xml with test scope, then reload the Maven project.

Learn how to create a test package and unit tests with JUnit assertions, including equals, not equals, and null checks, and run tests to identify and fix failures.

Explore JUnit unit lifecycle methods, including before each and after each, and before all and after all, with test data setup and resource cleanup and coding examples.

Implement test lifecycle methods using a demo utils test, adding before each and after each for per-test setup and teardown, with before all and after all running once.

Master how JUnit custom display names improve test reports for managers and non-techies. Explore generators—simple, replace underscores, and indicative sentences—at the class level for readable test output.

Learn how to add and manage custom display names for JUnit tests, experiment with display name generators, and apply class-level generators to rename methods with underscores and camel case.

learn how to use JUnit assertions for same and not same object references, and true and false conditions, with practical tests on a demo utils class and is greater logic.

Learn to write JUnit assertions for same and not same object references and for true and false conditions, using demo utils methods as examples.

Demonstrate using JUnit assertions for arrays, iterables, and lines with assert array equals, assert iterable equals, and assert lines match, demonstrating deeply equal comparisons.

Learn JUnit assertions for arrays, iterables, and lines by checking deep equality of a string array and a string list, with demo utils data and passing tests.

Explore JUnit assertions for throws and timeouts, using assertThrows and assertDoesNotThrow with lambdas. Verify negative inputs and timeouts with demo utils class and assertTimeoutPreemptively.

Demonstrates writing JUnit assertions for throws and does not throw in coding part 1, using assertThrows with a lambda to call demoUtils.throwException and verify negative values trigger an exception.

Demonstrates JUnit timeout assertions by testing a method that sleeps for two seconds, asserting a three-second limit, and showing test failure when sleep extends to five seconds.

Learn how to control JUnit test execution order using display name, method name, random order, and order annotations, while understanding the default deterministic ordering and test independence.

Learn to order JUnit tests by method name, display name, and the order annotation, using priorities like 0, 1, 30, and 50, where the lowest value has the highest priority.

Learn to control test execution with conditional annotations, enabling or disabling tests by operating system, environment variables, and system properties, using IntelliJ.

Learn how to use conditional tests in Java with @Disabled and @EnabledOnOs, demonstrating OS-specific execution for Windows, Mac, and Linux, including how to disable tests with reasons.

Learn to run conditional tests in Java using @EnabledIfEnvironmentVariable and @EnabledIfSystemProperty, configuring dev environment checks with environment variables and system properties in IntelliJ run configurations.