#65 Need of Interface in Java

Summary

The video script explores the concept of needs and design patterns in software development, using the example of a developer requiring a laptop to code. It explains how a developer's dependency on a specific tool, like a laptop, can be abstracted to a more general 'computer' class, promoting loose coupling and flexibility. The script illustrates the transition from concrete classes to abstract classes and interfaces, emphasizing the importance of generalization in coding to handle different types of computers, like laptops or desktops, seamlessly.

Takeaways

• 💻 When joining a company as a developer, you often receive a laptop to work on, such as a MacBook.
• 🖥️ Developers need computers to write code, whether it be a laptop or a desktop.
• 👨‍💻 A developer class can be created, which requires a laptop object to perform tasks like coding, compiling, and running applications.
• 🧑‍💼 Companies might provide desktops instead of laptops, which can also perform the same tasks and often faster.
• 🔄 To make the code more flexible, a developer should not be dependent on a specific type of computer (laptop or desktop).
• 🏗️ Creating a parent class 'Computer' can generalize the concept, allowing both laptops and desktops to inherit from it.
• 🔀 Using abstract classes or interfaces helps in creating flexible and loosely coupled applications, where the developer object depends on a 'Computer' type.
• 🔧 Interfaces and abstract classes allow developers to generalize functionality, making it easier to work with different types of objects (e.g., laptops, desktops).
• 🚀 An interface can be used instead of an abstract class to declare methods that any implementing class must define, ensuring flexibility and generalization.
• 🎥 Reviewing the video and practicing the concepts is essential for understanding the power and implementation of interfaces and abstract classes in design.

Q & A

What is the main example used in the script to illustrate the concept of a need in software development?

The main example used in the script is that of a developer who needs a laptop to write code and build applications in a company.

Why does the script mention the preference for a Macbook for developers?

The script mentions Macbooks as an example of a desirable tool that developers might prefer, emphasizing the importance of providing suitable equipment for developers to work efficiently.

What is the problem with the initial approach of associating developers directly with laptops in the script?

The problem is that the initial approach creates a tight coupling where developers are dependent on a specific type of computer (laptops), which limits flexibility and scalability in the software development environment.

What is the solution proposed in the script to make the developer's code writing process more flexible?

The solution proposed is to create an abstract class called 'Computer' that both 'Laptop' and 'Desktop' classes inherit from, allowing developers to be dependent on a more general concept of a computer rather than specific types.

Why is creating an abstract class for 'Computer' considered an improvement over the initial approach?

Creating an abstract class for 'Computer' allows for a more generalized and flexible approach, where developers can work with any type of computer, not just laptops, making the code more adaptable to different environments and requirements.

What is the role of the 'code' method in the Laptop and Desktop classes as described in the script?

The 'code' method in both the Laptop and Desktop classes represents the action of writing and compiling code. It is a method that can be called on any object of these classes to simulate the process of coding.

How does the script use the concept of inheritance to solve the initial problem?

The script uses inheritance by having both the Laptop and Desktop classes inherit from a common abstract class called 'Computer', which allows for a more flexible and abstract representation of the computing devices used by developers.

What is the alternative to using an abstract class as discussed in the script?

The alternative to using an abstract class is to use an interface, which provides a way to define a contract for the 'code' method without specifying its implementation, allowing for even greater flexibility.

Why might a company prefer to give a desktop to a developer instead of a laptop?

A company might prefer to give a desktop to a developer because desktops can be faster and more powerful, providing a better environment for coding and application development.

What is the significance of the term 'loosely coupled' in the context of the script?

The term 'loosely coupled' refers to the design principle where components of a system are less dependent on each other, allowing for greater flexibility and easier maintenance, as illustrated by the developer being dependent on 'Computer' instead of specific devices like 'Laptop' or 'Desktop'.

How does the script illustrate the importance of generalizing in software design?

The script illustrates the importance of generalizing by showing how using a more abstract class or interface ('Computer') instead of specific classes ('Laptop', 'Desktop') allows for a more flexible and scalable design that can adapt to various types of computing devices.

