We'll ditch the confusing terms and focus on real-world scenarios that you can easily understand.

By the end of this post, you'll be a prototypal inheritance pro, realizing that it wasn't that hard after all!

Table of Contents

• Concept Introduction
• What are JavaScript Objects?
• What is an Object Prototype?
• How to Work with .prototype Object of a Constructor
• How to Alter a Constructor's Prototype
• The proto Property
• Summary

Concept Introduction

Imagine that I'm a parent and I have a child and a grandchild. If you were to represent my family tree in a diagram, it should look like this:

Fig 1: Depicting the inheritance structure with family

You can see that grandparent is at the top of this family tree, while the parent is a direct descendant of the grandparent, and the child is a descendant of parent.

If you attempt to walk your way back up, you'll see that grandchild is a child of parent and its own parent is a child of grandparent.

What are JavaScript Objects?

You may have come across this statement at some point: "In JavaScript, almost everything is an Object".

Notice how I spelt Object? When I use Object and object throughout this article, they will mean different things.

Object is a constructor used to create objects. That is: one is parent/ancestor and the other is child.

Using the illustration in Fig 1.0 above, let's attempt to demonstrate how the family tree works in JavaScript.

 Object ⁠ is the grandparent.

Constructors like ⁠ Array, String, Number, Function, ⁠ and ⁠ Boolean ⁠ are all descendants of ⁠ Object.

They all produce offspring of different types: array, string, number, function, and Boolean. However, if you trace back to their origin, they are all Objects.

Fig 2: Object is at the top of the inheritance tree in JavaScript

So if you're asked why everything (except null and undefined) are regarded as objects in JavaScript, it is because they are all descendants of the Object constructor.

The constructors listed in the image above are responsible for the different data types you use in JavaScript. That is, they are used behind the scenes to create familiar data types (and you can also use them to create values of different types explicitly).

Let's try out some code snippets.

How to Create an object

// Using the regular object syntax
const newObj = {}

// Using the object constructor
const newObjWithConstructor = new Object()

How to Create an array

// Using the regular array syntax
const newArr = []

// Using the array constructor
const newArrWithConstructor = new Array()

How to Create a number

// Using the regular syntax
const num = 3

// Using the number constructor
const numWithConstructor = new Number(3)

How to Create a function

// Using regular function syntax
function logArg (arg) {
    console.log(arg)
}

// Using the Function constructor
const logArgWithConstructor = new Function('arg1', 'console.log(arg1)')

How to Create a boolean

// Using the regular boolean syntax
const isValid = true

// Using the Boolean constructor
const isValidWithConstructor = new Boolean(true)

You can see that from the example snippets above, it is possible to explicitly create values using the appropriate constructor, or just by using the simple syntax and allow JavaScript to create the value with the appropriate type for us.

Note: It is important to state that each method of creating values have their own use case and side effects but we won't be getting into that in this article.

The constructors of these various values have something called a prototype.

What is an Object Prototype?

In JavaScript, there is something called prototype. The closest concept to this is the human DNA.

Just like DNA acts as blueprints that define characteristics that are passed on through generations of the human family tree, prototypes in JavaScript are used to define properties and methods that are inherited by objects down the JavaScript Object tree.

Let us combine Fig 1 and Fig 2 above, updating it now to accommodate the concept of DNA and prototype.

Fig 3: Comparing JavaScript inheritance with the concept of inheritance in humans

In JavaScript, all constructors have a prototype. The prototype of a constructor is a dictionary of everything that values created with the constructor should inherit.

Read the line above ☝️ again and proceed when it is clear.

Think of the constructor like a parent and the prototype like the DNA. When the constructor (parent) creates (gives birth to) an offspring (value), the offspring inherits from the DNA (prototype) of it's parent the constructor.

Let's consider another diagram:

Fig 4: Rough depiction of DNA Inheritance in human

From Fig 4, you can see that a child inherits directly from their parent and their parent inherits traits from the grandparent. In this chain of inheritance, the child actually inherits from both the grandparent and the parent.

In fact, the child's characteristics traits are strongly influenced by the combination of the DNA of every ancestor before itself.

This is how prototypal inheritance works in JavaScript.

The properties in the prototype of a constructor are inherited by the children created by that constructor. This continues down the chain. You can reason about it like this:

Every descendant in the inheritance chain, inherits everything available in the prototype of its ancestors.

Fig 5: Prototypal inheritance chain

From the diagram above, you can see that all other prototypes inherit from the Object prototype. Therefore, any value created with the Array constructor (for instance), will inherit from the Array prototype, and also, the Object prototype.

This is so because Array prototype inherits from Object prototype.

The term Array prototype is written as Array.prototype in JavaScript, while Object prototype is Object.prototype.

Note: It is important to note that the concept of DNA is complex so if stretched, we would quickly discover that there are some nuances and difference between how DNA and prototypes work but at the high level, they are very similar.

Therefore, an understanding of inheritance in human family tree would give us a strong understanding of prototypal inheritance in JavaScript.

