Java OOP (Object-Oriented Programming)

What you will learn

1. 3.1Classes & Objects

   Model real-world things as Java classes, create objects with new, give them state and behaviour, and manage many objects through references, arrays and null.

   1. Why object-oriented programming?25 min
   2. Write your first class28 min
   3. Create objects with new28 min
   4. State and behaviour: fields and methods30 min
   5. Many objects, references and null35 min
   6. Common mistakes and practice35 min

2. 3.2Constructors

   Constructors give every new object a valid starting state: default and parameterized constructors, the this keyword, overloading, and chaining with this().

   1. What is a constructor?30 min
   2. The default constructor30 min
   3. Constructors with parameters35 min
   4. The this keyword35 min
   5. Constructor overloading30 min
   6. Call one constructor from another with this()35 min
   7. Common mistakes and practice35 min

3. 3.3Encapsulation

   Keep objects correct by hiding their data behind private fields and well-designed public methods that check every change.

   1. Why encapsulation?25 min
   2. private fields and public methods30 min
   3. Getters and setters30 min
   4. Keep objects valid with checks35 min
   5. Read-only fields and computed values35 min
   6. Design methods, not just setters35 min
   7. Common mistakes and practice35 min

4. 3.4Static & Final

   Shared class members, static methods and blocks, and values that never change: when to use static, final and static final.

   1. Instance members and static members25 min
   2. Static variables28 min
   3. Static methods and why main is static32 min
   4. Static blocks28 min
   5. final variables and constants32 min
   6. Common mistakes and practice35 min

5. 3.5Inheritance

   Reuse code with parent and child classes: extends, protected, multilevel and hierarchical families, super(), constructor order, final methods and classes, and your own exception classes.

   1. Why inheritance?25 min
   2. extends: parent and child classes30 min
   3. Multilevel and hierarchical inheritance30 min
   4. Why a class can extend only one class25 min
   5. Call the parent constructor with super()30 min
   6. Constructor order in inheritance30 min
   7. final methods and final classes25 min
   8. Your own exception classes30 min
   9. Common mistakes and practice35 min

6. 3.6Polymorphism

   One method call, many behaviours: override methods safely with @Override and super, use parent references and arrays, and trace how Java picks the method at run time.

   1. What is polymorphism?22 min
   2. Method overriding32 min
   3. The @Override annotation25 min
   4. Call the parent's version with super.method()28 min
   5. Overloading vs overriding26 min
   6. Parent reference, child object (upcasting)34 min
   7. Dynamic method dispatch35 min
   8. Common mistakes and practice35 min

7. 3.7Abstraction & Interfaces

   Hide how and show what: abstract classes, interfaces, default and static methods, choosing between them, and a first look at lambdas.

   1. Why abstraction?25 min
   2. Abstract classes and abstract methods35 min
   3. Constructors, fields and normal methods in abstract classes30 min
   4. Interfaces: a contract30 min
   5. Implement several interfaces30 min
   6. default, static and private methods in interfaces40 min
   7. Abstract class or interface? How to choose30 min
   8. Functional interfaces and lambdas: a first look35 min
   9. Common mistakes and practice40 min

8. 3.8Enums

   A fixed set of named values: why enums beat int and String constants, built-in methods, switch, constants with data and behaviour, interfaces and state machines.

   1. Why enums?25 min
   2. Enum basics40 min
   3. Enums with fields, constructors and methods40 min
   4. Enums with behaviour40 min
   5. Common mistakes and practice45 min

9. 3.9Composition & Relationships

   How Java classes relate: IS-A vs HAS-A, association, aggregation, composition and delegation, and how to choose and design them from a real problem.

   1. HAS-A vs IS-A30 min
   2. Objects inside objects30 min
   3. Association: objects that work together35 min
   4. Aggregation: a whole that shares its parts30 min
   5. Composition: a whole that owns its parts35 min
   6. Delegation: let another object do the work35 min
   7. Composition vs inheritance: choosing35 min
   8. Design classes from a real problem40 min
   9. Common mistakes and practice40 min

10. 3.10Object Class & Equality

    Every Java class inherits from Object: print objects with toString(), compare them correctly with == and equals(), and keep hashCode() consistent so equal objects behave as equal everywhere.

    1. The Object class: every class's parent25 min
    2. toString(): print objects nicely32 min
    3. == compares references30 min
    4. Write your own equals()40 min
    5. hashCode() and the equals/hashCode contract40 min
    6. Common mistakes and practice35 min

11. 3.11Copying Objects

    When b = a shares an object instead of copying it, and how to make real copies: copy constructors and copy methods, shallow vs deep copies, and clone() with Cloneable.

    1. Assignment is not a copy35 min
    2. Copy constructors and copy methods35 min
    3. Shallow copy vs deep copy40 min
    4. clone() and Cloneable40 min
    5. Common mistakes and practice40 min

12. 3.12References, Casting & Immutability

    How Java decides between the reference type and the object type, how to cast safely with instanceof and pattern matching, and how to build immutable classes, records and nested classes.

    1. Reference type vs object type30 min
    2. Downcasting and ClassCastException30 min
    3. instanceof and pattern matching30 min
    4. Field hiding vs method overriding30 min
    5. Immutable objects30 min
    6. Design your own immutable class35 min
    7. Records: short immutable data classes30 min
    8. Nested classes: static nested, inner and anonymous35 min
    9. Common mistakes and practice35 min

13. 3.13OOP Mastery & Code Tracing

    Pull all of OOP together: read and trace unfamiliar programs, spot and fix design problems and bugs, design classes from requirements, apply SOLID, and build a multi-class application, ready for placement interviews and coding rounds.

    1. Read an unfamiliar OOP program30 min
    2. Trace object creation and constructors35 min
    3. Trace inheritance and polymorphism35 min
    4. Spot OOP design problems35 min
    5. Find and fix OOP bugs35 min
    6. Design classes from requirements35 min
    7. SOLID principles in plain words35 min
    8. Build a multi-class application35 min

14. 3.14Java OOP Mini Projects

    Nine GitHub-ready console projects, one for each big OOP idea: classes, encapsulation, inheritance, polymorphism, interfaces, composition, equality, immutability, and a final payroll capstone.

    1. Student Profile & Marks Report60 min
    2. Bank Account Manager60 min
    3. Employee Role Hierarchy60 min
    4. Payment Processing Engine60 min
    5. Multi-Channel Notification Service75 min
    6. Build a Library Management System75 min
    7. Build a Product & Customer Catalogue60 min
    8. Build an Immutable Order & Cart70 min
    9. Capstone: Employee Management & Payroll90 min