OOP: Objects, Classes, Encapsulation & Polymorphism

• An object in Object-Oriented Programming (OOP) is a concrete instance of a class.

Classes in OOP

• A class in OOP is a structure or template used to create objects, defining the characteristics and behaviors of those objects.

Encapsulation

• Encapsulation hides the internal details of an object, protecting the data by concealing the internal workings.

Class Definition

• The keyword 'class' is commonly used to define a new class in many programming languages.

Constructor

• A constructor is a method that executes automatically when an object is created.

Method

• A method in OOP is a function defined within a class.

Inheritance

• The reserved word 'extends' typically indicates inheritance in languages like Java or Python, signifying that a class inherits from another.

Polymorphism

• Polymorphism means "having multiple forms," allowing different classes to use the same method in distinct ways.

Benefits of OOP

• Code reusability, modularity, and better organization are all benefits of OOP.
• A difficulty in maintaining code is NOT a benefit of OOP.

Method Overloading

• Method overloading involves creating methods with the same name but different parameters, allowing various methods with the same name but distinct signatures (parameters).

Attribute

• An attribute is a variable within a class, belonging to a class or object.

Inheritance Objectives

• Inheritance promotes code reuse and facilitates extension of written code.

Constructor Function

• A constructor is a function that initializes objects. When a constructor isn't defined in a class, the language creates a default constructor.

Instantiation

• Instantiation is the process of creating an object based on a class.

Destructor

• A destructor is a type of method that destroys an object. It executes when an object is eliminated.

Encapsulation Advantage

• The main advantage of encapsulation is protecting the internal data of an object.

Overriding

• Overriding involves redefining an inherited method by changing the functionality of an inherited method in a subclass.

Abstract Methods

• 'Abstract' signifies that a method should be implemented in a subclass.

Exception Handling

• The 'try' block attempts to execute a block of code that might fail which may throw errors.
• The 'catch' block captures and handles exceptions thrown in the 'try' block.
• An uncaught exception can halt the program.
• The keyword 'throw' is used to manually raise an exception.
• An exception is an error detected during runtime. Exceptions separate the error flow from the main flow.

Exception Grouping

• Multiple exceptions in the same error block can be grouped by using multiple 'catch' statements.

Finally

• The 'finally' block always executes, whether an error occurs or not. 'Finally' is ideal for releasing resources, regardless of error.

Exception Logic

• If no error occurs within the 'try' block, the program follows its normal flow.

Throw Keyword

• The keyword 'throw' ensures that an exception is passed to a higher level if not caught.

Uncaught Errors

• If an error occurs outside a 'try-catch' block, it leads to unhandled errors, causing an uncontrolled exception.

Custom Exceptions

• A custom exception is defined, they typically extend the Exception class.

Finally and Exception Handling

• The 'finally' clause in exception handling guarantees the execution of a block.

Capturing Exceptions

• Capturing an exception means identifying and handling an error in a controlled manner, preventing the program from stopping. The presence of Try-catch enables error handling without stopping the program.

Try-Catch

• The try-catch mechanism handles runtime errors.

Handling Uncaught Exceptions

• Not managing exceptions can lead to unexpected failures.

Code Reusability

• Inheritance is a component of OOP that is closely related to code reusability, allowing the re-use of existing code.

Polymorphism

• Polymorphism allows two classes to use methods with the same name.

Post Exception Capture

• After capturing an exception, it should be handled properly to correct or notify about the problem.

Abstract Classes

• The keyword 'abstract' indicates that a class cannot be instantiated.

Exception vs Error Codes

• Exceptions separate normal logic from error logic

Instantiation

• Instantiation involves creating an object from a class.

Exception Types

• When an exception is thrown inside a 'try' block, the corresponding 'catch' block executes.
• If a 'catch' doesn't capture the correct exception, another 'catch' will try to capture it.

Abstraction

• Abstraction means showing only relevant information and hiding unnecessary details from the user. Displaying only relevant information.

Custom Exceptions

• Custom exceptions are defined by creating a new class that inherits from the Exception class.

Private Attributes

• The keyword 'private' defines a private attribute and limits access to the attribute within the class only.

Abstract classes

• Abstract classes cannot be instantiated directly.

Exception Handling Robustness

• A program is more resilient when exceptions are handled.

Constructors

• Overloading a constructor means having multiple constructors with the same name but different parameters.

Exception Propogation

• If an exception cannot be handled where it occurs, it should be allowed to propagate.