If you learn better with videos, watch this, before you continue.

How to Work With .prototype of a Constructor

To view the content of a constructor's prototype, we simply write theConstructorName.prototype. Foe example: Array.prototype, Object.prototype, String.prototype and so on.

Ever imagined how it is possible to write [2, 8, 10].**map**(...)? This is because, in the prototype of the Array constructor, there's a key called map. So even though you did not create the property map by yourself, it was inherited by the array value because that value was created by the Array constructor internally.

Read the above statement thus: Have you ever wondered why you have your specific blood type? It's because you get your blood type from the genes you inherited from your parents!

So the next time you make use of properties and methods like .length, .map, .reduce, .valueOf, .find, .hasOwnProperty on a value, just remember that they are all inherited from the constructor's prototype or some prototype up the prototype chain (the ancestry).

You can see the constructor prototype as the prototype of the entity used to construct/create/make a value.

You should be aware that the .prototype of every constructor is an object. The constructor itself is a function, but it's prototype is an object.

console.log(typeof Array) // function
console.log(typeof Array.prototype) // object

Note: An exception to this is the prototype of the Function constructor. It is a function object, but it still has properties attached to it and those properties can be accessed like we would do with regular objects (using the . notation).

If you recall, we can add new properties to and retrieve values of already existing properties of objects by using the dot . notation. For example: objectName.propertyName

const user = {
    name: "asoluka_tee",
    stack: ["Python", "JavaScript", "Node.js", "React", "MongoDB"],
    twitter_url: "https://twitter.com/asoluka_tee"
}

// Using the syntax objectName.propertyName, to access the name key we'll write; user.name 
const userName = user.name;
console.log(userName) // asoluka_tee

// To add a new property to the object we'd write;
user.eyeColor = "black"

// If we log the user object to the console now, we should see eyeColor as part of the object properties with the value of 'black'

Ever heard of DNA mutation? It's the idea of altering ones DNA. In JavaScript, this is possible with prototypes.

Just like DNA mutation is an extremely dangerous thing to try and the outcome could be uncertain or cause undesired side-effects, altering the prototype of a constructor is not a good idea unless you know what you are doing.

How to Alter a Constructor's Prototype

In JavaScript, it is possible to alter the prototype object of a constructor just the same way you can with a regular JavaScript object (as shown above).

This time, we just need to follow this syntax constructorName.prototype.newPropertyName = value. For example, if you want to add a new property named currentDate to the prototype object of the Array constructor, you'd write:

//constructorName.prototype.newPropertyName
Array.prototype.currentDate = new Date().toDateString();

From now on, in your code, because currentDate now exists in the prototype of the Array constructor (Array.prototype), every array created in our program can access it like this: [1, 2, 3].currentDate and the result will be today's date.

If you want every object in your JavaScript program to have access to currentDate, you have to add it to the prototype object of the Object constructor (Object.prototype) instead:

//constructorName.prototype.newPropertyName
Object.prototype.currentDate = new Date().toDateString();

const newArr = [1, 2, 3]
const newObj = {}
const newBool = true

// NB: The date shown is the date of writing this article
console.log(newArr.currentDate) // 'Fri May 10 2024'
console.log(newObj.currentDate) // 'Fri May 10 2024'
console.log(newBool.currentDate) // 'Fri May 10 2024'

This is possible because the prototype object of all constructors inherit from the prototype object of the Object constructor.

Let's write our version of two popular array methods and use them just like we'd used the original.

1. Array.prototype.reduce: We'll call ours .reduceV2

// Add our new function to the prototype object of the Array constructor
Array.prototype.reduceV2 = function (reducer, initialValue) {
  let accum = initialValue;
  for (let i = 0; i < this.length; i++) {
    accum = reducer(accum, this[i]);
  }
  return accum;
};

// Create an array of scores
let scores = [10, 20, 30, 40, 50];

// Use our own version of Array.prototype.reduce to sum the values of the array
const result = scores.reduceV2(function reducer(accum, curr) {
  return accum + curr;
}, 0);

// Log the result to the console
console.log(result);

The focus here is not to explain the whole syntax, it is to show you that by leveraging the prototype chain, you can create your own methods and use them just like the ones JavaScript provides.

Notice that you can just replace our .reduceV2 with the original .reduce and it will still work (edge cases are not handled here).

2. Array.prototype.map: We'll call ours .mapV2

// Add mapV2 method to the prototype object of the Array constructor
Array.prototype.mapV2 = function (func) {
  let newArray = [];
  this.forEach((item, index) => newArray.push(func(item, index)));
  return newArray;
};

// Create an array of scores 
const scores = [1, 2, 3, 4, 5];

// Use our mapV2 method to increment every item of the scores array by 2
const scoresTimesTwo = scores.mapV2(function (curr, index) {
    return curr * 2;
})

// Log the value of scoresTimesTwo to the console.
console.log(scoresTimesTwo)

Note: It is important to state that this is by no means a perfect implementation of the original versions of the map method of JavaScript. It is just an attempt to show you what's possible with a constructor's prototype object.

