What You Will Learn

A zero-to-hero Core Java course taught through live video sessions. You will master Java fundamentals, object-oriented programming, string handling, collections, and exception handling — and be fully interview-ready by the end.

✅ Java Fundamentals ✅ OOP Concepts ✅ Interfaces & Abstract Classes ✅ String Handling ✅ Collections Framework ✅ Exception Handling ✅ Interview Preparation

🚀 Your Learning Journey

From complete beginner to job-ready Java developer — step by step.

1Java Basics
2OOP & Classes
3Interfaces
4Collections
✓Job Ready!
MODULE 1  Introduction to Java & Setup
Java Basics & Environment
  • What is Java and its role in software development
  • JDK vs JRE vs JVM – differences and purpose
  • Writing and running the first Java program
  • Structure of a Java class – class keyword and main method
  • System.out.println() – printing output to the console
  • Packages – organising Java classes
MODULE 2  Data Types & Variables
Primitive Data Types
  • Variables – declaration and assignment
  • Integer types – byte, short, int, long
  • Floating-point types – float, double
  • char – character data type
  • boolean – true and false
  • String – non-primitive type
Type Casting & final
  • final keyword – declaring constants
  • Implicit (widening) type conversion
  • Explicit (narrowing) type casting
MODULE 3  Operators
Types of Operators
  • Arithmetic operators – +, -, *, /, %
  • Increment (++) and decrement (--) operators
  • Relational operators – ==, !=, >, <, >=, <=
  • Logical operators – && (AND), || (OR), ! (NOT)
MODULE 4  Control Flow
Conditional Statements
  • if, else, if-else-if ladder
  • Nested if conditions
  • switch statement – case, default, and break
  • Scanner class – reading user input at runtime
MODULE 5  Loops
Loop Types & Control
  • for loop – syntax, initialisation, condition, update
  • while loop – condition-driven iteration
  • do-while loop – executes at least once
  • break statement – exit a loop early
  • Nested loops – loop inside a loop
Pattern Printing
  • Star (*) patterns using nested loops
  • Number patterns using nested loops
MODULE 6  Arrays
Arrays & Iteration
  • Array declaration, initialisation and zero-based indexing
  • Iterating arrays using a for loop
  • for-each loop – simplified iteration
  • 2D arrays (two-dimensional arrays)
MODULE 7  Methods
Defining & Calling Methods
  • Method declaration and calling
  • Parameters and arguments
  • Return types and return statement
  • Static methods vs instance (non-static) methods
  • Generic (reusable) methods
MODULE 8  OOP – Classes, Objects & Constructors
Classes & Objects
  • Class as a blueprint – instance variables and methods
  • Creating objects using the new keyword
  • Default constructor and parameterised constructor
  • this keyword – referring to the current object
Static & final Members
  • static variables – shared across all objects
  • static methods – called on the class, not an instance
  • final variable, final method, final class
MODULE 9  OOP – Inheritance & Encapsulation
Inheritance
  • extends keyword – child class inheriting from parent
  • super keyword – accessing parent class members
  • Types of inheritance – single, multilevel, hierarchical
Encapsulation & Access Modifiers
  • Access modifiers – public, private, protected
  • Encapsulation – private fields with getter and setter methods
  • Packages and package-level access
  • Method overloading – same method name, different parameters
MODULE 10  OOP – Polymorphism & Type Casting
Polymorphism & Overriding
  • Method overriding – child class redefines parent method
  • Runtime (dynamic) polymorphism
  • Overloading vs overriding – key differences
Type Casting
  • Upcasting – implicit casting from child to parent type
  • Downcasting – explicit casting from parent to child type
MODULE 11  Interfaces & Abstract Classes
Interfaces
  • interface keyword – defining a contract
  • implements keyword – implementing an interface
  • Interface methods are by default public and abstract
  • A class can implement multiple interfaces
Abstract Classes
  • abstract class – cannot be instantiated directly
  • abstract method – must be implemented in subclass
  • Concrete methods inside an abstract class
  • Interface vs abstract class – when to use which
MODULE 12  String Handling
String Class & Methods
  • String is immutable – each operation creates a new object
  • length(), charAt(), indexOf(), substring()
  • String comparison using equals() vs ==
StringBuilder & StringBuffer
  • StringBuilder – mutable, faster, not thread-safe
  • StringBuffer – mutable, thread-safe
  • String vs StringBuilder vs StringBuffer – key differences
MODULE 13  Collections Framework
List
  • ArrayList – dynamic array, allows duplicates, maintains insertion order
  • LinkedList – doubly-linked list, fast insert and delete
  • for-each and Iterator to traverse a List
Set
  • HashSet – no duplicates, no guaranteed order
  • LinkedHashSet – no duplicates, preserves insertion order
  • TreeSet – no duplicates, sorted order
Queue & Legacy Classes
  • Queue – LinkedList used as a Queue (offer, poll, peek)
  • Stack – LIFO structure (push, pop, peek)
  • Vector – legacy thread-safe List
Map
  • HashMap – key-value pairs, no guaranteed order
  • LinkedHashMap – key-value pairs, preserves insertion order
Sorting & Iteration
  • Comparable interface – compareTo() for natural ordering
  • Comparator interface – compare() for custom ordering
  • Iterator – hasNext() and next() for manual traversal
MODULE 14  Exception Handling
Handling Exceptions
  • What is an exception – unexpected event during execution
  • try-catch block – risky code and recovery code
  • finally block – always executes regardless of exception
  • throw keyword – manually throwing an exception
  • Normal termination vs abnormal termination
TOOLS  Tools & Technologies Used
Tool / Technology Purpose Category
Eclipse IDE Writing, compiling and running Java programs IDE
JDK (Java Development Kit) Java compiler, runtime tools and class libraries Runtime
JVM (Java Virtual Machine) Executes Java bytecode on any platform Runtime
Scanner class Reading user input from the console at runtime Utility
Java Collections API Built-in data structures – List, Set, Map, Queue API
PREP  Interview Preparation Tips

📚 Know OOP Cold
Be ready to explain all four OOP pillars — Inheritance, Polymorphism, Encapsulation, Abstraction — with real code examples.

📄 Understand Collections
Know the difference between ArrayList vs LinkedList, HashMap vs LinkedHashMap, and when to use Set over List.

⚡ Practice Exception Handling
Always demonstrate try-catch-finally correctly. Understand the difference between normal and abnormal termination.

🔫 Interface vs Abstract Class
This is one of the most common Java interview questions. Be clear on when to use each and explain the differences confidently.

💡 Comparable vs Comparator
Know when to use each for sorting. Be ready to write compareTo() and compare() implementations from scratch.

🔹 Write Clean Code
Interviewers notice proper naming and well-structured code. Practice writing Java programs daily on LeetCode or HackerRank.