Interfaces vs Abstract Classes

Summary

This video script delves into the nuances of abstract classes and interfaces, contrasting their syntactical differences and use cases. It highlights that while both cannot be instantiated and can contain static members, they serve different purposes in code design. Abstract classes encapsulate commonality among related entities, whereas interfaces decouple components, enhancing flexibility. The script uses analogies like shapes and vehicles to illustrate concepts and discusses scenarios where one might be favored over the other, emphasizing the trade-offs between inheritance and composition in structuring code for maintainability and flexibility.

Takeaways

• 📜 Abstract classes and interfaces are common interview topics and are used to encapsulate common behaviors or roles in code.
• 🔍 The syntactical difference lies in that interfaces can only have public methods and properties, while abstract classes allow for various access modifiers and constructors.
• 🚫 Neither abstract classes nor interfaces can be instantiated directly.
• 🔗 A class can implement multiple interfaces but can only inherit from one abstract class due to the concept of identity.
• 🎯 Abstract classes are used when there is a commonality among classes, while interfaces are chosen for their role in decoupling components and increasing flexibility.
• 📈 Interfaces can provide scope control and enable immutability, whereas abstract classes cannot offer this level of control.
• 🏗️ Traits or roles, a programming paradigm, can be implemented using interfaces but not abstract classes, as a class can play multiple roles through interfaces.
• 🔄 In scenarios where additional responsibilities are anticipated, abstract classes might be more suitable than interfaces.
• 🔧 Inheritance leads to succinct code but may limit reusability, whereas composition with interfaces allows for greater flexibility but can increase code volume.
• 🔎 The choice between inheritance and composition depends on the specific needs of the project, with composition generally preferred for its flexibility.
• 💡 Understanding the differences and appropriate use cases for abstract classes and interfaces is crucial for writing maintainable and flexible code.

Q & A

What is the primary purpose of discussing abstract classes and interfaces in the context of the video?

The primary purpose is to clarify the syntactical differences, use cases, and to provide examples of when to use abstract classes or interfaces in programming, especially in the context of interviews and software design decisions.

What are some key syntactical differences between abstract classes and interfaces?

Abstract classes can have access modifiers, default implementation methods, fields, and constructors. Interfaces, on the other hand, can only have public methods, default implementation methods (but not consumed within the implementing class), and properties (but without fields).

Why might you choose to use an interface over an abstract class in a particular scenario?

You might choose an interface when you want to introduce more flexibility into your code by decoupling components, allowing for multiple roles or behaviors to be played by a class, and when you need to maintain a contract without enforcing a specific implementation.

How do abstract classes and interfaces handle the concept of immutability and state management?

Interfaces can be used to enforce immutability by defining properties that can only be initialized and not reinitialized, effectively controlling the state of an object. Abstract classes do not inherently support this pattern without additional implementation.

What is the significance of the shape and vehicle analogies in understanding abstract classes?

The analogies help to illustrate that a class can represent a general concept (like a shape or a vehicle) and share common properties or behaviors with other classes within that concept, which is the essence of using an abstract class to encapsulate commonality.

How can you explain the use of default implementation methods in abstract classes versus interfaces?

In abstract classes, default implementation methods can be consumed within the inheriting class, whereas in interfaces, the default implementation cannot be directly accessed by the implementing class; instead, the class must provide its own implementation or use the default implementation from the interface.

What is the main advantage of using composition with interfaces over inheritance with abstract classes?

Composition with interfaces provides greater flexibility, as it allows for the decoupling of components and the ability to mix and match behaviors in different contexts. It enables reusability of interfaces across various parts of an application, whereas inheritance may lead to tightly coupled and less flexible code structures.

Why might you prefer an abstract class in a scenario where multiple context-specific behaviors are needed?

In such scenarios, abstract classes can be used to define a common structure or behavior that is shared across different contexts, making it easier to manage and reuse the shared logic without having to implement multiple interfaces for each context-specific behavior.

What are the trade-offs between using inheritance and composition in software design?

Inheritance provides a succinct way to express related concepts and share common logic, but it can lead to tightly coupled code that is difficult to refactor. Composition, on the other hand, offers more flexibility and decoupling but may require more code and explicit orchestration of components.

How does the video script illustrate the concept of 'scopes' in relation to interfaces?

The concept of 'scopes' is illustrated by showing how interfaces can define a set of behaviors or properties that are accessible only within a certain scope or state of an object, providing a structured way to control access and maintain immutability.

What is the role of traits or roles in object-oriented programming, and how do interfaces support this concept?