Before we round up this lesson, there's one more thing I need to mention; It is the __proto__ property of every object.

The proto Property

__proto__ is a setter and getter for [[prototype]] property of an object. This means that it is used to set or get the prototype of an object (for example, the object from which another object inherits from).

Consider this code snippet;

const user = {}
const scores = []

user.prototype // undefined
scores.prototype // undefined

In the above snippet, we tried to access the prototype object directly from values. This is not possible in JavaScript.

This makes sense because only constructors have the prototype property attached to them.

Just like DNA mutation is risky, it could be chaotic to mess with the prototype object if you do not absolutely know what you're doing.

Under normal circumstances, a child should not try to alter the DNA of its ancestor or even determine who to inherit traits from 😉

The JavaScript language however provides a way for us to access the prototype object from values that are not constructors using the __proto__ property.

This is a deprecated method and should not be used for new projects. I am mentioning __proto__ because you could be employed to work in a codebase that still uses it.

__proto__ allows a value to access the prototype object of it's constructor directly. So if for any reason you wish to see what is available in the prototype chain of a value's immediate ancestor, the __proto__ property could be used for that.

You can also use __proto__ to determine which object a value should inherit from.

For instance, we have an object called human, and we want another object called parent to inherit from human, this can be done with the __proto__ property of parent like this;

// Create a human object
const human = {
    walk: function () { console.log('sleeping') },
    talk: function () { console.log('talking') },
    sleep: function () { console.log('sleeping') }
}

// Create a parent object and configure it to inherit from human.
const parent = {
    __proto__: human
}

// Use a method from the ancestor of parent
parent.sleep() // sleeping

Notice how we can call the sleep method on parent because parent now inherits from human.

There are more modern recommended methods to use when interacting with the prototype object like Object.getPrototypeOf and Object.setPrototypeOf

const user = {}
const scores = []

// Get the prototype of the user object
console.log(Object.getPrototypeOf(user))

// Change the prototype of the scores array. This is like switching ancestry and should be done with great care.
console.log(Object.setPrototypeOf(scores, {}))

// Check the prototype of scores now
console.log(Object.getPrototypeOf(scores)) // {}

These methods should be used with great care. In fact, you should read more about them in the MDN JS docs to get more information on their pros and cons.

If you've read up to this point, you now know the fundamentals of Array.prototype and from now on, learning about any other concept built on top of this in JavaScript will be easier to understand.

Let's summarize what you have learned so far.

Summary

We have different constructors in JavaScript: Array, Boolean, Function, Number, String, and Object.

Object is the parent of all the other constructors.

Each constructor has a .prototype object and this object contains properties and methods that could be accessed by values created using the constructor. For example, a value created using the Array constructor will have access to all the properties and methods available in the Array.prototype object and this inheritance goes all the way up.

That is to say, a value created using the Array constructor (whether implicitly or explicitly), will not only have access to properties and methods in the Array.prototype object, but also properties and methods in the Object.prototype object.

This is because of the concept of prototypal inheritance. Object is parent of Array and every child produced by Array will have access to traits from both Array and Object.

This is what happens when you try to get a property from a value which is not explicitly declared on the value. See code snippet below:

const user = {}

// trying to retireve .valueOf property from the user object
console.log(user.valueOf)

Obviously the user object has no .valueOf property, so it looks up its prototype chain for any prototype which has that property and if it is found, the value is returned. Otherwise, we get undefined.

We also learned that we can alter the prototype of any constructor to add functionality and this should be done with caution.

Finally, we learned about how __proto__, getPrototypeOf, and setPrototypeOf could be used to retrieve and set the prototype of a value.

How is This Useful?

Imagine that you want to create a method which creates a new object based on an array and returns it when called on the array.

This one's for you to try out yourself.

// Array.prototype.toObject
const names = ['Austin', 'Tola', 'Joe', 'Victor'];

// Write your implementation of toObject here.

console.log(names.toObject()) // {0: 'Austin', 1: 'Tola', 2: 'Joe', 3: 'Victor'}

Hurray!!! I know you feel like a JavaScript ninja already.

If you learn better with videos, do subscribe to my YouTube channel and I'd be releasing lecture videos soon.

Thanks for reading! Happy coding!

But sometimes you might need to use what is commonly referred as virtual inheritance.

In this article we will discuss when you might need to use virtual inheritance and how to implement it in C++.

What is Virtual Inheritance?

In C++, a class can inherit from multiple classes which is commonly referred as multiple inheritance. But this can cause problems sometimes, as you can have multiple instances of the base class.

To tackle this problem, C++ uses a technique which ensures only one instance of a base class is present. That technique is referred as virtual inheritance.

Example of When Virtual Inheritance is Useful

Let's look at an example and then explain what's happening:

#include <iostream>

class A {
    public:
     int x = 5;
     //some other things
};
class B : public A { // inherit from the Class A.
    public:
      int i = 6;
};
class C : public A { // inherit from the Class A.
    public:
      int i = 7;
};
class D : public B, public C { // inherit from both class B and C
    // something can go here..
};