Outlines

00:00

💼 Understanding Developer Needs and the Role of a Laptop

This paragraph introduces the concept of a 'need' in the context of software development. It uses the example of a developer joining a company and the expectation of being provided with a laptop to write code and build applications. The scenario explores the dependency of developers on laptops for their work and illustrates this with a hypothetical class structure in programming, where a 'Developer' class might interact with a 'Laptop' class to perform coding tasks. The paragraph emphasizes the practicality of having a laptop for developers but also raises the question of flexibility and dependency in tool usage.

05:00

🖥️ Transitioning from Tight Coupling to Loose Coupling with Abstraction

The second paragraph delves into the principles of object-oriented programming, specifically focusing on the concepts of abstraction, interfaces, and inheritance. It discusses the issue of tight coupling between the 'Developer' class and the 'Laptop' class, suggesting that this coupling limits flexibility. To address this, the paragraph proposes the creation of an abstract 'Computer' class, from which both 'Laptop' and 'Desktop' classes can inherit. This abstraction allows a 'Developer' to work with any type of computer, thus promoting loose coupling and making the code more adaptable to different environments. The summary also touches on the use of abstract classes and interfaces to generalize the concept of a 'Computer', emphasizing the importance of these programming constructs in creating flexible and maintainable code.

Keywords

💡Need

In the context of the video, 'need' refers to a prerequisite or essential condition for completing a task or achieving a goal. The video uses the example of a developer needing a laptop to write code, illustrating the concept of dependency in software development. It highlights the importance of identifying actual needs versus perceived ones to create flexible and adaptable systems.

💡Interface

The term 'interface' in the video script is used metaphorically to discuss the interaction between a developer and their tools, such as a laptop or desktop. It is also a technical term in computer science that defines a shared boundary between two systems or objects, which the video uses to explain the concept of abstraction and loose coupling in software design.

💡Developer

A 'developer' is a person who designs, codes, and maintains applications or systems. The script uses the developer as a central figure to explore the concept of needs and dependencies in a work environment. It also discusses the developer's role in the context of using different types of computers, such as laptops and desktops, to perform their coding tasks.

💡Laptop

A 'laptop' is a portable computer that is used in the script to represent a specific tool a developer might need to perform their job. The video discusses the dependency of a developer on a laptop and later challenges this dependency by introducing the concept of a more generalized 'computer' class.

💡Desktop

A 'desktop' refers to a personal computer designed for use at a single location due to its size and power requirements. In the video, the desktop is introduced as an alternative to a laptop, demonstrating the flexibility required in software design to accommodate different types of computing devices.

💡Abstract Class

An 'abstract class' in object-oriented programming is a class that cannot be instantiated on its own and is often used as a base class for other classes. The script uses the concept of an abstract class to illustrate creating a generalized 'computer' class that can represent both laptops and desktops, promoting flexibility in software design.

💡Coupling

'Coupling' in software design refers to the degree of direct knowledge one class has of another. The script discusses 'tight coupling' where a developer is specifically dependent on a laptop, and contrasts it with 'loose coupling' where the dependency is on a more general 'computer' class, allowing for greater flexibility.

💡Method

A 'method' in programming is a procedure associated with a message that is sent to an object. The video script uses the method 'code' within the 'laptop' and 'desktop' classes to demonstrate how objects of these classes can perform tasks, such as compiling and running code.

💡Inheritance

'Inheritance' is a mechanism in object-oriented programming where a new class (subclass) is created from an existing class (superclass), inheriting its properties and behaviors. The script explains how both 'laptop' and 'desktop' can inherit from a general 'computer' class, showcasing the power of inheritance in creating a flexible code structure.

💡Interface (in programming)

An 'interface' in programming defines a contract for methods that must be implemented by any class that uses the interface. The script suggests using an interface instead of an abstract class to further abstract the concept of a 'computer', allowing for even greater flexibility and the ability to define behavior without specifying how it must be implemented.

💡Generalization

