#8.11 Kotlin Tutorials 'object' declaration - Alternative to STATIC

hi Lisa Tsering Siddarth and welcome to
the next module of object-oriented
programming in case of Cortland now in
Cortland we have some concept of objects
declaration and also companion objects
but before learning that let us first
check out what is singleton in Kotlin
now in case of Cortland whenever we
declare class that we were doing so far
we create instance of that class and
then access all the variables and
methods but in case of singleton we have
just one instance of the class in the
whole application so once we define a
class as singleton then we just have one
instance and that instance is just
created by Cortland internally that is
we do not have any control over creating
the instance of that singleton class now
it means that suppose we have a class
student which is declared as singleton
then we cannot create the objects of
this class that is there exists only one
object for this class by default which
is created by the Cortland internally in
simple words we can say we cannot create
objects like student one student two and
so on I hope I am clear at this point
and now in Java we define singleton by
using the keyword of static such as we
have static variables static methods
present inside a class so in that case
the static variables and methods are not
a part of the class they are just part
of class definition not the objects
right so in case of cortlandt as well we
don't have any static keyword present
but alternative to that we have some
object declaration and also the concept
of companion objects now proceeding
forward in Cortland we cannot declare
static variables and methods compared to
Java side so we have an alternative to
that such as we can declare object and
these objects are actually acting as a
class that can contain the static
variables and methods without using the
keyword of static now when we declare
something as object
the Kotlin internally behind the curtain
simply creates a singleton object for us
when the program is running so when we
run the program we get one instance of
that object so how do we declare the
object in case of Cortland so in
Cortland let us check out the code
snippet suppose we have object customer
now here we don't have class keyword we
are using object keyword right so object
space customer this is the syntax inside
which suppose I have variable ID of the
type of integer now this ID is actually
acting as a static variable compared to
Java this is not exactly static but
behaving like a static variable like we
call static in case of Java right
similarly suppose I have a function
register customer so this method as well
is behaving as a static method now when
we call static variable and static
method if you are from Java background
then you must be knowing how to access
the static variables and methods now to
access these variables and methods we
need to use simply use customer dot ID
let's say 27 so here we are simply using
customer now this customer is the name
of this object or right so class name or
the object name dot ID equal to 27 that
looks similar to the code snippet from
the Java background and next we can call
customer dot register customer and our
code inside the function will be
executed now notice here we are calling
without creating any instance that is we
don't need to declare it as the object
explicitly the Kotlin by default creates
or object instance that is a singleton
instance for our customer class or the
object so let us know proceed and check
out the code inside the demo application
so here inside the IntelliJ IDE I will
simply declare let's say class of
customer so here inside the IntelliJ IDE
I have simply created a normal class of
customers data that contains the
customers count and also type of
customer that simply returns a string
value now in order to access this car
variable and also this method inside the
main we need to write these code so here
in order to access the count variable
and this method we are simply calling
the object name dot count and object
name dot method right by simply creating
the customers data object now if I want
to use this class as a singleton so what
I will do is I will simply use instead
of class I will simply use object so
this object keyword simply creates a
singleton object for this customers data
so we no longer can create the instance
of this customer data manually because
we cannot create the instance of the
singleton class it is done automatically
for you so here I have to remove this at
the top level code and now in order to
access this count variable what we need
to do is we need to simply use copy this
class name and paste it in paste it here
and now again paste it here so here this
count variable is actually acting like a
static variable and also this method is
acting like a static method right so
this is how we access the members of the
object like this and now if I print
let's say print Ln let's say customers
data dot count let's see the output so
here in the output we get 98 right so
this count value is currently 98 that we
have defined here now suppose if I again
change the value let's say 209 and let's
see what happens if we are going to
print it now this time we get 109 so the
value has been updated 209 so whenever
you access this count and change the
value it will be changed to that
particular instance that was created by
Cortland right because we don't have any
name for that object we are simply using
the class name here that is our object
class dot count and something like that
similarly now the same thing applies for
this method as well call it anywhere and
it will be returning Indian string right
and now at the end this object customers
data can also inhale properties from the
superclass
so let us define a class here let us
call it my superclass so here this
customer data can also inherit the
properties of my superclass now since
this is my superclass so we need to
treat it like an object by using the
primary constructor here right and now
let us make this class as open so add to
a so as to inherit all the properties
and also if I want to inherit this my
method or override this my method inside
the customers data then also that is
possible so for that we need to simply
use the open keyword here and then
simply override this function my method
simply override it now inside this if
you want you can call the super dot my
method STR and now here let us print
this like this and now you can notice
this object is actually behaving like a
class because it is actually inheriting
all the properties of my superclass so
we can call it a derived class and this
is now acting as a superclass now what
about this my method how can we access
this my method so for that again inside
the main method what I will do is I will
simply use customers data dot my method
and simply pass let's say hello so this
my method is now becoming the static
member of this object right so we can
write a comment line here so this method
similar to this method is now acting as
a static method inside this object of
customers data and now if you create the
instance of my superclass then you have
to access this method here with the help
of the object of this my superclass it
is only behaving static after we
override it inside the object customers
data so let us now run the code and
let's see what it prints so here we get
my super class has got printed just
because of this statement super dot my
method and object customer data hello is
getting printed which is present
here right so in this video we learned
about how do we declare the object and
also how can we find the alternative for
the static variables and methods in case
of Cortland similar to what we do in
case of Java so at the end of this video
let us summarize the properties of the
object so to declare an object we use
the keyword of object and Kotlin
internally creates a class and also the
instance and object of that particular
class but that object is only when in
count we cannot create more object or
instance again and these objects can
have properties methods and also
initializers and now one thing i forgot
to show you that inside the customers
data object we can also use the init
block like this and you can now
initialize whatever you want to inside
the init block right like this so we can
have initializes in case of object and
next we cannot have constructors inside
the object as it makes sense because
because we do not have any right to do
so to create any instance manually and
the object can also have its superclass
like we saw in this video that is it
simply supports inheritance fine so this
was all about the object in case of
Kotlin so that's all for this video have
a nice day and catch you guys in the
next video
this is shrinkage art signing off thank
you