Traits or roles represent specific behaviors or functionalities that an object might adopt within certain contexts. Interfaces support this concept by allowing a class to implement multiple interfaces, effectively playing multiple roles, which is not possible with abstract classes that enforce a single role or identity.

Outlines

00:00

📚 Introduction to Abstract Classes and Interfaces

This paragraph introduces the topic of abstract classes and interfaces, highlighting their importance in software development interviews. It emphasizes the need to understand the syntactical differences between the two and their use cases. The speaker shares personal experience of asking this question in interviews and suggests that even those who feel confident may struggle to articulate the nuances. The paragraph sets the stage for a detailed discussion on when and why to use abstract classes or interfaces, and it invites viewers to engage by liking, subscribing, and commenting.

05:01

🔍 Exploring Analogies and Use Cases

The second paragraph delves into analogies and practical examples to better understand abstract classes and interfaces. It uses shapes and vehicles to illustrate the concepts and contrasts them with programming realities. The speaker discusses the limitations and capabilities of both abstract classes and interfaces, such as the inability to instantiate them and their potential to contain static members. The paragraph also touches on the idea of implementing multiple interfaces versus inheriting from a single abstract class, and it provides examples of scenarios where one might be preferred over the other.

10:01

🤔 Decision-Making Between Abstract Classes and Interfaces

This paragraph focuses on the decision-making process when choosing between using an abstract class or an interface. It presents a scenario where both can be used interchangeably but advises against using abstract classes when additional responsibilities can be attached to the operation. The speaker introduces the concept of 'Scopes' and 'traits' or 'roles', explaining how interfaces enable these programming paradigms, which abstract classes cannot support. The paragraph concludes with a discussion on inheritance versus composition, emphasizing the flexibility and potential code volume trade-off when using interfaces over abstract classes.

Keywords

💡Abstract Class

An abstract class is a foundational class in object-oriented programming (OOP) that cannot be instantiated on its own but can serve as a base for other classes. It allows for the definition of both abstract methods (which must be implemented by subclasses) and concrete methods (which can provide default behavior). In the context of the video, abstract classes are depicted as a way to capture commonalities among different entities, suggesting that they are used to extract and encapsulate shared attributes or behaviors, which subclasses can then inherit and specialize.

💡Interface

An interface in OOP defines a contract or a blueprint of methods that classes must implement, without specifying how these methods should be implemented. Interfaces are used to ensure a certain set of functionalities across different classes. The video highlights interfaces as tools for decoupling components in code, facilitating the substitution of dependencies and increasing flexibility. By using interfaces, developers can define roles or behaviors that classes can adopt, without prescribing the exact way these behaviors should be executed.

💡Syntactical Difference

Syntactical differences refer to the distinct rules and structures used when defining abstract classes and interfaces. The video mentions, for example, that interfaces cannot have access modifiers for their methods (they are implicitly public), and do not support the declaration of fields, while abstract classes allow for more versatility, including the specification of access modifiers, fields, and constructors. These syntactical distinctions guide programmers on how to properly use each construct within their code.

💡Dependency Breaking

Dependency breaking is a technique highlighted in the video where interfaces are used to decouple components of the software, reducing direct dependencies between different parts of the code. This increases the code's flexibility and maintainability, as changes to one component do not necessarily require changes to the dependent components. By defining an interface, one can substitute the implementation behind the interface without altering the code that relies on it.

💡Composition vs. Inheritance

The video discusses the debate between using composition (achieved through interfaces) versus inheritance (through abstract classes or base classes) to extend or enhance the functionality of objects in OOP. Composition is favored for its flexibility and the ease with which it allows objects to be constructed from smaller, reusable components. In contrast, inheritance provides a straightforward means of sharing behavior and structure among related classes, but can lead to rigid and fragile code structures. The video illustrates both approaches, underscoring the context in which each is most beneficial.

💡Default Implementation

Default implementations refer to methods within an interface or an abstract class that are given a concrete implementation. This allows classes implementing the interface or inheriting from the abstract class to use these methods without the need for their own implementation. The video explains that while both abstract classes and interfaces can provide default implementations, the way they are consumed differs: default methods in interfaces cannot be accessed directly by the implementing class without referring to the interface.

💡Commonality Extraction

Commonality extraction is a concept described in the video as the process of identifying shared attributes or behaviors among a set of entities and encapsulating them into an abstract class. This technique allows for the creation of a more organized and modular code structure, where shared logic is centralized, reducing redundancy and facilitating maintenance. The video uses the example of shapes to illustrate how different types, like squares and circles, might share common properties or methods, which are then abstracted into a superclass.

