#8.9 Kotlin Programming for beginners INTERFACE Video Lecture - Kotlin

hi Lisa stirrings in the heart once
again welcome to the next video of this
quarter lean fundamentals in this video
we will talk about water interfaces in
case of Kotlin so let us first check out
the practical example and then the
theory so here inside the IntelliJ IDE
this is the example that we took in the
previous video right about the
abstraction in case of Cortland now
suppose if I change this abstract open
class - let's say interface and now the
interface is not a class always remember
this it is something like a listener
that you want some service such as on
click of button something should happen
on touch of a keyboard something should
happen so in that case the listener is
actually the interface right you want
some short-term or temporary service so
in that case we create a interface as
for example in Android suppose someone
click on a button so on click of a
button something should happen right so
we implement the onclick method in case
of Android so that is the main purpose
of interface in case of Kotlin as well
so here let us change the name of
interface let's say my interface
listener right and now here whatever you
define inside an interface is actually
by default abstract in nature such as
where let's say name string well it
should not be named here because we are
using the interface but it's a variable
name so let it be named by default right
now by default whatever you declare
inside the interface is actually
abstract and also open in nature because
abstract variables and methods are by
default open in nature that we saw in
the previous video right and this
abstract is redundant so we need to
remove it as well and also abstract
keywords and also abstract methods and
also the variables should not contain
some default value like here let's say
dummy name like this so the abstract
variables should not contain some
initialized value it should be your
empty declaration like
this so let us remove it as well because
it is redundant so here I have simply
written a comment statement properties
in case of interphase are abstract by
default right and now suppose let us
define a function let us say eat or
let's say on click and here suppose if I
define a body now if you define a body
then this method is actually a normal
function which is actually public in
nature but in this case it is not final
in nature because in case of interface
nothing is final
everything is open in nature so this on
click method is basically is by default
open in nature it is not final so always
remember in case of interface nothing is
final
everything is open in nature so let me
write a comment line for you so the
normal methods are public and open by
default not final always remember and
now here this public and open keyword
are redundant again so let us remove it
and now let us define one more method
let's say function of on touch on touch
of a image something should happen now
here if I define here the body and
declare here abstract then the compiler
is again not happy because the abstract
methods cannot contain the body right so
here either I have to remove this or I
have to remove this from here but but I
want this method to be abstract in
nature right so here what I will do is I
will simply remove the body now since it
is abstract in nature so you have to
compulsorily
override it inside the class that
implements this interface and now this
was all about the properties inside the
interface abstract methods and also the
normal methods and now suppose I have a
class of Indian let's say let's remove
it here and let us modify the code let
us say class of button now suppose if I
want to implement this interface for
this button so what I will do is I will
simply use class button : then simply
use my interface listener now this is
actually the interface suppose you want
to inherit some
let's say person then for that you need
to use this syntax percent followed by
the primary constructor right as we did
in the previous videos but if you want
to implement the interface then you just
have to specify colon followed by
interface name there is no primary
constructor here just because the
interface cannot be instantiated so here
I have simply written the command line
you cannot create the instance of the
abstract class let's make it interface
so the interface similar to the abstract
class cannot be instantiated what I am
talking about is inside the main method
you simply cannot define where let's say
my object equal to my interface listener
you cannot do it because my interface
listener cannot contain a constructor as
well it is just an interface not a class
so always remember this similar to
absurd classes the interface cannot be
instantiated let us remove it and now
here let us remove the person as well so
this is the syntax to get all the
properties of this my interface listener
inside the class of button and now let
us call it my button as of now just to
avoid any confusion and now here it
shows some error that if you are using
the interface here then you must
override this abstract method that is on
touch and also this abstract variable
name and now here this abstract abstract
keyword is redundant
so again methods in interface are
abstract by default so to rectify this
error we need to override this variable
name and also function on touch because
they are abstract in nature so I will
simply override let's say override where
name of the type of string and simply
assign it a default value let's say
dummy name it is totally up to your
choice and now let us overwrite this
abstract method as well function on
touch so here I will simply use override
keyword space function let us say on
touch
so here the IntelliJ IDE simply creates
a placeholder to do for us where I will
simply define our own code right like
this now coming to this point function
on click now this function on click is
not abstract in nature because it has a
method body so it is actually behaving
like a normal method so if you want it
is totally up to your choice either you
override that method or not if you want
you can also override it it is totally
up to your choice right and if you want
you can also call the super
implementation of this method like super
dot on click method so as of now I do
not want it so let us remove it you may
or may not override this method right
because this is a normal method now
inside the main method what I am going
to do is I will simply create the
instance of this class of my button
because this my button is actually of
the type of class so we can instantiate
it where let's say and after this I will
simply call my button dot let's say on
touch right so this was simply trigger
this method present here on touch and
also I will call my button dot let's say
on click and this will simply trigger
this method present here this on click
now let us define our code here let us
say print line button was test and here
print line as well button was right and
now suppose if I run the code right now
then these two statements is simply
going to print button was touched and
also button was clicked in the output
consoled so here in the output we get
button was clicked button was touched
and clicked like this and now suppose
inside the on click method suppose I
have some print statement let us say
print line on click interface codes
right like this so this is the print
line statement inside the on click
method now suppose I want to print this
statement as well so for that what I
will do is inside the on click method
method inside the my button class what i
will do is i
simply use the super keyword super dot I
will simply call on click method so this
will simply trigger the superclass
method that is this one now remember
this is not the class right but still we
are inheriting all the properties of my
interface listener inside my button
class so let us now run the code so in
the output we get button was touched
then on Blake interface code button
clicked was called and then button was
clicked so this is how we call the
superclass method right like we have
done here super dot on click now if you
want you can also remove this on click
code here it will show no error right
but if you remove this untouched method
then the compiler is not happy because
this on touch method is actually
abstract in nature so you need to
override it anyhow here inside the
derived plus and now suppose I have one
more interface so let us copy this
interface my second interface listener
let's let's trim down the name my second
interface right and now inside both the
interface let us modify our code so here
I will simply remove variable name and
also here name and now I will simply
convert this function on touch into the
normal method so I will simply define
the body as let's say print line on
touch was called from my second
interface on touch was called from my
second interface now similarly here I
will so here I have simply modified my
code inside my interface listener I am
having on touch abstract method without
any body now same method I am having in
inside my second interface but it is now
behaving as a normal method it is no
longer abstract method now this onclick
method and this one click method appears
to be same right so suppose I want to
implement both the listener inside my
button class so what I will do is this
is our first listener and then I will
simply give a comma and then implement
my second interface like this right
and here let us remove the statement and
now let us remove the code as well here
and now here it shows some error that
you need to implement the abstract
method so simply press alt enter
implement the members and it will show
you two options my cortland my interface
listener my second interface we need to
override this on touch method which is
actually abstract in nature so as per
our expectation the error should have
been gone but here if you notice the
error is not gone but but as per the
rule we have simply overwritten this
abstract method now rest of the methods
are actually normal methods that should
be optional to override such as on click
method and also on touch method of the
second interface but here we are using
two interface now these two interface
have two methods on touch and on click
and in one of the case we have on test
method as abstract so we need to
override this on touch method
compulsorily inside my button class but
what about on click method this is
normal method here and this is again the
normal method now as per the rule if
there are two interface and there are
two normal methods of the same name
inside both the interface then you need
to override that method as well so here
I have to simply press alt enter and
simply inherit the on click method here
like this so this rectifies our error
right now suppose I create the instance
of my button like this and call my
button dot on touch and my button dot on
click right now if I simply going to
call this button dot on touch method
that is simply going to trigger this
method down the side inside my button
class and if I want to trigger the
superclass method then I then I will
simply use super dot on touch right so
this statement will simply trigger the
on touch method here because this is a
normal method and this is the abstract
method without any body so there is no
point of this method being called
because this method don't have any code
and here I have some
right so this statement will simply
trigger the superclass on touch method
of my second interface that has some
body and now suppose this statement is
executed my button dot on click so this
will simply trigger this local method of
on click present inside my button class
so here if I call let's say super dot on
click so what will happen it will simply
show some error because the compiler
will be confused that super dot on click
method is actually present in both the
case that is in this interface and also
inside this interface so it gets simply
confused which method to call right so
in that case we have a solution here we
can simply define super and simply pass
the name of the interface super my
interface listener dot on click and
again if you want to call this my second
interface on click method then you can
simply call super simply pass the name
of my second interface dot on click
right so these two statements are simply
going to trigger the respective on click
methods present inside their interface
here and here like this so always
remember this while you are using the
two interface and if both the interface
contains the same method name so how to
handle that situation I just showed you
in this example so this was all about
the practical example now let us jump
back to the theoretical examples so the
interface can contain both normal
methods and also abstract methods so
always remember this it can contain
normal as well as abstract methods but
in case of property they can contain
only abstract property that is you
cannot initialize any variable inside
the interface now proceeding forward the
interface are not a class so do remember
this and now similar to the abstract
class you cannot create the instance of
the interface because the interface is
not a class it is something different
thing that only provides a short term
service such as a button click or
touch when you check the checkbox when
you try to open the dialog box and
something like that so it simply
provides a short term service right the
interface so this was all about the
interface in case of Cortland