Basic OO Principles

There are 4 basic Object Orientated Principals that every aspiring programmer should follow. These are:

Abstraction (Coding logic, composability)
Encapsulation (Data hiding, all data in one unit)
Inheritance (Sharing, passing down properties, parent to child)
Polymorphism (Object takes on many forms, Same name functions however can behave differently)

Abstraction

Abstraction is the process of taking away or removing characteristics from something in order to reduce it to a set of essential characteristics. In programming, a programmer hides all but the relevant data about an object in order to reduce complexity and increase efficiency. In the process of abstraction, the programmer tries to ensure that the entity is named in a manner that will make sense and that it will have all the relevant aspects included and none of the extraneous ones.

An Example of how Abstraction works in JavaScript - Here is the given code:


                            const subtract = (a, b) => a - b;


                            const a = subtract(1, 1);

                            const b = subtract(a, 1);

                            const c = subtract(b, 1);

But if you use the function above to frequently deincrement numbers this means that you could use a lot of code, so this can be abstracted to:


                            const subtract = a => b => a - b;



                            const deinc = subtract(1);



                            const a = deinc(1);

                            const b = deinc(a);

                            const c = deinc(b);

What we have just done is created a partial application, applying the function to its first argument and returning a new function that takes the next argument. Then we have used the new deinc function instead of subtract when we need to deincrement by 1, which reduced the code required.

The reason why people make their code more abstract is to make their code more simple to read, more concise, as well as increasing its reusability and its composability.

Abstraction is doing more with less code.

Encapsulation

Encapsulation describes the idea of bundling data and methods that work on that data within one unit, e.g., a class in Java. It involves hiding the internal representation, or state, of an object from the outside. This is called "information hiding" (or data hiding) - If you have an attribute that is not visible from the outside of an object, and bundle it with methods that provide read or write access to it, then you can hide specific data and control access to the internal state of the object.

An example of Encapsulation:


                            var car = {


                                carName:"Volvo",


                            };



                            alert(car.carName); // Volvo

                            car.carName = "Ford";

                            alert(car.carName); // Ford



                            //Everything looks okay, but then...



                            car.carName = 35;

                            alert(car.carName); // 35 (This is legal)

This can be refactored to:


                            var car = (function (){



                                var carName = "Volvo";

                                var reg = new RegExp(/\d+/);



                                return { 

                                    setCarName : function (newValue) {

                                        if( reg.test(newValue)) { 

                                            alert("Invalid Name"); 

                                        } else {

                                            carName = newValue;

                                        }

                                    },

                                    getCarName : function () {

                                        return carName; 

                                    } 

                                }; // end of the return

                            }());

It is usually hard to implement an information hiding mechanism. This mechanism reduces the accessibility of attributes to the current class and uses public getter and setter methods to control and restrict external access to these attributes. These methods not only allow you to define which attributes can be read or updated, but it also enables you to validate the new value before changing the attribute.

Inheritance

Inheritance enables new objects to receive (or inherit) the properties and methods of existing objects. A class that is used as the basis for inheritance is called a superclass or base class. A class that inherits properties from a superclass is called a subclass or derived class. A superclass inherits visible properties and methods from its parent while adding additional properties and methods of its own.

The "is a" phrase is important in establishing a relationship in between both objects/classes.

An Example of Inheritance:

A Cat is an Animal. This means a Cat must be a subclass of Animal.


                            // Animal - superclass 

                            function Animal(name) { 

                                this.name = name; 

                            }



                            // superclass method 

                            Animal.prototype.start = function() {

                                return "We have this for you: "+this.name + ".";

                            };



                            // Cat - subclass 

                            function Cat(name) {

                                Animal.call(this.name); // call sugar constructor.

                            }



                            //subclass extends superclass 

                            Cat.prototype = Object.create(Animal.prototype);



                            // subclass method

                            Cat.prototype.run = function() {

                                console.log("Hello " + this.sayMeow());

                            };



                            // instances of subclass 

                            var cat1 = new Cat("Paul");

                            var cat2 = new Cat("Baleno");



                            // accessing the subclass method which internally access superclass method 

                            cat1.run(); // "Meowwww..."

                            cat2.run(); // "Meowwww..."

Inheritance is important in OOP because it cuts down the time needed to make programs this helps because it saves money and resources.

Polymorphism

Polymorphism is a object orientated programming concept that refers to the ability of a variable, function or object to take on multiple forms. A language that features polymorphism allows developers to program in the general rather than the program in the specific.

Objects of classes belonging to the same hierarchical tree (inherited from a common base class) may possess functions bearing the same name, but each having different behaviours.

An Example of Polymorphism:


                            var shape = function (){};

                            shape.prototype.draw = function(){

                                return "i am generic shape";

                            }

                            //circle

                            var circle = function(){}

                            circle.prototype = Object.create(shape.prototype);

                            circle.prototype.draw= function(){

                                return "i am a circle";

                            }

                            //triangle

                            var triangle = function (){}

                            triangle.prototype = Object.create(shape.prototype);

                            triangle.prototype.draw= function(size){

                                return "this is triangle";

                            }

                            //printing shapes

                            var shapes = [new shape(), new circle(), new triangle(23)];

                            shapes.forEach (function (shapeList){

                                console.log(shapeList.draw());

                            });

Polymorphism cuts down the work of the developer because he/she can now create a sort of general class with all the attributes and behaviours that he/she envisions for it. When the time comes for the developer to create more specific subclasses with certain unique attributes and behaviours, the developer can alter code in the specific portions where the behaviours differ. All other portions of the code can be left as is. Poly = Many, Morph = Forms.

These are the four main fundamentals of Object Orientated Programming.