Extends vs implements JavaScript

Extends vs implements JavaScript

The age-old debate!

In the world of object-oriented programming (OOP), two fundamental concepts are often confused: extends and implements. While they may seem similar, they serve distinct purposes.

Extends

When you extend a class in JavaScript, you create a new class that inherits properties and behavior from an existing class. This is achieved using the extends keyword. The extending class (the subclass) builds upon the original class (the superclass), incorporating its functionality while also introducing new characteristics of its own.

For example:

class Animal {
sound() {
console.log("The animal makes a sound.");
}
}
class Dog extends Animal {
sound() {
super.sound();
console.log("Woof!");
}
}

In this case, the Dog class extends the Animal class. The Dog class inherits the sound() method from Animal, but also adds its own implementation. When you create a new instance of Dog and call its sound() method, it will first output "The animal makes a sound." (inherited from Animal) and then "Woof!" (added by Dog).

Implements

On the other hand, when you implement an interface in JavaScript, you create a class that adheres to a specific contract or set of methods defined by that interface. This is achieved using the implements keyword.

An interface defines a blueprint for classes to follow, without providing any implementation details. A class implementing an interface must provide its own implementation for each method declared in the interface.

For instance:

interface Printable {
print(): void;
}
class Document implements Printable {
print() {
console.log("Printing document...");
}
}

In this example, the Document class implements the Printable interface. The Printable interface defines a single method print(), which is then implemented by the Document class. When you create an instance of Document and call its print() method, it will output "Printing document...".

Key differences

To summarize:

While both concepts share similarities, they serve distinct purposes. When choosing between extends and implements, consider whether you want to inherit behavior from an existing class or adhere to a specific interface or contract.

Difference between extending and implementing interface in java

The age-old question!

In Java, both extending and implementing interfaces have their own specific purposes, despite being often confused or misused. Understanding the nuances between these two concepts is crucial for writing efficient, effective, and maintainable code.

Extending Interfaces (Multiple Inheritance)

Java does not support traditional multiple inheritance, where a class can inherit from more than one parent class. However, you can use interfaces to achieve similar functionality through interface inheritance. This is often referred to as "extending" an interface.

When you extend an interface, you are essentially creating a new interface that includes all the methods and constants of the original interface, along with any additional members you might add. The extended interface inherits the abstract methods from the original interface, which must be implemented by its concrete subclass.

For example:

interface Printable {
void print();
}
interface Editable extends Printable {
void edit();
}
class Document implements Editable {
public void print() { /* implementation */ }
public void edit() { /* implementation */ }
}

In this scenario, Editable is an interface that extends Printable. The Document class implements the Editable interface and must provide implementations for both print() and edit() methods.

Implementing Interfaces

On the other hand, implementing an interface means creating a concrete subclass that provides a specific implementation for all the abstract methods declared in the original interface. This is often referred to as "implementing" an interface.

When you implement an interface, you must provide a concrete implementation for each of the interface's abstract methods. The implements keyword is used to specify which interfaces your class implements.

For example:

interface Printable {
void print();
}
class Document implements Printable {
public void print() { /* implementation */ }
}

In this scenario, the Document class implements the Printable interface and must provide an implementation for the print() method.

Key Takeaways

In summary, extending interfaces is about inheriting and combining multiple interfaces, while implementing interfaces is about providing a concrete implementation for an interface's abstract methods. By understanding these differences, you'll be better equipped to write effective, maintainable code that leverages the power of interfaces in Java.