Inheritance in OOP (Java)

Inheritance in OOP (Java)

• Inheritance allows a new class (child) to acquire properties and behaviors from an existing class (parent).
• Inheritance offers code reuse and facilitates hierarchical organization.

Key Terminology

• Super Class (Parent Class) is the class being inherited from.
• Sub Class (Child Class) refers to the class that inherits from another.
• In C++ terms, the Parent Class is known as the Base Class, and the Child Class is the Derived Class.
• Java supports Single Inheritance, where each class has only one direct parent.

Method Overriding

• Method overriding involves redefining a method in the child class with the same name and parameters as in the parent class.
• Use of @Override is optional but recommended.
• For overriding, the method signature (parameters) must match, and the return type must be the same or a subclass of the original.
• Access modifiers must be the same or more permissive (e.g., protected to public is allowed).

Method Overloading

• Method overloading uses same method name but different parameter lists (number or type of parameters must differ).
• For overloading, the return type can change
• Access modifier can change, and private methods can be overloaded but are not inherited.

Static Methods and Inheritance

• Static methods are not inherited in the usual way.
• Static methods cannot be overridden, but they can be redefined in the child class.
• Use of super inside a static method is not allowed.

Final Methods and Classes

• Final Class cannot be extended, so there are no child classes.
• Final Method cannot be overridden but can be inherited.

Determining When to Use Inheritance

• Use inheritance if there is an "is-a" relationship, such as "A Dog is an Animal" or "A Car is a Vehicle".
• Avoid inheritance if using "has-a" relationships; use composition instead like, "A Car has an Engine", so use an instance variable of Engine.

The Superclass of All Java Classes

• Every class in Java automatically extends Object.
• Methods from Object like toString(), equals(), and hashCode() are inherited.

Method Hiding

• Method hiding occurs when a static method in a child class has the same signature as a static method in the parent class; the child class hides the parent's method instead of overriding it.

instanceof Operator

• The instanceof operator checks if an object is an instance of a specific class, returning true or false.
• Frequent use of instanceof is usually a sign of bad design.

Multilevel Inheritance

• Multilevel inheritance involves child classes inheriting from parent classes, which may have inherited from their own parents, as in "Animal -> Mammal -> Dog."
• Multilevel inheritance allows for a deeper hierarchy but should be used with caution to avoid complexity.

Abstract Classes

• Abstract classes cannot be instantiated, only extended and they are used as a blueprint for other classes.
• Abstract classes can contain concrete (implemented) methods and abstract methods.
• Abstract methods lack a body and must be implemented by child classes.
• If a class has at least one abstract method, it must be declared as an abstract class.

Abstract Methods

• Abstract methods forces child classes to implement the method.
• It is declared in an abstract class without a body.

Why Use Abstract Methods?

• Abstract methods create a standard, forcing all subclasses to implement required methods and encourages consistency across different subclasses.
• These methods are the opposite of final methods, which cannot be overridden.

Interfaces in Java: Solving the Multiple Inheritance Problem

• Java does not support multiple inheritance with classes.
• The "is-a" issue can be resolved through use of interfaces for multiple inheritence of type.

What is an Interface?

• An interface is not a class but defines what a class should do, not how.
• An interface includes a set of methods a class must implement.
• All interface methods are implicitly public and abstract by default.

Interfaces vs Abstract Classes

Interface Variables and Methods

• All interface methods are implicitly public and abstract (no need to specify).
• All interface variables are implicitly public static final (constants).

Default Methods in Interfaces

• Interfaces normally cannot have method implementations, but Java allows default methods inside interfaces.
• The default keyword allows providing optional behavior.

Implementing an Interface

• If implementing an interface, the implements keyword must be used
• A class can implement multiple interfaces (separate with commas).
• If a class extends another class, write extends first, then implements.

Using instanceof with Interfaces

• The instanceof keyword Checks if an object implements an interface.

The Comparable Interface

• The Comparable<T> Interface is used for sorting objects in collections (ArrayList, LinkedList, etc.).
• Implementation of compareTo() is required.

Returning & Passing Interfaces

• A method can return an interface type to help in flexible design.

Polymorphism in Java

• Polymorphism allows different classes to be treated as instances of the same superclass, promoting flexibility and extensibility of code.
• Methods can be called dynamically at runtime.

Binding (Method Resolution)

• Binding refers to connecting a method call to its actual method definition.
• The two types of binding are: Static Binding (Compile-time) and Dynamic Binding (Runtime).

Static Binding (Early Binding)

• With static binding, method call is resolved at compile-time.
• Method call is used when methods are static, final, or private.

Dynamic Binding (Late Binding)

• Method call is resolved at runtime.
• Method call is used in Method Overriding and the object type determines the method to execute, not the reference type.

Static vs Dynamic Binding

Upcasting

• Upcasting involves converting a child class reference to a parent class reference.
• It hides child-specific methods but still allows overridden methods.
• You can't access child class methods using a parent reference.

Downcasting

• Downcasting involves converting a parent class reference back to a child class reference.
• Downcasting is used when you need access to child-specific methods.
• Downcasting must be done explicitly.

Compile-time vs Runtime Polymorphism

Polymorphism with Interfaces

• An interface can be used to achieve polymorphism.

Polymorphism with Inheritance

• Abstract classes can also be used for polymorphism.

Why Use Upcasting in Practice?

• Java API frequently uses upcasting for flexibility.

Runtime Analysis

• Different solutions exist for a problem, but some are faster than others, this is why one must analyze runtime.
• Performance depends on the Running Time and Space Usage.

Goal of Runtime Analysis

• Goal: Find the fastest solution unless space is a major concern.

Measuring Runtime

• Cannot measure runtime in seconds since different computers have different speeds.
• We need a universal way to compare algorithms.
• Three key scenarios: Best-Case, Worst-Case, and Average-Case.

Big-O Notation (Worst Case)

• O(f(x)) represents the upper bound of an algorithm's growth.
• Example: Searching in an unsorted list; Best case runs in Ω(1), Worst case runs in 0(n).

Ω (Omega) Notation (Best Case)

• Ω(f(x)) represents the lower bound and describes the fastest an algorithm can run.
• Example: Searching an element in an array; Best case runs in Ω(1) and Worst case runs in 0(n).

0 (Theta) Notation (Average Case)

• 0(f(x)) represents the tight bound (both upper and lower).
• 0(f(x) describes how the algorithm performs on average.
• Example: Searching for an element in an unsorted array; Average case runtime runs in 0(n)

Binary Search (0(log n))

• Binary Search is used for in searching sorted arrays.
• Binary search divides the input in half each step 0(log n).
• If array is not sorted, binary search won't work!