int main(){
    D obj;
    std::cout << obj.x << std::endl;
    return 0;
}

Let's see what's going on here:

First, we have a class A which is being inherited by two classes B and C. Both of these classes are then inherited by another class D.

Inside our main function, we create a new instance (object) of the class D. We then simply tried to print the value of x to the console.

It might look legit to access the value of x here, because class D is inherited from both B and C which are ultimately inherited from the class A.

But when you try to compile the above program, you get the following error:

<source>: In function 'int main()':
<source>:21:22: error: request for member 'x' is ambiguous
   21 |     std::cout << obj.x << std::endl;
      |                      ^
<source>:5:10: note: candidates are: 'int A::x'
    5 |      int x = 5;
      |          ^
<source>:5:10: note:                 'int A::x'

The error is pretty clear: error: request for member 'x' is ambiguous. Let's now see how the request is ambiguous.

If we draw the hierarchical class structure, it should become pretty clear:

Hierarchical class structure

We can see that we have multiple instances of the class A. So the request to the variable x becomes ambiguous because the compiler doesn't know which instance we are referring to – is it through B or through C ? That's the real problem.

One Way to Solve this Problem

One way to tackle the problem is to use the scope-resolution operator (::) with which we can directly specify which instance of A we want.

int main(){
    D obj;
    std::cout << obj.B::x << std::endl;
    std::cout << obj.C::x << std::endl;
}

Using the scope-resolution operator we explicitly told the compiler which instance of A we referred to.

The main problem with this approach is that it doesn't solve our problem – because our main problem is having multiple instances of class A, and we still have that. So we need to look around for some other solutions.

And the other solution is to use virtual inheritance. Let's see how it works now.

How to Use Virtual Inheritance

To inherit virtually we simply add a keyword virtual before our base class name in the derived class declaration like this:

class B : virtual public A{
    public:
      int i = 6;
};
class C : virtual public A{
    public:
      int i = 7;
};

The addition of the virtual keyword indicates that we want to inherit from A virtually.

Inheriting virtually guarantees that there will be only one instance of the base class among the derived classes that virtually inherited it. After the changes, our hierarchical class structure becomes:

The Hierarchical structure after virtual inheritance

So now if we try to compile the following code, it will successfully compile.

#include <iostream>

class A {
    public:
     int x = 5;
};
class B : virtual public A{
    public:
      int i = 6;
};
class C : virtual public A{
    public:
      int i = 7;
};
class D : public B, public C{

};

int main(){
    D obj;
    std::cout << obj.x << std::endl;

}

So with the introduction of virtual inheritance we are able to remove the ambiguities we had earlier.

Wrapping Up

In this article you learnt about the problem you might face while inheriting a class and a way to solve it using virtual inheritance.

Happy Coding!

Other pillars of object-oriented programming include encapsulation, polymorphism, and abstraction.

In this article, we will learn about inheritance in C# and the various types of inheritance we have in OOP.

What is Inheritance?

Inheritance is one of the key features of object-oriented programming (OOP). It is simply the process by which one class (the child or derived class) acquires the properties, methods, and fields of another class (the base, parent, or super class).

Inheritance in object-oriented programming means that you're creating classes that can pass down their properties to other classes without having to explicitly define the properties in new classes.

Inheritance does not only ensure the reusability of the codebase, but it also reduces your code’s complexity.

Types of Inheritance in C

Inheritance allows you to build families of related classes. The base/parent class defines the common data for the child class to inherit it. You use the colon operator (:) to show inheritance between two classes.

using System;

namespace LearningInheritance
{
    class ParentClass
    {
        //...
    }
    class ChildClass:ParentClass
    {
        //..
    }
}

There are different types of inheritance in C#. We'll discuss them now.

Single Inheritance in C

Single inheritance usually occurs between two classes – the base class, and the derived class. It occurs when a class is inherited from a single-parent class.

Below is a code sample that shows single inheritance in C#:

using System;

namespace LearningInheritance
{
    class ParentClass
    {
        public string name;
        public int Id = 9;

        public void displayParentClassDetails()
        {
            Console.WriteLine($"I am {name}");
            Console.WriteLine($"ID : {Id}");
        }
    }

    class ChildClass : ParentClass
    {
        public void getIdFromParentClass()
        {
            Console.WriteLine($"This is my ID : {Id}");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            //accessing the inherited members from the child class
            ChildClass child = new ChildClass();
            child.getIdFromParentClass();
        }
    }
}

In the above code, we derived a subclass (ChildClass) from a super class (ParentClass). The ChildClass now has access to the fields and properties of the ParentClass through inheritance. We could easily access the inherited members from the ChildClass as seen above.

Hierarchical Inheritance in C

Hierarchical inheritance occurs when more than one derived class is created from a single-parent class.

namespace LearningInheritance
{
    class ParentClass
    {
        public string name;
        public int Id = 9;