💡Contract

In the context of the video, a contract refers to a set of defined methods in an interface that a class agrees to implement. This concept is crucial for understanding how interfaces are used to specify a minimum set of behaviors that must be provided by any class that implements the interface. The idea of a contract emphasizes the role of interfaces in ensuring a consistent API across different implementations, allowing for interchangeability and flexibility in the use of different concrete classes.

💡Decoupling

Decoupling is a principle in software engineering aimed at reducing dependencies between different parts of a system, thereby making it easier to change, maintain, and extend. The video illustrates how interfaces can be used to achieve decoupling by serving as a layer of abstraction between components. This allows for parts of the system to interact through well-defined interfaces rather than direct references, enhancing modularity and the ability to substitute components without affecting others.

💡Identity vs. Behavior

The distinction between identity and behavior is discussed in the video as a key factor in deciding whether to use an abstract class or an interface. Identity refers to what an object is, captured by inheritance and the 'is-a' relationship, suggesting a more static and hierarchical relationship. Behavior, on the other hand, focuses on what an object can do, represented by interfaces and the 'has-a' or 'can-do' relationship, which is more dynamic and flexible. This distinction helps guide the choice between abstract classes and interfaces based on whether the focus is on an object's inherent identity or its capabilities.

Highlights

The video discusses the differences between abstract classes and interfaces, a popular interview question.

Abstract classes and interfaces are syntactically different, with interfaces being more restrictive in terms of access modifiers.

Interfaces can only have public methods and cannot have access modifiers specified, unlike abstract classes.

Abstract classes can have fields, constructors, and any access modifier methods, while interfaces cannot.

Both abstract classes and interfaces cannot be instantiated and can contain static members.

A class can implement multiple interfaces but can only inherit from one abstract class due to the concept of identity.

Abstract classes are used when there is a commonality among classes, while interfaces are used to break dependencies and increase flexibility.

Examples of using abstract classes include shapes like squares and circles, while interfaces can be used for vehicles or animals.

In web development, abstract classes are less commonly used compared to interfaces.

Abstract classes can be used to create a structure where operations share commonalities, like in the example of a stopwatch timing operations.

Interfaces can be used for scope control, allowing for immutability and a structured way to use code.

Traits or roles, a programming paradigm, can only be implemented with interfaces, not abstract classes.

The debate between inheritance (using abstract classes) and composition (using interfaces) is discussed, with a preference for composition in most cases.

Inheritance provides succinct code but may lead to tightly coupled components, while composition offers flexibility at the cost of increased complexity.

The video concludes with a recommendation to use interfaces and composition for their flexibility, unless a clear commonality among classes justifies an abstract class.

The presenter invites viewers to like, subscribe, and leave comments or questions for further discussion.

The source code for the examples in the video is available for patrons on Patreon.

Transcripts

welcome back boys and girls today we're

going to be talking about abstract

classes and interfaces it is a very

popular interview question and I

personally liked asking it myself as

well the interview question goes like

this you first ask to explain the

difference between an abstract class and

an interface so what is the syntactical

difference how do you use it why would

you use one over the other one and

perhaps can you give me some examples as

you go through the explanation of these

questions there are a lot of points

where you can ask the candidate to drill

down into their EXP ation and at some

points people just run out of things to

say or they just don't know what to say

even now if you're sitting there and

you're thinking I I know everything

about abstract classes and interfaces if

I actually start interviewing you about

it you may struggle to explain some

points so if you ever struggled with

articulating your thoughts on abstract

classes and interfaces the differences

between the two and why would you use

one over the other one hopefully this

video can help you don't forget if

you're enjoying the video leave a like

And subscribe if you if you have any

questions make sure to leave them in the

comment section if you think there is

anything that I have missed go ahead and

leave it in the comment section as well

I have a C Core status out if you would

like to know c as I did highly recommend

you take a look at it before we actually

start looking at the code I want to

outline a general idea for abstract

classes and interfaces so you can get a

feeling for why would you want to use

one over the other one and perhaps an

idea of their shape so for abstract

classes there is a set of things there

is then a commonality amongst all of

those things and you're taking that

commonality and extracting it into an

abstract class with interfaces you have

two parts of your code to components

where one depends on the other one and

you want to break this dependency

because you want to substitute the thing

that it's depending on or the thing that

it's consuming essentially introducing

more flexibility into your code this is

where the contract the bridge the

interface comes in ultimately used to

