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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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 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.

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.

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.

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.

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.

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 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.

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.

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.

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 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.

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.

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.

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 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.