Java Developer & Placement Programme

After this stage: I can write Java programs, structure classes, use collections and keep my code on GitHub.

1. Section 01LiveJava Basics

   Variables, operators, input and output, conditions, loops, methods, arrays, strings and exceptions, ending with mini projects.

   1. 1.1Getting Started

      1. What is Java?What is Java · Where Java is used · Compiler, bytecode and JVM · Write once, run anywhere
      2. JDK, JRE and JVMWhat the JVM, JRE and JDK do · A kitchen picture · How they fit together · Which one to install
      3. Install Java (JDK) on your computerOfficial Oracle download · Windows and macOS steps · Check with java -version · Fix PATH
      4. Set up VS Code for JavaInstall VS Code · Extension Pack for Java · Create a Java project · Run and see output
      5. Set up IntelliJ IDEA for JavaInstall IntelliJ IDEA · New Java project and JDK · psvm and sout · Run and see output
      6. Set up Eclipse for JavaInstall Eclipse · New Java project · Class with main · Run and see output
      7. Your first Java programParts of a program · File name rule · Run in an IDE or with javac and java · Common mistakes

   2. 1.2Variables & Data Types

      1. What is a variable?What a variable is · Create a variable · Print and update · Naming rules and camelCase
      2. Data types in JavaWhat a data type is · The 8 primitive types · String is a class · Pick the right type
      3. Whole numbers: int and longint for everyday numbers · long and the L suffix · byte and short · Ranges
      4. Decimal numbers: double and floatdouble, the default · float and the f suffix · Decimals are not always exact · A note about money
      5. char and booleanchar: one character · Single vs double quotes · boolean: true or false · Good boolean names
      6. Text with StringWhat a String is · Joining with + · Numbers and + · length()
      7. Type conversion and castingWidening: automatic · Narrowing: cast with (type) · Decimals are cut off · int / int division
      8. Constants with finalWhat a constant is · The final keyword · Changing a final is an error · UPPER_CASE names
      9. Common mistakes and practiceUsing a variable without a value · Quotes and suffixes · Overflow · Mixed practice

   3. 1.3Operators

      1. Arithmetic operatorsWhat an operator and an operand are · Use +, -, * and / · int division and double division · Find a remainder with %
      2. Assignment and compound assignmentHow = stores a value · The right side runs first · Use +=, -=, *=, /= and %= · Use += with a String
      3. Increment and decrement: ++ and --Add 1 with ++ · Take away 1 with -- · Prefix and postfix · Which value is used in the same line
      4. Comparison operatorsUse the six comparison operators · Store a comparison in a boolean · Tell = from == · Compare text with equals()
      5. Logical operators: &&, || and !AND with && · OR with || · NOT with ! · Check a range · Short-circuit evaluation
      6. The ternary operator ?:The three parts of ?: · Pick one of two values · Both values must fit the variable
      7. Operator precedence and parenthesesThe order of operators · Left to right for the same level · Use brackets · + with text and numbers
      8. Common mistakes and practiceFix = vs == · Fix int division and / by zero · Fix missing brackets with text · Practise all operators

   4. 1.4Input & Output

      1. Printing with println and printUse println and print · Print special characters with escape sequences · Join text and values with + · Use brackets to add numbers inside a message
      2. Formatted output with printfPrint values with printf · Use %d, %.2f, %s and %n · Round decimals and print a % sign · Build a formatted String with String.format
      3. Reading input with ScannerImport and create a Scanner · Show a prompt before reading · Read text with nextLine() · Read a whole number with nextInt()
      4. Reading numbers, words and charactersPick the right Scanner method for each type · Read decimals with nextDouble() · Read several values from one line · Read one character
      5. next() vs nextLine() and the Enter keyChoose between next() and nextLine() · Explain the leftover Enter after nextInt() · Fix it with an extra nextLine() · Read text before numbers
      6. Common input errorsExplain InputMismatchException · Fix a missing Scanner import · Write clear prompts · Close the Scanner at the right place
      7. Mini programs and practicePlan a small console program · Combine Scanner input with printf output · Pick the right Scanner method · Avoid the common input and output mistakes

   5. 1.5Conditional Statements

      1. The if statementWrite an if statement · Use a comparison or boolean as the condition · Know which lines are inside the block
      2. if-else: choose one of two pathsWrite an if-else statement · Know that exactly one block runs · Choose between if-else and ?:
      3. The else-if ladderWrite an else-if ladder · Put the checks in the right order · Use a final else
      4. Combine conditions with && and ||Use && and || inside an if · Check that a value is in a range · Use brackets when mixing && and ||
      5. Nested ifWrite an if inside another if · Match each else to its if · Choose between nesting and &&
      6. The switch statementWrite a switch with case, break and default · Explain fall-through · Switch on int, char and String values
      7. switch with arrows (->)Write arrow cases with -> · Store the result of a switch expression · Cover every value with default
      8. Common mistakes and practiceSpot and fix common condition bugs · Choose between if, else-if and switch · Write small programs with conditions

   6. 1.6Loops

      1. Why loops?Explain what a loop is · Name the three parts of a loop · Explain what an iteration is · Name the three loops in Java
      2. The for loopWrite a for loop with start, condition and update · Explain the order in which a for loop runs · Count up, count down and count in steps · Print a multiplication table with a loop
      3. Tracing a loop: totals and countsTrace a loop with a trace table · Keep a running total in a loop · Count items with a counter · Find a product such as a factorial
      4. while and do-while loopsWrite a while loop with a start, condition and update · Choose between for and while · Write a do-while loop · Explain why do-while runs at least once
      5. break and continueStop a loop early with break · Skip a round with continue · Trace a loop that uses break and continue · Avoid the continue trap in a while loop
      6. Nested loops and star patternsExplain how a nested loop runs · Print rows and columns with print and println · Print square and triangle star patterns · Print number patterns and a multiplication grid
      7. Common mistakes and practiceChoose between for, while and do-while · Fix off-by-one mistakes · Find and fix infinite loops · Spot a semicolon after for and a changed loop variable

   7. 1.7Methods

      1. Why use methods?Explain what a method is · Explain why methods avoid repeated code · Recognise methods you already use, like println
      2. Define and call a methodWrite a method with static void · Call a method from main · Trace the order in which methods run · Name methods in camelCase
      3. Parameters and argumentsWrite a method with one or more parameters · Pass arguments in the right order · Explain the difference between a parameter and an argument
      4. Return a value from a methodWrite a method with a return type and return · Store and use a returned value · Choose between void and a return type · Fix missing return statement
      5. Local variables and scopeExplain what a local variable is · Find the scope of a variable · Explain why each call starts with fresh variables · Describe the call stack in simple words
      6. Pass-by-value: a method gets a copyExplain pass-by-value for primitive types · Predict that a parameter change does not change the caller · Return a changed value and store it
      7. Method overloadingWrite overloaded methods · Predict which overloaded method Java calls · Explain why only the return type cannot differ
      8. Recursion: a method that calls itselfExplain base case and recursive call · Trace a small recursive method · Write countdown, factorial and sum with recursion
      9. Common mistakes and practiceFind and fix common method mistakes · Choose void or a return type · Write small programs that combine several methods

   8. 1.8Arrays

      1. What is an array?Explain what an array is · Explain elements and indexes, starting from 0 · Read one element with its index · Explain why an array has one type and a fixed size
      2. Creating an arrayDeclare an array variable · Create an array with values in { } · Create an array with a size using new · Know the default values of a new array
      3. Reading and changing array elementsRead and change one element with its index · Get the size of an array with length · Get the last element with length - 1 · Explain ArrayIndexOutOfBoundsException
      4. Looping through an arrayVisit every element with a for loop · Use i < length to stay inside the array · Loop through an array backwards · Fill an array with a loop and with Scanner input
      5. The for-each loopWrite a for-each loop over an array · Choose between for-each and an index loop · Explain why for-each cannot change the array
      6. Sum, average, largest and searchFind the total and average of an array · Find the largest and smallest element · Count the elements that match a condition · Search an array for a value
      7. Arrays and methodsPass an array to a method · Return an array from a method · Explain that an array variable holds a reference · Make a real copy of an array
      8. 2D arrays: rows and columnsCreate a 2D array with a size or with values · Read and change an element with a row and a column index · Get the number of rows and columns · Visit every element with nested loops
      9. The Arrays class: print, sort and comparePrint an array with Arrays.toString · Sort an array with Arrays.sort · Compare two arrays with Arrays.equals · Fill and copy an array with Arrays.fill and Arrays.copyOf
      10. Common mistakes and practiceFind and fix index out of bounds and off-by-one mistakes · Print arrays correctly · Avoid wrong starting values for max and min · Solve mixed array problems

   9. 1.9Strings

      1. String recap: characters and index positionsRecall String literals, + and length() · Find the index of any character in a String · Read one character with charAt() · Check for an empty String with isEmpty()
      2. Search in a String: indexOf, contains, startsWithFind the position of a character or word with indexOf() · Understand that -1 means "not found" · Use lastIndexOf() to search from the end · Check text with contains(), startsWith() and endsWith()
      3. Cut out part of a String with substring()Use substring(start, end) and remember the end is not included · Use substring(start) to take the rest of a String · Combine indexOf() and substring() to split an email or a name · Avoid StringIndexOutOfBoundsException with substring()
      4. Change case, trim and replace (Strings never change)Explain what immutable means for a String · Store the result of a String method · Change case with toUpperCase() and toLowerCase() · Remove extra spaces with trim() and strip(), and check isBlank() · Replace text with replace() and repeat text with repeat()
      5. Compare Strings: equals() and compareTo()Compare text with equals() and equalsIgnoreCase() · Explain why == can give false for the same text · Know what the String pool is · Put two Strings in dictionary order with compareTo()
      6. Loop through the characters of a StringLoop over a String with charAt(i) · Compare a char with == and single quotes · Use Character.isDigit(), isLetter(), isUpperCase() and toLowerCase() · Use toCharArray() with a for-each loop
      7. Split, join and turn text into numbersSplit a String into an array with split() · Split on one or more spaces with split("\\s+") · Join parts with String.join() · Turn text into numbers with Integer.parseInt() and Double.parseDouble()
      8. Build and change text with StringBuilderCreate a StringBuilder and add text with append() · Change text with insert(), reverse(), deleteCharAt() and setCharAt() · Turn a StringBuilder into a String with toString() · Explain why StringBuilder is faster than + in a loop
      9. Common mistakes and practiceSpot and fix == on Strings and unstored String results · Avoid index errors with charAt(), substring() and indexOf() · Avoid the char + char surprise · Solve small String programs: palindrome, word count, initials, reverse words

   10. 1.10Exception Basics

       1. What is an exception?Explain what an exception is · Tell a compile error from an exception · Read a stack trace: name, message and line number
       2. Common exceptions you will seeName the common runtime exceptions · Say what causes each one · Prevent them with simple checks
       3. Handle an exception with try and catchWrite a try-catch block · Know which lines run and which are skipped · Print the exception message with getMessage()
       4. Multiple catch blocksWrite a try with several catch blocks · Order catch blocks from specific to general · Catch two exception types in one block with |
       5. The finally blockWrite try-catch-finally · Know when finally runs · Close a Scanner in finally
       6. throw and throwsThrow an exception with throw · Tell checked and unchecked exceptions apart · Declare a checked exception with throws
       7. Keep asking until the input is validLoop until the user types a valid number · Clear bad input with nextLine() · Read a line and convert it with parseInt · Combine a number check and a range check
       8. Common mistakes and practiceAvoid empty catch blocks and silent errors · Catch specific exceptions instead of Exception everywhere · Choose between an if check and try-catch · Solve mixed exception problems

   11. 1.11Packages, Imports & Access Control

       1. Why do we need packages?Explain what a Java package is · Explain why packages are used · Read and write a full class name · Name the packages of String, Math, Scanner and Arrays
       2. Create your own packageWrite a package statement · Save a class in the folder that matches its package · Compile with javac -d and run with the full class name · Create a package in an IDE
       3. Use classes from other packages with importUse a class from another package by full name or import · Choose between a single-class import and a wildcard import · Know which classes need no import · Fix missing imports and name clashes
       4. Access modifiers: public, private and defaultName Java's four access levels and who can use each · Hide a field with private and expose public methods · Use default (package) access · Read access compile errors
       5. Build an app with two packagesName packages the standard way · Split a small app into packages by topic · Choose public and private for each member · Compile and run an app with several packages
       6. Common mistakes and practiceFix package line and run command mistakes · Fix missing, wrong and clashing imports · Fix private and default access errors · Solve mixed package and access problems

   12. 1.12Java Basics Mini Projects

       1. Build a simple calculatorBuild a menu loop with Scanner input · Use a switch expression inside a method · Format results with printf · Push a Java project to GitHub
       2. Build a number guessing gamePick random numbers with Random · Control a loop with two conditions · Use continue and do-while · Push a Java project to GitHub
       3. Build a student marks reportStore related data in parallel arrays · Write methods that take arrays · Validate input with a loop · Print aligned tables with printf
       4. Build a text analyzerSplit text into words · Loop over the characters of a String · Build and reverse text with StringBuilder · Check for palindromes
       5. Build an ATM simulatorPass values into methods and return the new value · Validate input with try/catch · Combine loops, switch and methods · Push a Java project to GitHub

   Open Java Basics in the live course

