#7.4 Interoperability Calling Kotlin functions from Java file and vice-versa

hi Lisa Tsering Siddarth and welcome to
the next part of this video series of
interoperability now in this video we
will check out the demo so here inside
the IntelliJ IDE I have my first dot kt+
right now inside this I am having a main
function now down the side I will simply
define one more function of add let's
say add a of the type of int and then B
of the type of end and now this will
simply return an int value so here I
will simply return the sum of a plus B
which is actually the integer value now
here inside the source folder I will
simply create my Java file let us call
it as let's say my Java file and make
sure it is of the class hit on OK and
this will simply create a public loss of
my Java file now inside this as per Java
we all know we have to define a public
static void main method which is
actually the entry point of any Java
code string Arg s right now if you
compare my Java file dot Java and this
my first dot Katy you will find the main
method in both the case right this is
the main method and also here I have the
main method now here my objective is to
call this add method from inside my Java
file but before that let us understand
how Java will simply interpret this file
so here after the code is compiled our
the content of my first dot Katie file
will simply converted into this public
class my first Katie right so by default
we will get a class inside which we will
have our main method and also the add
method so here I will simply define my
main method as public static void main
string Arg is similar to what we have in
case of my Java file so this method
function main arguments array of string
is actually converted into this one
public static void main string
a RGS now similar to this we also have
an ADD method that will be again
converted into the Java syntax so here
we have the add method public static int
add integer a and integer B so here I
have the return type of end and here we
have the return type of int right here
we have two parameters and here again we
have two parameters and again we are
returning the sum of K plus B right so
this is how the Java looks at these four
lines of code that is the function name
and function add
now now since now we know that we are
actually having this code internally so
from the my Java file inside the main
function I can simply call let's say the
name of the class let's say my first
Katie dot class right so this is
actually the auto-generated class name
inside which we have two methods of
let's say mean and add so the
intelligence will simply show you these
two options so our destiny is to call
this add method and it is call let's say
three and four let us add these two
numbers and here I am simply following
the Java syntax by adding a semicolon to
end the expression now let us use int
sum equal to this function and now here
I will simply print out such as system
dot out dot println printing sum from
the Java file and simply print the value
of the sum right and now here at the top
what i will do i will simply click on
this icon to run the code simply run my
java file dot main method and in the
output we have printing sum from Java
file as seven right so this is how we
access a method inside the cortland
class from inside the java class and now
similarly can we access the Java methods
from within the cortland file the answer
to this is yes now suppose if I define a
method here let's say public static get
area of a rectangle
let's say in length and int breath and
then simply return L into B side and now
here I forgot to give the return type as
int and now this method can be accessed
from inside the cortland file using the
same syntax such as from inside the main
method I will simply call sorry where
area equal to my Java file which is our
class name dot get area and simply pass
let's say length as 10 and then breadth
as 5 and now here I was simply called
print line printing area from the
coughlin file and now simply replace it
by area so here we are simply printing
the area of the rectangle by calling a
method present inside the file of dot
Java file that is this file right and
now let us run our Kotlin code so here
simply click on it and simply click on
friend my first Katy like we're in any
Cortland file so in the output we get
printing area from the Cortlandt file
that is 50 right so in this way we can
have both Kotlin and also the Java file
inside the same application and now let
us try something different
now suppose from the Java file we are
actually using my first Katy which is
the standard naming convention that the
compiler follow right my first Katy dot
class is getting converted during the
compilation now suppose if I use the
syntax at the top let's say at the rate
file and then JVM name and as a
parameter let's say give it a name as my
custom Kotlin file right now what
happens is that the compiler will simply
give this file name while converting
into the bytecode as my custom Kotlin
file name right now if you want to
access these methods so what will happen
is that instead of
following my first Katy you have to
simply use this syntax so ctrl C and
here let us change the comment by this
one and now next inside my file you have
to simply use it shows some error so
here you have to simply use my custom
Cortland file name dot add so now
onwards our codling file is now having
the wrapper of the class name of my
custom Cortland file name which we have
defined at the file level here right and
now let us run our java code by simply
running the main function so here we go
printing some from the java file as
seven right so our code is now working
perfectly fine and now what about the
packages now since these two files are
actually present directly inside the
source folder now if I want to create
let's say a new package and let's say
let us call it as comm dot my java hit
on ok and now simply drag and drop this
my java file into this package refactor
and now here if you notice inside the my
java files or java here I have the
package of comm dot my Java so this file
is now a part of this package and now
here let us create one more package and
let us call it as comm dot my Cortland
where we will store all our Cortland
files and now simply drag and drop the
Cortland files inside my Cortland
package and then refactor so inside my
first dot Katie you will find the
package name as comm dot my Kotlin and
now if you notice here here we have
simply imported the package of comm dot
my java dot my java file so here let us
remove it as of now let's see what
happens so here it simply shows some
error unresolved file right unresolved
class name so here I will simply press
alt enter now whenever there is some
error in case of IntelliJ IDE simply
press Alt + n
what alt' + enter' and hit on import
so the IntelliJ IDE will simply import
the required package for you and now
next inside my java file again we have
some error cannot resolve this class
name so again what to do simply press
alt enter so here I have the complete
input package as comm dot my Cortland
dot my custom Cortland file name right
and now if you run the code then also
the code will work perfectly fine in
both the files so here we go our code is
still working perfectly fine so this is
how we actually create the packages in
case of Cortland and we can store both
the Java file and also the Cortland file
within the same application so this is
how we are going to work in case of
Android as well so thanks for watching
and have a good day and see you guys in
the next video thank you