        public void displayParentClassDetails()
        {
            Console.WriteLine($"I am {name}");
            Console.WriteLine($"ID : {Id}");
        }
    }

    class ChildClass : ParentClass
    {
        public void getIdFromParentClass()
        {
            Console.WriteLine("Displaying from my Child Class");
            Console.WriteLine($"This is my ID : {Id}.");
        }
    }

    class AnotherChildClass : ParentClass
    {
        public void getIdFromParentClass()
        {
            Console.WriteLine("Displaying from my other Child Class");
            Console.WriteLine($"This is my ID : {Id}");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            //accessing the inherited members in the parent class (from the child class)
            ChildClass child = new ChildClass();
            child.getIdFromParentClass();

            //accessing the inherited members in the parent class (from the other child class)
            AnotherChildClass anotherChild = new AnotherChildClass();
            anotherChild.getIdFromParentClass();
        }
    }
}

In the above code, we showed that we can derive more than one child class from a single parent class.

The ChildClass and AnotherChildClass both inherit the fields and methods of the base class, ParentClass. This is called Hierarchical inheritance. The two child classes can therefore access the fields and methods of the parent class.

Multi-level Inheritance in C

Multi-level inheritance occurs when a class is derived from another derived class. It is simply a situation where a derived class is created and used as a base class for another class.

namespace LearningInheritance
{
    class ParentClass
    {
        public string name;
        public int Id = 9;

        //...
    }

    class ChildClass : ParentClass
    {
        //...
        //The Child class is the derived class in this case
    }

    class ThirdClass : ChildClass
    {
        //...
        //The ChildClass is the base class for the ThirdClass
    }

    class Program
    {
        static void Main(string[] args)
        {
            //...
        }
    }
}

In the above code, we also derived a subclass (ChildClass) from a super class (ParentClass). The ChildClass then acts as a base class for a sub-child class which was named ThirdClass.

Multiple Inheritances – Interfaces in C

Multiple inheritances are not supported in C#. But you can achieve it by using interfaces.

Multiple inheritances allow a derived class to be inherited from multiple parent classes. You can see an example of how a child class can inherit from multiple interfaces that act like a parent class below:

namespace LearningInheritance
{    
    class Program
    {
        interface InterfaceA
        {
            //...
        }

        interface InterfaceB
        {
            //...
        }     

        class NewClass: InterfaceA, InterfaceB
        {
            //...            
        }

        static void Main(string[] args)
        {
            //...
        }
    }
}

Conclusion

Inheritance is important because it helps keep your code clean. It makes it easier to build families of related classes. The child class can inherit all the fields, properties, and methods that are contained in the parent class except those classes that are declared as a private class.

Through this article, I hope you have gained some insight about inheritance in C#.

Happy Coding.

Table of Contents

• Intro

• How to access a prototype’s properties and methods in JavaScript

• The prototype chain

• A prototype-based language

• Javascript classes

• Roundup

Intro

Have you ever wondered how strings, arrays or objects “know” the methods each of them have? How does a string know it can .toUpperCase() or an array know that it can .sort()? We never defined these methods manually, right?

The answer is that these methods come built-in within each type of data structure thanks to something called prototype inheritance.

In JavaScript, an object can inherit properties of another object. The object from where the properties are inherited is called the prototype. In short, objects can inherit properties from other objects — the prototypes.

You’re probably wondering: why the need for inheritance in the first place? Well, inheritance solves the problem of data and logic duplication. By inheriting, objects can share properties and methods without the need of manually setting those properties and methods on each object.

How to Access a Prototype’s Properties and Methods in JavaScript

When we try to access a property of an object, the property is not only searched in the object itself. It's also searched in the prototype of the object, in the prototype of the prototype, and so on – until a property is found that matches the name or the end of the prototype chain is reached.

If the property or method isn’t found anywhere in the prototype chain, only then will JavaScript return undefined.

Every object in JavaScript has an internal property called [[Prototype]].

If we create an array and log it to the console like this:

const arr = [1,2,3]
console.log(arr)

We will see this:

The double square brackets that enclose [[Prototype]] signify that it is an internal property, and cannot be accessed directly in code.

To find the [[Prototype]] of an object, we will use the Object.getPrototypeOf() method.

const arr = [1,2,3]
console.log(Object.getPrototypeOf(arr))

The output will consist of several built-in properties and methods:

Keep in mind that prototypes can also be changed and modified through different methods.

The Prototype Chain

At the end of the prototype chain is Object.prototype. All objects inherit the properties and methods of Object. Any attempt to search beyond the end of the chain results in null.

If you look for the prototype of the prototype of an array, a function, or a string, you’ll see it’s an object. And that’s because in JavaScript all objects are descendants or instances of Object.prototype, which is an object that sets properties and methods to all other JavaScript data types.

const arr = [1,2,3]
const arrProto = Object.getPrototypeOf(arr)
console.log(Object.getPrototypeOf(arrProto))

Each type of prototype (for example array prototype) defines its own methods and properties, and in some cases overrides the Object.prototype methods and properties (that’s why arrays have methods that objects don’t).

