<<< Concepts of OOP

1. Concepts of OOP: Object-Oriented Programming (OOP) is a powerful and widely used programming paradigm that allows developers to model real-world entities and their interactions in software. OOP promotes the use of objects, classes, and encapsulation, providing a structured and modular approach to building complex applications e.g. 

1. Class: Classes are blueprints or templates for creating objects, defining their attributes (properties) and behaviors (methods) e.g.

1. Fields

2. Methods

1. A method is like a function to expose the behavior of an object

2. Advantage: e.g. Code Reusability & Code Optimization

Note: Instance Variable is created inside the class but outside the method

3. Constructors

1. Constructor is called when an instance of the class is created 

2. Constructor is a special type of method that is used to initialize the object

3. Every time an object is created using the "new()" keyword & at least a constructor is called

4. Constructor Overloading:

1. A technique of having more than a constructor with different parameter lists

2. Each constructor performs a different task

5. Two types of constructors: e.g.

1. No-arg constructor or Default

2. Parameterized constructor

6. Rules to create Constructor: e.g.

1. Constructor name must be the same as its class name

2. Constructor must have no explicit return type

3. Constructor can't be abstract, static, final, & synchronized 

4. Destructor

1. It can be used once at a time in a class

2. It's a special method that gets called automatically ASAP after the life cycle of an object is finished

3. A destructor is called to de-allocate and free memory

4. Destructors also known as finalizers are non-deterministic

5. A destructor will have exact same name as the class prefixed with a tilde (~) e.g. ~Vehicle()

6. It can neither return a value nor can it take any parameters

5. Blocks

6. Nested class & Interface

Note: Class is a collection of objects

2. Object: Objects are instances of classes, representing individual entities with specific characteristics and actions

1. Object is an instance of a class

2. Object is a real-world run-time entity

3. It has state & behavior

1. State: represents data (value) of an object

2. Behavior: represents the behavior (functionality) of an object: e.g. deposit, withdraw

3. Inheritance>>>: Inheritance enables a class (subclass) to inherit attributes and methods from another class (superclass)

1. Inheritance represents the IS-A relationship, also known as parent-child relationship, and promotes code reusability

2. Types of Inheritance: e.g.

1. Single Inheritance

2. Multiple Inheritance (Through Interface)

3. Multilevel Inheritance

4. Hierarchical Inheritance

5. Hybrid Inheritance (Through Interface)

3. Why use inheritance? 

1. For Method Overriding (so runtime polymorphism can be achieved)

2. For Code Reusability

4. Polymorphism>>>: It allows objects of different classes to be treated as objects of a common superclass through method overriding and method overloading. It enhances flexibility and enables dynamic behavior based on the actual type of the object

1. When one task is performed in different ways i.e. known as polymorphism

2. Features:

1. Method Overloading (compile-time polymorphism)

1. Within a class: Multiple methods having the same name but different parameters

2. Advantage: Increases the readability of the program

3. Different ways to overload:

1. By changing the number of arguments

2. By changing the data type

2. Method Overriding (runtime polymorphism)

1. Subclass (child class) has the same method as declared in the parent class

2. Rules for method overriding: e.g.

1. Method must have the same name as in the parent class

2. Method must have the same parameter as in the parent class

3. Must be IS-A relationship (inheritance)

5. Abstraction>>>: Abstraction focuses on defining the essential features of an object while hiding unnecessary implementation details. Abstract classes and interfaces provide foundations for defining common behavior across multiple classes.

1. Abstract Class: Abstract class is a restricted class that cannot be used to create objects (to access it, it must be inherited from another class).

2. Abstract Method: Abstract method can only be used in an abstract class, and it does not have a body. The body is provided by the derived class (inherited from).

3. Hiding internal details and showing functionality

4. Abstraction is achieved by using abstract class and interface

1. Interface

1. Is a blueprint of a class

2. It has static constants and abstract methods

3. It is used to achieve multiple inheritance e.g. represents IS-A relationship

4. It can be used to achieve loose coupling

5. Interface fields are public, static, and final by default, and methods are public and abstract

6. Marker or tagged interface

1. Within an interface that has no member 

1. e.g. Serializable, Cloneable, Remote, etc.

2. Used to provide essential information to JVM

7. Abstract class achieves partial abstraction (0 to 100%) whereas Interface achieves full abstraction (100%)

6. Encapsulation>>>: Encapsulation is the process of bundling data (attributes) and methods that operate on the data within a class, hiding the internal details from outside interference

1. Binding (or wrapping) code and data together into a single unit e.g. known as encapsulation

2. Access modifiers (public, private, protected) control the visibility of class members, enforcing data protection and providing a well-defined interface for interactions

7. Association and Aggregation

1. Association represents a relationship between two or more classes, showing how they are connected

2. Aggregation is a special form of association, where one class contains another class as a part of relationship

8. Composition

1. Composition is a strong form of aggregation where the lifetime of the contained object is tied to the container

2. It allows building complex structures by combining multiple objects

9. Design Patterns

1. Design patterns are reusable solutions to common programming problems, facilitating software design and development

2. e.g. Singleton, Factory, Observer, and Strategy patterns

1. Singleton Pattern: Ensures that a class has only one instance and provides a global point of access to it. Click >>>

2. Factory Pattern: Defines an interface for creating an object but lets subclasses alter the type of objects that will be created. Click >>>

3. Observer Pattern: Defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically. Click >>>

4. Facade Pattern: Provides a simplified interface to a set of interfaces in a subsystem, making it easier to use. Click >>>

5. Strategy Pattern: Defines a family of algorithms, encapsulates each one, and makes them interchangeable. It lets the algorithm vary independently from clients that use it. Click >>> 

10. SOLID Principles and OOP

1. The SOLID principles (Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion) complement OOP, guiding developers in writing maintainable and scalable code

11. Conclusion

1. Object-Oriented Programming provides a structured and efficient approach to software development, allowing developers to create modular, maintainable, and flexible applications. 

2. Understanding the core concepts of OOP empowers developers to design elegant solutions and build robust software systems. 

3. Embracing OOP principles leads to higher code quality, better collaboration, and enhanced software development experiences.

Note: Object Oriented Programming (OOP) is easier than Procedure-Oriented Programming (POP)

#Programming #OOP #CodeAnalysis #Concepts #AbdurRahimRatulAliKhan #ARRAK

>>>