Tag: object oriented design patterns

Clean Architecture – Chapter 5 | Object Oriented Progrmming

March 5th, 2023

What is Object Oriented?

I have always come across that object oriented (OO) is a way to model real world. It was the same definition, while I was in bachelors, same while I was doing masters. The author labels this definition as evasive and doesn’t tell us what OO is. He refers perhaps we accepted this definition because it makes software closer to us as it emulates real world

The other popular definition is “OO is combination of data and functions”. It implies o.f() is different than f(o), which is absurd as programmers have been passing data structures in functions long before OO was discovered.

Yet another definition is OO is a proper mixture of encapsulation, inheritance and polymorphism. And then author goes on to refute this definition as well, ultimately defining OO by the end of the chapter. Let’s see what argument he makes against all these three.

Encapsulation

OO languages provided easy way to encapsulate both data and functions into one object. But this is not unique to OO languages, C even before OO had perfect encapsulation.

In C, we used to declare the data structures and functions in header files and then implement them in implementation files. The users of the data structures never has access to the implementations. (we always import header files in other C files, and use data structures and functions from there)

Modern programming languages, removed this distinction between header and implementation and combined them into one, thus diluting encapsulation. So in a way modern OO languages don’t provide any improvement on encapsulation, rather degrade it. So we cannot say OO depends on strong encapsulation.

Inheritance

Inheritance is redeclaration of group of variables and functions within an enclosed scope. In C, it was possible to manually do this. Safe to say, inheritance was there in pre OO languages in some form. Modern OO languages build upon that concept, making it more easy to do.

Polymorphism

Polymorphism is an application of pointers to functions. In C, C++, there were pointers (referring to location of a resource) that were passed between functions. This kind of polymorphism was manual, and the programmers need to be careful to follow the pointers safely to avoid errors. Although modern programming languages didn’t start polymorphism, they have made its development simple and intuitive.

Dependency Inversion – the real power of OO

Traditionally, in structured programming languages, the flow of dependencies followed the flow of control of program. It has been done using include in C, import in Java, etc.

Polymorphism enables us to control the flow of source code dependencies and keep it separate from the flow of control using dependency inversion.

OO is the ability through the use of polymorphism, to gain absolute control over every source code dependency of the system. It allows the architect to create a plugin architecture, in which modules that contain high level policies are independent of modules that contain low level details. These modules can be developed independently of each other.
Robert Martin.

Thanks for stopping by! See you in next post! Hope it was good byte on object oriebted methodoloty. Don’t hesitate to start conversation using comments below.
Factory Pattern using Factory Method- Part 1

January 22nd, 2023
Why the need for factory pattern?

Let’s take example of a ToyotaCarFactory, the main aim of the ToyotaCarFactory is to fulfill an order for a ToyotaCar. There are multiple models of Toyota and the factory should manufacture them all.

The orderCar method would look something like this –
```
ToyotaCar orderCar(String model)
{
    ToyotaCar car;

    if(model.equals("sienna") {
       car = new SiennaToyotaCar();
    } else if(model.equals("highlander") {
       car = new HighLanderToyotaCar();
    } else if(model.equals("prius") {
       car = new PriusToyotaCar();
    } 

    car.assembleParts();
    car.polish();
    car.testDrive();
}
```
If Toyota decided to launch three other methods, the object instantiation part would keep on increasing. And we would need to change it, make sure nothing breaks, add the code to correct part. Our code is not closed for modification, as every time new type of toyota car is added, we have to open this and modify it.

If instead we would have implemented against a CarFactory interface, then we would have given the responsibility of instantiating the required objects to the subclasses. And say other car manufacturers want to use the same CarFactory, we could easily add new concrete subclasses without causing changes to existing ones.

That’s the advantage of coding to interfaces as opposed to coding to concrete implementation. Your code is following the principle of “Open for extension, closed for modification”.

Factory Pattern

Creator is the interface which has the factory method. But the subclasses which implement the factory method actually create the Product objects.

Example

Let’s use an example to better understand this pattern.

Example of Factory Pattern using Toyota Car manufacturing

Continuing on our Car manufacturing example, our Creator is the CarFactory, having the createCar() factory method which would hold the object instantiation part. ToyotaCarFactory is our concrete creator class which would be responsible for creating the different ToyotaCar objects by providing an implementation of createCar() method.

We will see a sample implementation in the following post.

Tag: object oriented design patterns

Clean Architecture – Chapter 5 | Object Oriented Progrmming

What is Object Oriented?

Encapsulation

Inheritance

Polymorphism

Dependency Inversion – the real power of OO

Factory Pattern using Factory Method- Part 1

Why the need for factory pattern?

Example