But under the hood and going up the ladder of the prototype chain, everything in JavaScript is built upon the Object.prototype.

If we try to look into the prototype of Object.prototype we get null.

const arr = [1,2,3]
const arrProto = Object.getPrototypeOf(arr)
const objectProto = Object.getPrototypeOf(arrProto)
console.log(Object.getPrototypeOf(objectProto))

A Prototype-Based Language

JavaScript is a prototype-based language, meaning object properties and methods can be shared through generalized objects that have the ability to be cloned and extended.

When it comes to inheritance, JavaScript has only one structure: objects.

Each object has a private property (referred to as its [[Prototype]]) that maintains a link to another object called its prototype. That prototype object has its own prototype, and so on until an object whose prototype is null is reached.

By definition, null has no prototype, and acts as the final link in this chain of prototypes.

This is known as prototypical inheritance and differs from class inheritance. Among popular object-oriented programming languages, JavaScript is relatively unique, as other prominent languages such as PHP, Python, and Java are class-based languages, which instead define classes as blueprints for objects.

At this point you may be thinking "But we CAN implement classes on JavaScript!". And yes, we can, but as syntactic sugar. 🤫🤔

Javascript Classes

Classes are a way to set a blueprint to create objects with predefined properties and methods. By creating a class with specific properties and methods, you can later on instantiate objects from that class, that will inherit all the properties and methods that that class has.

In JavaScript, we can create classes in the following way:

class Alien {
    constructor (name, phrase) {
        this.name = name
        this.phrase = phrase
        this.species = "alien"
    }
    fly = () => console.log("Zzzzzziiiiiinnnnnggggg!!")
    sayPhrase = () => console.log(this.phrase)
}

And then we can instantiate an object from that class like this:

const alien1 = new Alien("Ali", "I'm Ali the alien!")
console.log(alien1.name) // output: "Ali"

Classes are used as a way to make code more modular, organized, and understandable and are heavily used in OOP programming.

But keep in mind that JavaScript doesn’t really support classes like other languages. The class keyword was introduced with ES6 as syntactic sugar that facilitates this way of organizing code.

To visualize this, see that the same thing we did by previously defining a class, we can do it by defining a function and editing the prototype in the following way:

function Alien(name, phrase) {
    this.name = name
    this.phrase = phrase
    this.species = "alien"
}

Alien.prototype.fly = () => console.log("Zzzzzziiiiiinnnnnggggg!!")
Alien.prototype.sayPhrase = () => console.log(this.phrase)

const alien1 = new Alien("Ali", "I'm Ali the alien!")

console.log(alien1.name) // output "Ali"
console.log(alien1.phrase) // output "I'm Ali the alien!"
alien1.fly() // output "Zzzzzziiiiiinnnnnggggg"

Any function can be invoked as a constructor with the keyword new and the prototype property of that function is used for the object to inherit methods from. In JavaScript, “class” is only used conceptually to describe the above practice – technically they’re just functions.😑

Although this doesn't necessarily make a lot of difference (we can still perfectly implement OOP and use classes like in most other programming languages), it's important to remember that JavaScript is built with prototype inheritance at its core.

Roundup

That's it, everyone! As always, I hope you enjoyed the article and learned something new. If you want, you can also follow me on LinkedIn or Twitter.

Cheers and see you in the next one! =D

Java is one of the most popular object-oriented programming languages in use today.

Because it is platform-independent, you will find Java applications on every type of device and every operating system. And because Java is relatively easy to learn, it is one of the first languages that many programmers pick up.

An important feature of Java that you should be familiar with is class inheritance. Inheritance allows programmers to optimize code by facilitating class reuse. When you can reuse code that has already been tested and debugged, the software development life cycle becomes shorter and less costly.

While theoretically a simple concept, coding inheritance relationships require attention to detail. This is particularly true with respect to multiple inheritance, where a single child class inherits properties from multiple parent classes.

Java rejects multiple inheritance relationships because they create ambiguities, but there are a few ways you can accomplish many of the same effects if you know what to do.

In this article, we'll consider the problems with multiple inheritance and discuss alternative coding options in Java.

Inheritance Terminology

Sometimes, to be a successful programmer, you have to learn to problem solve in order to find workarounds for common bugs or problems. This is a necessary part of coding securely and smartly.

One such problem deals with multiple inheritance (or rather, the lack thereof) in Java.

_Image Source_

To fully understand inheritance in Java, you need to familiarize yourself with basic object-oriented programming (OOP) inheritance terminology.

• Class: Classes are a fundamental template structure in object-oriented programming languages. A class defines the common properties for a group of objects.
• Parent Class: Also known as base classes or superclasses, a parent class is an extensible class that provides features to a child class. This is where reusability comes into play. The parent class definitions and functions are reused when creating child classes.
• Child Class: More generically called a subclass, a child class inherits features from another class. Child classes are extended or derived classes.
• Inheritance: The relationship between the parent and child classes.