Generalization is the process of creating a general concept or class from more specific ones. The video script uses generalization to move from specific classes like 'laptop' and 'desktop' to a more general 'computer' class, which simplifies the developer's dependency and makes the code more adaptable to different types of computing devices.

Highlights

Understanding the concept of 'need' in software interfaces through the example of a developer's requirements.

Developers joining a company expect to be provided with a laptop to write code and build applications.

The example of a 'laptop' class in object-oriented programming to illustrate the dependency of a developer on a tool to perform their task.

Introduction of a 'code' method within the 'laptop' class to simulate the process of writing, compiling, and running code.

The scenario where a developer requests a laptop to write code, emphasizing the need for a specific tool.

The creation of a 'laptop' object to fulfill the developer's need for a tool to write code.

The concept that every developer might need a different laptop, implying the need for multiple objects.

The alternative of a 'desktop' being provided by a company instead of a laptop, challenging the developer's dependency on a specific tool.

The introduction of a 'computer' class as an abstract concept to generalize the type of tool a developer might use.

The idea of 'loose coupling' in software design to make applications more flexible and not dependent on specific implementations.

The demonstration of using a 'computer' reference to pass either a 'laptop' or 'desktop' object to a developer.

The explanation of how the 'code' method is called based on the actual object passed, not the reference type.

The practical application of abstract classes and interfaces in software design to improve flexibility.

The transition from concrete classes like 'laptop' and 'desktop' to the abstract 'computer' class for better design.

The importance of abstract classes in creating an abstraction layer that simplifies the complexity of software design.

The option to use interfaces instead of abstract classes for even greater flexibility in software design.

The demonstration of how interfaces allow for an 'interface reference' rather than a class reference, enhancing design flexibility.

The encouragement for developers to generalize concepts in software design, similar to how we generalize in real life.

Transcripts

let's try to understand what is a need

for the interface now for that let's

take an example here so let's say we

have a class here and so the example

which I'm trying to take here is for the

developers let's say when you join a

company of course as a developer when

you join a company you want to write

code right you want to build application

and if you have seen the trend whenever

you join a company most of the company

will give you a laptop to work on and

luckily if you get a Macbook that's

great so they give you a laptop right so

that's that's the thing right if you

want to work in a company let's say if

you go to our office and if you want to

work there you will say hey I want a

laptop so in this case let's say you are

a developer okay so I will say you are a

deaf right of course you're a human but

let's say you're a developer and then as

a developer what you do you make

applications right or maybe I can say

you write code

ulcerative app you you develop

applications right now when you say you

are developing an application of course

you will say

coding okay you're building an

application here of course as a company

if I want to build a product I have to

hire developers now in this case let's

say if I hire a developer let's say

developer name is Naveen and then if you

say new developer and with this object

Naveen I can say Naveen dot Dev app

right so I want I mean to develop

application and if I compile this code

and if I run it perfectly works right

now let's say

if I say hey you know I will make an

application but I need a laptop first I

cannot work without laptop but we don't

have laptop right so what I will do is I

will create a laptop class I will say

class laptop and in this class laptop of

course in a laptop what you do is you

write code and I can say calling

right in fact what laptop when you say

code you it basically you code the new

compile then you run so you do all those

stuff right so I'm saying code compile

and run and now as a developer what I

want is if I if you ask me to write a

code what I will do is I will just say

hey give me a laptop so basically you

have to accept a laptop object here

that's right you can also pass the

object so this developer will say give

me a laptop and then I will write code

so here instead of saying this you can

simply say lab dot code right now since

you have a laptop object you can

basically call this method called code

and it will work so what I'm doing is I

got two classes here which one is

developer and second is laptop and

inside laptop class I have a method

which is code and then once I pass this

object I can simply code right now the

only thing is when you ask a developer

to write a code developer will say hey

give me a laptop so that means first you

have to create an object of laptop so I

was a laptop lap is equal to the new

laptop so we got a laptop object of

course every developer needs a different

different laptop object so let's say if

you hire five developers you need five

laptops to give them

okay I was a lab here now this should

work there's no problem if you can see

the code everything should look good uh