2. Section 02LiveGit, GitHub & Developer Setup

3. Section 03LiveJava OOP

4. Section 04LiveJava Collections & Generics

After this stage: I can approach unfamiliar coding questions, choose the right algorithm and solve problems within a time limit.

1. Section 05LiveProblem Solving & Coding Patterns

2. Section 06LiveData Structures & Algorithms in Java

3. Section 07Coming soonCoding Challenges & Timed Assessments

After this stage: I can use modern Java, work with files, write safe concurrent code and explain how Java runs my program.

1. Section 08Coming soonStreams & Modern Java

2. Section 09Coming soonFiles, I/O & Robust Error Handling

3. Section 10Coming soonMultithreading & Concurrency

4. Section 11Coming soonJVM Internals & Memory Management

After this stage: I can build a database-backed Java application with REST APIs and secure sign-in.

1. Section 12Coming soonSQL & Database Design

2. Section 13Coming soonJDBC & Database Connectivity

3. Section 14Coming soonWeb Fundamentals, HTTP & REST APIs

4. Section 15Coming soonSpring Framework & Spring Boot

5. Section 16Coming soonSpring Data JPA & Hibernate

6. Section 17Coming soonSpring Security & Authentication

After this stage: I can develop, test, deploy, document and explain a working Java backend project.

1. Section 18Coming soonTesting, Debugging & Code Quality

2. Section 19Coming soonDesign Patterns & SOLID in Practice

3. Section 20Coming soonDocker, Deployment & CI/CD Basics

4. Section 21Coming soonBackend Architecture & System Design Fundamentals

5. Section 22Coming soonReal-World Java Projects

After this stage: I can attempt coding assessments, answer technical questions and discuss my projects in interviews.

1. Section 23Coming soonJava Technical Interview Preparation

2. Section 24Coming soonPlacement Assessments & Career Preparation