Summary of Week 4 | Concepts Summary

Summary of "Week 4 | Concepts Summary" Video

This video lecture covers key object-oriented programming concepts in Java, focusing primarily on Abstract Classes, Interfaces, Inner Classes, controlled interaction with objects, multiple inheritance using Interfaces, and briefly touches on iterators and callbacks.

Main Ideas and Concepts

1. Abstract Classes and Abstract Methods

Abstract class: A class declared with the keyword abstract that can contain abstract methods (methods without implementation) and regular methods/variables.
Abstract method: Declared with abstract keyword, no body (ends with semicolon); subclasses must provide implementation.
Rules:
- If a class contains any abstract method, the class must be declared abstract.
- Abstract Classes can have constructors, instance variables, and concrete methods.
- Cannot instantiate Abstract Classes directly (no new AbstractClass()).
- Can create reference variables of abstract class type and assign objects of subclasses.
Inheritance and Implementation:
- Subclasses extending an abstract class must implement all abstract methods or be declared abstract themselves.
- Abstract class acts as a blueprint or template enforcing subclasses to implement specific behavior.
Example: Shape abstract class with abstract method draw(). Subclasses Circle, Square, and Rectangle implement draw().

2. Interfaces

Interface is similar to an abstract class but with some differences and additional features.
Interface methods:
- By default, all methods are public abstract (no body).
- Can have default methods (with implementation, declared using default keyword).
- Can have static methods with implementation.
Variables in interface are implicitly public static final and must be initialized.
Cannot instantiate Interfaces directly but can create reference variables of interface type.
Classes implement Interfaces using the implements keyword.
Interfaces support multiple inheritance (a class can implement multiple Interfaces).
Conflict resolution:
- If multiple Interfaces have default methods with the same signature, the implementing class must override the method to resolve ambiguity.
- The overriding method can call the parent interface’s default method using InterfaceName.super.methodName().
Interfaces are often used to define a public API or contract for classes.

3. Differences Between Abstract Class and Interface

Abstract Classes are used when classes share common behavior and state (some implementation).
Interfaces are used for multiple inheritance and to define contracts without implementation (though default/static methods are exceptions).
Java does not allow multiple inheritance of classes but allows multiple interface implementation.

4. Inner Classes (Private Inner Classes)

A private inner class is a class defined inside another class and marked private.
Private Inner Classes cannot be instantiated or accessed outside the outer class.
Useful for encapsulation and hiding implementation details.
Example: Employee class contains a private inner class Address.
Outer class can instantiate and manipulate the inner class.
Inner Classes can have their own methods (e.g., toString()) and constructors.
Used in data structures like linked lists (node class as private inner class).

5. Controlled Interaction Through Objects (Combining Private Classes and Interfaces)

Combining private Inner Classes with Interfaces allows controlled access to internal details.
Private inner class implements a public interface exposing only selected methods.
Outer class returns the private inner class object as an interface reference, restricting access to only interface methods.
Example: University class has a private inner class College implementing a public interface Academics.
This pattern enforces encapsulation and controlled interaction with object state.
Real-life analogy: Railway booking system where access to train status is controlled via login and interface methods.

6. Multiple Inheritance Using Interfaces

Java does not support multiple inheritance with classes but allows a class to implement multiple Interfaces.
When two Interfaces have default methods with the same signature, the implementing class must override the method to resolve ambiguity.
To call a specific interface’s default method, use InterfaceName.super.methodName().
Example: Copier class implements Interfaces Scanner and Printer, both having default method f(). Copier overrides f() and can selectively call parent interface methods.

7. Additional Notes on Abstract Classes and Interfaces

Abstract Classes can have concrete and abstract methods; Interfaces primarily abstract but can have default/static methods.
Reference variables of Abstract Classes/Interfaces can point to subclass/implementing class objects.
Use Abstract Classes when shared code and state are involved.
Use Interfaces for multiple inheritance and defining contracts.