if I run you can see it still works so

basically we are saying code compiled

one so what you're doing is from the

main method you are calling Dev app

which is here and then you are passing

the laptop object okay so you're passing

this object here and when you accept

this object you're calling the code

method so it will call this code method

and you execute this part everything

works well right now the only thing is

do you really need a laptop see in some

companies they give you a desktop right

so if you go to the office you they will

have a desktop where you have a monitor

you have a desktop a good desktop which

works so why as a developer you are

asking for a laptop what if company

wants to give you a desktop you can't

say hey I cannot work without laptop

right you should be able to work on any

computer

so let's say you also get an option of

desktop there in fact in desktop as well

I can do the same thing but I will say

faster like desktops are always faster

than a laptop right so you can see when

you're coding uh it says code compiled

One faster because it works fast now

what if a company says hey you know I we

don't have laptops with us but what we

have is we have desktop our desk is

equal to new desktop and they don't want

to pass the laptop object so that when

the company says Hey Naveen you have to

work you have to make an application and

what we are giving you is not laptop we

are giving you a desktop now nobody will

say I can't work you can see Naveen says

I can't develop application because my

application only needs laptop you can't

do that so writing laptop here is an

issue we can't do that right so how do

we solve this problem and that's what

you know when I was talking about

abstract class and interface I told you

about the design thing right so when you

back an application you have to make it

more flexible here we are what you are

doing is you're doing a tight coupling

here which is you are saying that

developer is dependent on a laptop no

developer is not dependent on laptop

developer is dependent on a computer a

computer can be anything your computer

can be a laptop a computer can be a

desktop so if you want to improve this

example what you can do is you can

create a class called computer okay and

in this computer class you can say

public void code and basically you know

I want to keep this empty because I

don't want with a code because we don't

computer does not exist right it's just

a concept

and I can say a laptop is actually a

computer so when you do that the

advantages in fact desktop is also a

computer so when you do that what

happens is now both this laptop and

desktop they are computer so when I'm

creating a reference of it so can I say

computer lab is equal to new laptop and

computer

desk is on the new desktop we can do

that right we can create a reference of

a patent class an object of a subclass

and that's what we are doing here same

thing can be applicable here right as a

developer you are focused more on the

computer not on laptop or desktop the

moment you do that you can say

everything is working there's no problem

here is because what you are passing

here is Dex desk right which desktop

basically but that is referred as a

computer and what you are referring here

is a computer there's no mismatch here

you're passing a computer reference you

are accepting a computer reference but

when you call code it will be called

based on what object you are passing so

basically we are passing desktop object

So when you say code it will call the

code of the desktop not of the laptop

let me show you so if I compile this

code and run you can see it says faster

that's desktop but now if I pass a

laptop let's say computer company

decided to send you a laptop and now

when you compile and run you can see it

says code compile and when there is no

faster here that means that's laptop

code

so that's how you design the application

right to make it Loosely coupled where

your developer object is not dependent

on the laptop or desktop it is dependent

on the computer any computer will do a

mobile phone also do because that's a

computer now there's one change

see if it if you look at this code we're

doing nothing right so instead of

defining it here can I simply declare

this and we know when you're declaring

it we can make it abstract and since

your method is abstract you can also

make your class abstract and problem

solved and that's the importance of

abstract class right you can create that

abstraction layer where you say we are

not working with laptop and desktop in

real world as well we do that right uh

sometimes we don't mention rows or

lilies or sunflower we simply say

flowers right we don't say apartment or

a villa or anything we say house right

so we try to generalize things in real

life in real in virtual world as well

it's good to generalize things instead

of specializing things there's one more

don't you think we can also use

interface issue of using abstract class

so we are using interface we don't need

public abstract the only change you have

to make is instead of using App extends

we have to say implements

and that's the beauty of interfaces

right

uh I know we have written a lot of code

maybe you have to watch this video once

again to understand and try it by

yourself that's when you will understand

the power of the interfaces and what you

are creating here is not the classes

reference we are getting interface

reference yeah and that's the importance

of the interface