decouple your components in code with

this let's go ahead and get started here

I have a bunch of files we're going to

go through them one by one the first is

the abstract class over here and then

the interfaces we're going to take a

look at the difference between the two

syntactically first interfaces are a

little bit smaller so the first thing

that we can take a look at is you cannot

actually have access modifiers or you

cannot put the ones that you want you

can only put public you can make them

explicit but you can't actually specify

them with abstract classes you can put

whatever access modifier that you want

and the only thing that you can Define

on interfaces are methods either

abstract methods or just method

definitions which are the same on the

abstract class which are abstract

methods over here and then default

implementation methods you can also have

them on the abstract class however there

is a slight difference between the two

so a default implementation method on an

abstract class can be consumed within

the inheriting class so s string can be

used over here and then if I instantiate

a square I can also consume that

function on there if I'm using an

interface the space which is

implementing the interface I cannot

reach the default implementation on here

I will actually have to go to the

interface itself so here I will be able

to reach this function okay now you can

also specify properties on an interface

however that is only going to be

concerned for the methods of the

property because a property is three

parts two methods getter and Setter

depending on which ones you specify and

also a field with an abstract class you

can actually get Fields if you specify a

property on an interface you don't

actually get a field and then another

thing that an abstract class can have

that an interface cannot have is a

Constructor and that is pretty much it

for the differences between the two you

can also talk about commonalities

between the two how are abstract classes

and interfaces similar neither of them

can be instantiated they both both can

still contain static members and that's

about it now moving on to how you would

actually use an abstract class versus an

interface you implement an interface and

you inherit from an abstract class you

can Implement multiple interfaces on a

single class and then you can only

inherit from one abstract class the

reason you can only inherit from one is

because there is a notion of identity a

square is a shape a square cannot be an

animal and shape a square at that point

has schizophrenia so when we're talking

about implementing an interface it is

more do I have this Behavior am I

playing this role these are partly the

ideas that you can figure out when

you're thinking or you're talking about

implementing some kind of feature is it

a thing or do we have this Behavior May

sway you in one direction or the other

whether you should be choosing an

abstract class or an interface so that's

about it for the difference between the

two if you're wondering about the

example that I have over here it's a

shape example a square is a shape a

circle is a shape you can then have

triangles you can have other examples

such as Vehicles animals so truck

motorcycle car those are vehicles for

Animals you have red cat Etc these are

very good analogies to understand

abstract classes however when you

actually get to programming uh the

concepts vary slightly and generally in

web development you don't really get

that many opportunities to create

abstract classes like that although

there are places like video games where

if you have some kind of objects on the

plane you get a lot of options to

basically say ah I should have this

abstract class where all of the objects

have some kind of position in the game

for the interfaces I have an example of

a cache so if for example I have my

application using cash everywhere if I

want to substitute a cash at

implementation at any point going from

redis to M cach or to some kind of other

cache that is going to come out in the

in the future I don't have to change the

whole application to depend on a

different service I just substitute the

implementation for the interface and and

my application should just keep working

as it does why would you actually use an

abstract class over an interface or an

interface over an abstract class in some

cases there really is no difference

whether you use one or the other one and

Abstract classes can behave like

interfaces and this is what this example

is about I'm going to tell you what to

do in this situation for example we have

something that depicts an operation this

is really to Mark functions okay we have

an operation that is going to increment

we then have an I try so we try to

execute an operation and the operation

that we depend on is this interface we

then have an night time again we start

up a stop stopwatch and we try to time

the time it takes to execute an

operation and again we depend on this

eye operation we then have the

individual permutations where we compose

things together now with abstract

classes you can effectively arrive at

the same structure where you have your

abstract operation abstract try uh

really the same implementation abstract

time again the same implementation and

then abstract operation and the same

permutation so really no difference

between the two what should you be using

in this situation you shouldn't be using

abstract classes because at that point

you can actually bolt on more

responsibilities to this operation

rather than just being used in this

mechanism if all operations are sharing

some kind of commonality between all of

them which is not present over here you

should be reaching for abstract classes

and again to reiterate in this example

we don't have that commonality so

there's no reason to use an abstract

class unless you're actually foreseeing

that commonality coming in the future

then you want to opt in for an abstract

class now for favoring interfaces there

are just some things that you you can do

with interfaces that you cannot do with

abstract classes and here we have the

first example I am naming it Scopes

because you can effectively control how

much of the object you want to access

using an interface so for example we

have states that you can initialize and

that after initialization it is ready to

be read so we accept some kind of state

