#7.3 Interoperability How Kotlin code is compiled and Converted to a Class

hi Lisa Tsering Siddarth and welcome to
the next topic of discussion that is
interoperability in case of Cortland now
this is going to be the most interesting
part of this series of coddling
programming now at the very beginning of
this series I told you that Kotlin
supports interoperability now what does
this means this means that you can
simply call any Java function from the
Kotlin and vice versa that is you can
call the coordinate functions from the
java file this simply means that you can
have both Java and Kirkland files
present inside your same application so
how does this work actually so for that
you have to first understand this thing
how a Java code runs now the whole
process is actually divided into two
parts the first is the compile time and
the second part is the run time now
during the compile time the compiler
simply converts your Java file that
contains the Java code into the bytecode
now this bytecode is actually stored
inside the file which has the extension
of dot class so here I have my demo dot
Java and here I have my demo dot class
that simply contains the bytecode which
is the more refined form of the code
which is actually understandable by the
Java Virtual Machine so the Java Virtual
Machine with the help of some other
libraries simply makes your code execute
and hence your program is now up and
running now what happens in case of
Cortland now in case of Cortland the
whole process is again divided into the
compile time and the run time now in
case of compile time we have my demo dot
Katie
we have dot Katie extension file that
simply contains the Kotlin code similar
to what we have here is Java code
now the Cortland compiler simply
converts the Katie file extension into
my demo Katie
dot class that simply contains the
bytecode now here you can notice I have
my demo dot Katie so the class file name
is actually my demo Katie dot class this
is the standard naming convention in
case of
Orlin when the compiler converts this
file into the bytecode now this file
contains the bytecode right so here if
you compare the both side you will find
here we have bytecode and again in case
of court Lane we have the bytecode now
since we have bytecode in both the forms
now this bytecode
in the runtime will be executed with the
help of Java Virtual Machine and then
your program will be now up and running
so this is how our typical Java code
runs and the Cortland code runs so now
if you notice in both the case we are
having the bytecode right and now
proceeding forward let us now check out
how does a typical scotland file or code
looks like so what we see inside the
Cortland file is this now suppose our
Cortland file has the name of my first
dot Katie stored inside the source
folder and here is our code suppose I
have a method of function ad that takes
a parameter of a integer and simply
returns a boolean value and this is a
method body now at the high level we
actually see this code right now what
happens after the compilation to the my
first dot KD file now soon after the
compilation this file is actually
converted into my first Katie dot class
right and internally what the compiler
to is that simply adds the wrapper of
class on top of this function so
internally what happens is that this
code is actually converted into this
code such as I have now class my first
Katie right inside which I have public
static boolean add int a now if you
compare this method and this method you
will notice that this is a high level
method in case of Cortland and now this
is a typical method in case of Java so
we have public static now by default all
the methods in case of Cortland are
actually public in nature so we have
public here now since this method is a
high level method so it has been
converted to the static right and here
we have a boolean return type so
we have a boolean return type and this
is a method name with an integer a
parameter and now inside this we have a
method body so what we see internally
does not appears to be same after the
code is compiled right so now since we
know the internal structure of the my
first katydid class so this code can be
called from any of the Java files
present inside your application so how
can we access the Cortland file from a
Java file we will check out in the next
video so please make sure you watch my
next video because it is a very
important part of this course so see you
guys in the next video
thank you