OOP Concepts: Polymorphism, Inheritance, and More

• Polymorphism involves a logical unit of code altering its behavior based on circumstances.

Method Overloading

• Method overloading occurs when multiple methods in the same class share a name but accept different parameters.

Method Overriding

• Method overriding is when a child class changes the functionality of a method from its parent class.
• Both overloading and overriding let a method modify its behavior in certain cases.

Inheritance

• Inheritance happens when a class inherits methods, behaviors, and attributes from an existing class, creating a parent-child hierarchy.

Composition

• Composition describes when a class consists of subclasses, representing a 'must-have' relationship.
• Example: A Car class is made up of Wheels subclass.

Aggregation

• Aggregation describes when a class could contain a subclass, indicating a 'may-have' relationship.
• Example: A human can own a car, but a car can exist without a human.

Abstract Class

• An abstract class is not fully defined and cannot be instantiated as an object.
• They hold common traits and behaviors that child classes can use.

Abstract Method

• An abstract method lacks defined functionality and must be overridden in child classes.

Virtual Method

• A virtual method is a method with a default implementation and may be altered/overridden by child classes.

Interface

• An interface is a collection of undefined behaviors that implementers must follow.

Class

• A class defines both attributes and functionality.

Single Responsibility Principle

• According to the Single Responsibility Principle, a class should be responsible for one thing only.
• Example: Instead of "my website is broken", use "my website's button to my shop is broken."

Open-Closed Principle

• The Open-Closed Principle states that once a class or method is complete, it should not require editing.
• Instead, its functionality should be extended by new code; for example, add qualities to a robot so that the robot can be used for another game instead of changing the original robot's code.

Dependency Inversion Principle

• The Dependency Inversion Principle states that implementations of classes should be programmed into interfaces in case the functionality of the class changes.
• Example: Have a big arena for robots to fight. The arena's functionality should not depend on the robot's functionality (the robot should break easier than the arena).

Interface Segregation Principle

• The Interface Segregation Principle states that a class implementing an interface should only be required to use the methods that it needs.
• Interfaces should be designed to do this.
• Example: A normal printer (print) and a fancy printer (print and scan); just because the fancy printer can do more does not mean the normal printer stops working.

Liskov Substitution Principle

• According to the Liskov Substitution Principle, if an object of a given type is replaced with a new object of its subtype, there should be no consequences.
• Example: If a user on Instagram becomes an employee, the admin account should still be able to use Instagram.