Fundamental Concepts of OOP

[jimin-kiim]

• ADT, Class and Object
• Encapsulation, Information Hiding (w. interface and implementation)
• Inheritance
• Polymorphism
• Data Abstraction

[jimin-kiim]

ADT(Abstract Data Type)

• a type that combines data and the procedures

in OOP

Class

• is used for defining ADT
  • data: state, attributes, member variables
  • procedures: behaviors, methods, member functions

Object

• is an instance of class
• when the objects are created, different memory space and address are assigned to each object

• objects created by the same class share the class's methods

  💡 thinking in terms of objects and classes is much easier for humans

[jimin-kiim]

Object

• data + operations
• interface + implementation
  • interface : public operations
  • implementation : internal data, internal operations

Encapsulation, Information Hiding

• implementation is encapsulated by the interface and the only way to get to the implementation legally is through the interface.
• information hiding
  • internal data of an object can be modified only through an interface
• prevents accidental damage by separating the client and the implementor

Benefits of data encapsulation

• protection of implementation(safety) :
  • clients cannot directly access encapsulated data (internal data of an object can be modified only through the interfaces)
• readability(understandability) :
  • clients of interface doesn't need to know any knowledge as to how the functions that describe the interface use encapsulated information
• implementation independence :
  • A change in implementation should not affect the interface seen by the clients of a class.
  • An encapsulated implementation provides the implementor freedom to change it without affecting the interface.
  • "how the clients use the interface is independent of the implementation"

protection keywords for encapsulation

• private
  • accessible only within the class definition
  • not accessible in the child class
  • but memory is still found in the child class
• public
  • accessible anywhere
• protected
  • accessible within the class definition
  • accessible in the definition of child class
  • less encapsulation
  • use only when it is really necessary

[jimin-kiim]

• the most basic philosophy of OOP  
  • organizing the system as the interaction of loosely coupled software components.
  • organizing the classes into a hierarchical structure based on the concept of inheritance

    Inheritance

    Inheritance : Hierarchical Structure

• subclass = derived class = child class
• superclass = base class = parent class
• subclass inherits attributes and behaviors of superclass
  • instance of subclass can access both data and behavior of parent class
  • member variables and functions in the parent class are part of child class
  • private aspects of the parent are also part of the child but cannot be accessed within the child class
• subclass can also define their own attributes and behaviors

Inheritance : Extension and Contraction

• Inheritance is both extension and contraction
• Extension
  • the behavior of a subclass is larger than the behavior of the superclass
  • subclass is an extension of the superclass
• Contraction
  • the subclass can override behavior to make it fit a specialized[restricted] situation
  • subclass is a contraction of the superclass
• interplay between extension and contraction allows Object-Oriented systems to take very general tools and specialize them for specific projects

Inheritance relationship

IS-A relationship

• public [general, specialized] inheritance
• can check whether two classes have inheritance relationship
  • A is-a B : sounds right to ears that A can be made of a a subclass of B

    HAS-A relationship

• can be used with private inheritance
• composition[membership] relationship

Benefits of Inheritance

• Software Reuse
  • improved reliability and maintainability
  • Reuse of code (Code sharing)
  • methods defined in the parent can be made available to the child without rewriting
  • makes it easy to create new abstractions
  • Reuse of concept
  • methods described in the parent can be redefined and overridden in the child
  • although no code is shared between parent and child, the concept embodied in the definition is shared.
• Consistency of Interface (abstract class)
• Rapid Prototyping
• Extensibility / Polymorphism
  • new functionality may be easily plugged in without changing existing classes

Cost of Inheritance

• Execution speed ( dynamic binding)
• Program size
• Program Complexity
• Increased coupling between classes

Constructor / Destructor in Inheritance

• Instantiating a derived class object begins a chain of constructor calls
• before performing its own tasks, the derived class constructor invokes its direct base class's constructor either explicitly or implicitly
  • explicitly : via a base class member initializer
  • implicitly : calling the base class's default constructor
  • parent constructor -> member variable constructor -> self constructor
• destructors are called in reverse order
  • self destructor -> member variable destructor -> parent destructor example in c++

[jimin-kiim]

Polymorphism

• Poly(many) + Morph(forms)
• variable[function, class] with one name may have many different meanings
• the ability of objects belonging to different data types to respond to method calls of the same name and to behave appropriately according to their data types

  Four different forms of Polymorphisms

• overloading
• overriding
• polymorphic variable
• dynamic binding

Overloading

• same method name with different signature
• a single function name has several alternative implementations
• typically, overloaded function names are distinguished at compile time based on their type signature
• namespace : overloading based on scope
• default (optional) parameter : overloading of function
• operator overloading

  Overriding

• different definitions that use the same method name with the same signature
• a child class redefines a method inherited from a parent class
• resolved at run time, not at compile time
• two possible means for overriding
  • replacement
  • totally and completely replaces the code in the parent class the code in the child class
  • refinement
  • executes the code in the parent class and adds to it the code in the child class

    
    void Parent::example(int a)
    {
      cout << "in parent code\n";
    }

void Child::example(int a) {   Parent::example(12); // do parent code   cout << "in child code\n"; // then child code }

### Polymorphic variable
- a variable declared as one type but in fact holds a value of different type
  - can reference more than one type of object
- derives their power from interaction with inheritance, overriding and substitution
- when a method is overridden, the code executed will be determined by the current value of a polymorphic variable, not its declared type
- this : example of common polymorphic variable
### Generics (templates)
- a way of creating general tools or classes by parameterizing on types (not values)
  - developing code by leaving certain key types unspecified, to be filled in later
- both used with functions and with classes
  - [function template](https://github.com/jimin-kiim/CPP/issues/16#issuecomment-1352937437)
  - [class template](https://github.com/jimin-kiim/CPP/issues/16#issuecomment-1352937578)

[jimin-kiim]

Data Abstraction

• creating classes with appropriate functionality which hide the unnecessary details
• a programming and design technique that relies on the separation of interface and implementation.
  • Interface : the outside, or service view, describes what an object does
  • Implementation : the inside view describes how it does