OOP Inheritance Types

There are many popular object-oriented programming languages in use today, including Java, C++, JavaScript, Python, PHP, Ruby, and Perl. While inheritance is a common concept across these OOP languages, not all inheritance types exist in each language.

It is crucial to know the general inheritance types and the limitations on inheritance in the specific language you are using. The more you know about inheritance, the more effective a software developer you will be.

Types of inheritance supported by Java include:

• Single-level inheritance: When a child class derives features from a single parent class.
• Multi-level inheritance: This is a tiered form of single-level inheritance. In multi-level inheritance, a child class can also act as a parent class to other child classes. The relationship between each level is linear – no branches are extending above as in multiple inheritance. The ultimate child class then has features from every level above it.
• Hierarchical inheritance: The opposite of multiple inheritance. In hierarchical inheritance, a single parent class has more than one child class. So rather than having branches above it, it branches below.
• Hybrid inheritance: As its name suggests, hybrid inheritance is a combination of other inheritance types.

In addition to the inheritance types above, there are other types that Java does not support.

• Multiple inheritance: In multiple inheritance, a child class has more than one parent class. While Java and JavaScript do not support multiple inheritance, OOP languages such as C++ do.
• Multipath inheritance: A hybrid of multiple, multi-level, and hierarchical inheritance, in multipath inheritance a child class derives its features and functions from a parent class and several child classes of the parent class. Because multipath inheritance relies on multiple inheritance, Java does not support its use.

Why Java Doesn’t Support Multiple Inheritance

The primary problem with multiple inheritance is that it has the potential to create ambiguities in child classes. In a 1995 overview whitepaper, Java lead designer James Gosling stated that the issues with multiple inheritance were one of the motivations for the creation of Java.

The difficulties inherent in multiple inheritance are most clearly seen in the diamond problem. In the diamond problem, parent class A has two distinct child classes B and C; that is, child classes B and C extend class A.

Image Source

Now we create a new child class D, which extends both class B and class C. Note that we have multiple inheritance (D extends B and C), hierarchical inheritance (B and C extend A), and multilevel inheritance (D extends A, B, and C).

In the diamond problem, child classes B and C inherit a method from parent class A. Both B and C override the inherited method. But the new methods in B and C conflict with each other.

Ultimate child class D inherits the two independent and conflicting methods from its multiple parents B and C. It is unclear which method class D should use, so there is ambiguity. Other OOP programming languages implement various methods for addressing the multiple inheritance ambiguity.

How to Solve the Multiple Inheritance Problem in Java

Just because multiple inheritance is problematic does not mean that it is not useful. There are many situations where you may want one class to have features from several other classes.

Just think about that Tesla Roadster you will buy when you become a wildly successful software developer. It will draw characteristics from both the sports car class and the electric car class.

Or maybe you are using a private browser to read this article, which has features from the online data privacy solution class and the general internet browser class.

But you can’t extend multiple classes in Java. So how does Java deal with the multiple inheritance issue?

Well, it uses structures called interfaces. Interfaces are abstract types that specify behaviors for classes to implement. Because they are abstract, interfaces do not contain detailed instructions for their behaviors. Instead, the classes provide concrete implementations of interface behaviors.

Interfaces have several defining characteristics:

• Unlike classes, you do not instantiate interfaces. Instead, classes implement interfaces
• Interfaces contain only public constant definitions and method headers
• Interfaces can only extend other interfaces, not classes
• Interfaces can extend multiple interfaces, and classes can implement multiple interfaces

Now, we can effectively bypass the diamond problem with interfaces. Recalling that only interfaces can only extend other interfaces and any class that needs multiple inheritance characteristics must implement multiple interfaces, we can redefine the diamond problem classes.

What were previously classes A, B, and C now become interfaces A, B, and C. Interfaces B and C still extend interface A, but there are no concrete functions in any of these interfaces, just defined behaviors. Class D remains a class, which is responsible for the concrete implementation of the behaviors found in interfaces B and C.

Note one key distinction here: Class D is not extending interfaces B and C. It is instead implementing them. So you do not actually have a multiple inheritance. Instead, you have simply redefined the problem.

Conclusion

Understanding inheritance is necessary for any effective coder. For Java programmers, it is equally important to know the limitations of inheritance and the built-in Java workaround for the traditional problems with multiple inheritance.

Learning how to put interfaces in place to recreate the effects of multiple inheritance in Java will increase your effectiveness and hireability.

Java inheritance refers to the ability of a Java Class to inherit the properties from some other Class. Think of it like a child inheriting properties from its parents, the concept is very similar to that. In Java lingo, it is also called extend-ing a class.

Some simple things to remember:

• The Class that extends or inherits is called a subclass
• The Class that is being extended or inherited is called a superclass

Thus, inheritance gives Java the cool capability of re-using code, or sharing code between classes!

Let’s describe it with the classic example of a Vehicle class and a Car class :

public class Vehicle {
    public void start() {
        // starting the engine
    }

    public void stop() {
        // stopping the engine
    }
}