we initialize it and then it's ready to

be consumed where we cannot change it we

cannot reinitialize it again effectively

giving us immutability and a way a

structured way to use our code so we

can't actually make mistakes another

things that interfaces can be used for

and it's very rare in the C world but a

concept called traits or roles where you

have some kind of context where the

functionality only belongs to that

context a class that can be used inside

that context implements this interface

effectively enabling this programming

Paradigm which you cannot do with

abstract classes because if you have

many context many roles and a class can

play many roles you should be able to

implement multiple interfaces if these

are abstract classes you can only play

one role which defeats the whole purpose

of this Paradigm so interfaces can only

be used in these scenarios and by the

way for Scopes you can get away with

using classes for it but you're going to

have to create a new class with its own

individual functionality and if you have

shared States between those classes and

you have to constantly transition it it

just becomes more code volume rather

than bolting on all of those Scopes onto

one class okay and now for the big

debate of inheritance versus composition

inheritance meaning you are trying to

use classes and Abstract classes and

inheritance in order to extend your

application or extend Behavior or add

more Behavior to your application and

then composition is for interfaces where

you're decoupling everything with

interfaces and then composing it

together it's uh not really a big debate

everybody will generally tell you prefer

composition over inheritance and I

generally agree however in this example

we are implementing the same thing in

two different ways using abstract

classes and interfaces and you're going

to see that okay

inheritance has its place with some

benefits however composition also has

its benefits and we're going to see what

they are in just a second here we have

an example we want to send an in

interface there is some kind of

commonality and abstraction between all

of the notifications that we can send

where we check should this notification

be sent and should we execute it these

are the two main abstractions we have a

check and we have an execute when we

want to alert an admin this is what the

this is the condition that we're

checking and this is the actual

execution Logic for how we're sending a

notification then we have a notify sweet

spot so again condition and then

actually sending the the notification

currently these two implementations are

the same however imagine that we're just

getting different users that we want to

notify the notification itself is a

slightly different slightly different

text subject are we sending to mobile

email right so this can vary quite a bit

but understand that what we have here is

we have a coupling between a condition

and the actual Logic for executing a

notification to this notification

abstract class into this process over

here and this yields us a very succinct

way of expressing what notifications we

have and for what reasons and to where

and how they're being sent the downsides

here is that this logic cannot be reused

in other places now if there are no

other places to use it in this is 100%

fine this is preferable if this logic

should be used in other places you go

with interfaces your de coupling

notifications from the actual way that

you're sending notification and you

decoupling it from how you're actually

going to perform the check you create

interfaces for it so you have some kind

of constraint and you have some kind of

notification that you want to perform

and then to replace that abstract class

we actually have a class where we're

composing the interfaces together and

then we're performing The same logic and

then the individual implementations

here's the admin constraint The Sweet

Spot constra straint and then the actual

notification constraint these can now be

surfaced in any other place in your

application and where you're actually

using them at those points you actually

have to compose this feature together so

the second option a lot more flexible

but also a little bit more verbose and

that is the main trade-off that you have

between interfaces and Abstract classes

and inheritance and composition

inheritance when used correctly you have

very succinct code which can only really

be present in one place and you don't

have to wonder about if it's being used

in another place these are really

isolated units where these notifications

are notifications it's not a thing that

behaves like a notification that can be

placed anywhere within your application

where with interfaces the reason people

will just say just prefer composition

because then you don't have to make this

distinction between H is this a thing

that doesn't need to be used anywhere

else you just Define your interfaces

everything is decoupled and then you

have to explicitly start defining places

where they compose and then you actually

have to do the composition or

orchestration at some point by going

default composition you're paying the

price of code volume and complexity you

have a lot more components however that

is going to give you flexibility over

implementations with inheritance you

generally get a very succinct

implementation where the logic is very

closely collocated and depends on each

other so if the structure is correct

it's very hard to mess it up up the

potential price that you need to pay

with inheritance is that abstract class

that you have extracted if that

abstraction has to be used in other

places other than these set of classes

that you extracted the common the

commonality from then you're in trouble

then you will need to go ahead and

refactor your code into it being an

interface and start defining these Place

places of composition and this will be

it for this video thank you very much

for watching hopefully you have found it

useful if you did don't forget to leave

a like And subscribe if you have any

questions again in the comment section

if you would like the source code for

this video as well as my other videos

please come support me on patreon I will

really appreciate it and a big and

special thank you goes out to all of my

Patron supporters you help me make these

videos as always thank you for watching

and have a good day