public class Car extends Vehicle {
    int numberOfSeats = 4;

    public int getNumberOfSeats() {
        return numberOfSeats;
    }
}

Here, we can see the Car class inheriting the properties of the Vehicle class. So, we don’t have to write the same code for the methods start() and stop() for Car as well, as those properties are available from its parent or superclass. Therefore, objects created from the Car class will also have those properties!

Car tesla = new Car();

tesla.start();

tesla.stop();

Run Code

But, does the parent class have the methods of the child? No, it doesn’t.

Therefore, whenever you need to share some common piece of code between multiple classes, it is always good to have a parent class, and then extend that class whenever needed! Reduces the number of lines of code, makes code modular, and simplifies testing.

What can be inherited ?

• All protected and public fields and methods from parent

What cannot be inherited ?

• private fields and methods
• Constructors. Although, the subclass constructor has to call the superclass constructor if its defined (More on that later!)
• Multiple classes. Java supports only single inheritance, that is, you can only inherit one class at a time.
• Fields. Individual fields of a class cannot be overriden by the subclass.

Type Casting & Reference

In Java, it is possible to reference a subclass as an instance of its superclass. It is called Polymorphism in Object Oriented Programming (OOP), the ability for an object to take on many forms. For example, the Car class object can be referenced as a Vehicle class instance like this :

Vehicle car = new Car();

Although, the opposite is not possible :

Car car = new Vehicle(); // ERROR

Run Code

Since you can reference a Java subclass as a superclass instance, you can easily cast an instance of a subclass object to a superclass instance. It is possible to cast a superclass object into a subclass type, but only if the object is really an instance of the subclass. So keep this in mind :

Car car = new Car();
Vehicle vehicle = car; // upcasting
Car car2 = (Car)vechile; //downcasting

Bike bike = new Bike(); // say Bike is also a subclass of Vehicle
Vehicle v = bike; // upcasting, no problem here.
Car car3 = (Car)bike; // Compilation Error : as bike is NOT a instance of Car

Run Code

Now you know how to share code through a parent-child relationship. But, what if, you do not like the implementation of a particular method in the child class and want to write a new one for it? What do you do then?

Override it!

Java lets you override or redefine the methods defined in the superclass. For example, your Car class has a different implementation of start() than the parent Vehicle, so you do this :

public class Vehicle {
    public void start() {
      System.out.println("Vehicle start code");
    }
}

public class Car extends Vehicle {
    public void start() {
      System.out.println("Car start code");
  }
}

Car car = new Car();
car.start(); // "Car start code"

Run Code

So, it’s pretty simple to override methods in the subclass. Although, there is a catch. Only that superclass method with the exact same method signature as the subclass method will be overriden. That means the subclass method definition must have the exact same name, same number and type of parameters, and in the exact same sequence. Thus, public void start(String key) would not override public void start().

Notes :

• You cannot override private methods of the superclass. (Quite obvious, isn’t it?)
• What if the method of superclass which you are overriding in the subclass suddenly gets obliterated or methods changed? It would fail in runtime! So Java provides you a nifty annotation @Override which you can place over the subclass method, which will warn the compiler of those incidents!

Annotations in Java is a good coding practice, but they are not a necessity. The compiler is smart enough to figure out overriding on its own though. Unlike other OOP languages, Annotations in Java it doesn’t necessarily modify the method or add extra functionality.

How to call super class methods?

Funny you ask about it! Just use the keyword super :

public class Vehicle() {
    public void start() {
      System.out.println("Vehicle start code");
    }
}

public class Car extends Vehicle {
    public void run() {
      super.start();
  }
}

Car car = new Car();
car.run(); // "Vehicle start code"

Run Code

N.B. : Although you can call the parent method by using a super call, you cannot go up the inheritance hierarchy with chained super calls.

How to know the type of a class?

Using the instanceof keyword. Having lots of classes and subclasses it would be a little confusing to know which class is a subclass of which one in runtime. So, we can use instanceof to determine whether an object is an instance of a class, an instance of a subclass, or an instance of an interface.

Car car = new Car();

boolean flag = car instanceof Vehicle; // true in this case!

Constructors & Inheritance

As mentioned earlier, constructors cannot be directly inherited by a subclass. Although, a subclass is required to call its parent’s constructor as the first operation in its own constructor. How? You guessed it, using super :

public class Vehicle {
    public Vehicle() {
        // constructor
    }
    public void start() {
      System.out.println("Vehicle start code");
    }
}

public class Car extends Vehicle {
    public Car() {
      super();
    }
    public void run() {
      super.start();
  }
}

Run Code

Remember, if the superclass does not have any constructors defined, you don’t have to call it explicitely in the subclass. Java handles that internally for you! Invocation to super constructor is done in the case when the super class is to be called with any other constructor other than the default constructor.

If no other constructors are defined, then Java invokes the default super class constructor (even if not defined explicitly).

Congrats, now you know all about Inheritance! Read more about advanced ways to inherit things in Abstract Classes and Interfaces!