Part 20 - C# Tutorial - Static and instance class members.avi Video Lecture

welcome to prison technologies I am
Bankard this is part Wendy static and
instance class members in this session
we will understand what static and
instance class and we saw and the
difference between these two we'll also
look at a practical example explaining
when you should and shouldn't be marking
members static let's look at an example
as part of understanding static and
instance class members let's create a
simple circle class so class circle and
as all of us now a circle class
basically have two fields one is the PI
field and the other one is the radius
okay so let's go ahead and create these
two fields okay so pi is actually a
float so float out of school pi and
let's initialize that to 3.14 one let's
create the radius field and let's mark
radius as integer so unschool radius now
to initialize by the way float needs to
have a trailing F now to initialize
class fields we know that we need to
have constructors we have seen that in
part 19 introduction to classes so let's
go ahead and create a constructor and we
know a constructor will have the same
name as that of the class and it doesn't
have a return type but a constructor can
take parameters which in turn can be
used to initialize the class members so
public and the name of the class circle
and let's pass in a radius parameter to
this constructor and we use this radius
parameter to initialize this class field
so this dot underscore radius equal to
radius the parameter that we are passing
into
this constructor so we have used a
constructor to initialize the radius
fear and pi field is actually already
initialized here and let's go ahead and
create another method which actually can
calculate the area of the circle and
written it back so public and that since
we want to return the area back to the
calling application we need to have a
return type so let's have a flute return
type float and we will call this
calculate area method so what does this
method going to do basically this method
is going to calculate the area of the
circle and return the area so and we
know that to calculate the area of the
circle that one-ply is PI R square pi in
radius into a radius so we can say I
simply return this dot and then part 19
we have seen when we use this keyword we
are actually referring to an instance of
this circle class an object of the
circle class so this keyword refers to
an instance in this class so this dot pi
into this dot radius into this dot
radius again so what is this basically
doing calculating the area of the circle
and returning that now we have defined
state and behavior for our class you
know the state is represented by these
two fields and behavior is represented
by this method which can you know
basically calculate the area and what
data is our class holding onto pi and
radius now to actually use this class we
can go ahead and create an object of
this class in the main method so how do
we do that so circle c1 is equal to new
circle so we use the new operator to
create an instance of this class and
when we create the circle object you
know we are calling this constructor and
we need to pass in the radius let's say
for example I want
create a circle with radius five so I
get that and then if I want to get the
you know print the area back what we can
do
float because we are getting fluid back
so fluid
maybe area is the folder we call c1 dot
calculate area look at that I'm using
the instance of the class to basically
call this method c1 not calculated and
if you look at the return type of
calculate area to float we are storing
that in this variable and if I want to
print the area we can say
console.writeline area is equal to
whatever is written by that method so
now if you look at this method it's a
pretty simple one all we are doing here
is creating an instance of the circle
class that we have created and on that
instance we are calling the calculate
area method which in turn will calculate
the area for us and gives it back and we
are printing that area so if we go ahead
and run this application by pressing
ctrl f5 as you might expect it reduces
the area of the circle let's do another
thing let's say I want to create another
circle object so let's create another
circle object this time I'm going to
call my object as c2 and I'm going to
make the radius six and since we already
have area they'll call that as area one
will call this as area two so they're
printing area one there and we are
printing area two here okay so until now
what we have done we have created two
circle objects one circle with radius 5
and the other circle with radius 6 so
let's go ahead and run this and
obviously it should in the area of the
two circles but for some reason if you
look at this okay it's printing in a
once one circle area is 5 the other one
is 6 but if you look at this we are
calling c1 got calculated area so that's
why it's calculating the area for the
same circle again so we need to change
this to circle 2
so let's go ahead and run this now it
should print the area of circle - okay
very simple example but then there's
something wrong here with this class you
know the way we have designed this class
now look at this whether you have
created a circle in order for circle 1
and circle 2 what's the difference in
terms of the data that it's carrying for
circle 1 the radius is 5 and pi value is
3.14 one for circle - the radius is 6
and the pi value is again three point
one one no matter whether you create one
circle or thousand circles pi value is
always going to be constant it's not
going to change on a pair object that
you are creating so that's going to be
static it does not change on a pair
object basis so when something doesn't
change on a pair object basis then it is
wise to go ahead and convert them into
static and there's a reason behind doing
that okay
now before we do that let's let's
understand what's happening you know in
memory when you actually create these
objects let's go back to the side now if
you look at this one this class has two
fields and we don't have static keyword
in front of them
that means these fields are instance
fields or non-static field if I had if I
have put a static keyword that this
field is called as a static field but
the absence of static keyword makes them
non-static fields are non or instance
members or instance fields okay now not
only feels your constructors your men
methods events we haven't spoken about
even said but evens you know delegates
all these basically whatever that can be
properties that can be present in a
class you know they can either be static
or instance members basically your class
members like fields constructors methods
properties etc all of these class
members can be of two types either
instance fields or static static members
instance I mean a member is called a
static member
if it has a static keyword you know in
front of it otherwise it's called as an
instance member now when a member is an
instance member what's going to happen
we know that these two fields are
instance members and we are creating two
circular objects one with radius five
and one with radius six so what's going
to happen in memory is this one okay
circle one for circle one object these
two fields you know we will have a copy
of these fields pi and radius if I
create another circle object pi and
radius again if I create another circle
object I will have a copy of pi and
radius from that object so keep in mind
if we create thousand objects this pi
and radius values will be duplicated
thousand times because each object will
have their own set of tools instance
fields because they change on a pair
object basis but if you look at this
here whether you created a circle with
radius five or radius six you know pi
value is going to be constant it's not
going to change so it makes sense to
actually mark this field less static
because it's not going to change pair
object basis so when you mark it as
static then in memory there will be only
one copy of that PI which will be shared
by all the objects that you create okay
so if we had made PI static and radius
as instance field then there will be a
copy of Pi which will be shared by all
the objects you create no matter you
know even if you create thousand objects
you know there is going to be ever one
copy of the static field you know it's
not just with fields even with methods
you know if the method is an instance
method then every object that we create
will have its own copy of that method
own copy of that method executing okay
so if there is something that's not
going to change on a pair objective
basis then it's wise to actually mark
them as static so in our example you
know it's wise to actually mark the PI
field as static field okay so the
moment I'm market okay one difference
between static and instance members we
have already known that you know if a
member has a static keyword in front of
it it's all a static member otherwise
it's called as an instance man but now
I'm not referring to fields and
properties when I say class members you
know properties feels methods
constructors you know all those things
that can present inside a class are
called as class members okay so if these
members have a static keyword in front
of them like all the static members
otherwise they are called
non-static or instance members all right
so that's one difference so the moment I
make this static look at what's going to
happen
okay now this field has become static
now the moment I made it static look at
this you cannot refer that field with
this keyword because remember this
keyword refers to an instance of this
class an object of this class and
remember this pie does not change on a
pair object basis so it doesn't make
sense to call that using you know the
instance of the object instead you can
refer that by the name of the class
because it doesn't change an apparent
check basis so there is no I mean it
doesn't make sense to say see one dot pi
or see two dot pi you don't use an
object to refer to a static member you
use the name of the class so instead of
using this cable and it's a compile time
error to use an instance or this keyword
to refer to a static member so refer to
that I can use the name of the class and
it's not only filled any kind of memo
for example let us say I have created
maybe a public static void print method
in this class in the circle class which
can print the radius of the circle let's
say on the diameter of the circle we
will not worry about the implementation
at the moment so if you look at this
method this is a static method we have a
static keyword now if I have to invoke
the
print method look at this the print
method is a static method whereas
calculated area is an instance method as
it doesn't have static keyword
now to call calculate area I actually
have used the circle object z1 to call
the instance method whereas if I have to
call the print method look at this the
moment I say c1 dot I cannot see print
method because there's no I mean it
doesn't make sense to call a static
member on an instance of a class okay so
if you want to call the print method you
use the name of the classes circle dot
print okay so bottom line another
difference between static and instance
members static members are invoked using
the name of the class and instance
members are in group using an instance
or object of the class that's why they
are called as instance members whereas
static members the name of the class and
it makes sense right because a static
member doesn't change in the pair object
basis it doesn't make sense to actually
move it on an instance of the class it
perfectly makes sense to invoke it on
the name of the class and keep in mind
that is ever going to be only one copy
of a static member in the memory no
matter how many objects you create okay
so that's another difference now let's
get rid of this one okay so I made this
static this pi field a static field and
we are referring to that field it's the
class name and now this program is
actually a little more efficient because
look at this we have saved a lot of
memory here in a flute whatever is the
sales size of the datatype if I create
thousand objects in that much memory
will be occupied by each copy but
instead now since we made it static that
is going to be only one copy even if you
see a thousand two thousand one hundred
thousand objects so your program will
run a little more efficient
okay another thing you know your
constructor can also be a static
constructor for example look at this
this field is an instance field to
initialize an instance field we use an
instance constructor similarly to
initialize a static field you can make
use of the static constructor something
like this and to make a constructor
static look at this this constructor has
an access modifier ideally we'll be
talking about X modifiers in a later
session okay
but for Ecstatic constructor you cannot
have access modifier public static let's
circle and look at this the moment I do
that and if I try to go and build a
solution access modifiers are not
allowed on static constructors okay so
it's not allowing us to use access
modifiers on static constructor and it
actually makes sense okay you don't have
to mug this or you know try and remember
this hard it makes sense because look at
this
if you don't mark any class member with
an access modifier explicitly look at
this all I'm doing is I'm removing this
access modifier if I remove the access
modifier of a class member you know by
default it is going to be private and if
something is private you can access that
only inside this class inside the circle
class I would say the class you cannot
access that okay so the moment I have
removed the access modifier public it
has become private so I cannot access
this constructor outside of the class
and you will see there is a compiler
error here you know circle does not come
contain the constructor that takes
because that's not visible this circle
constructor is not visible outside of
this class because we remove that public
access modifier and by default if a
member does not have an access modifier
it's going to be private meaning it will
be available only within that class
we'll be talking about X modifiers in
detail in a later session anyway
so which means to initialize or to
create an instance of this class you
have to invoke the constructor okay
because if we want to create a circular
object with radius 10 you need to pass
the size to that constructor which will
initialize your class field so we are
explicitly actually this constructor
gets automatically called and we are
creating this c1 object okay that's why
it needs to be public but a static
constructor you don't have to call that
the static constructor need not be
called anytime you refer to any field
you know maybe a static field if you
refer to a static field the constructor
will be automatically called even before
that to initialize the static field okay
so you don't have to call static
constructors explicitly that's why it
won't allow the excess modify book if
you put public somebody will be able to
call that constructor and we shouldn't
be allowing people to do that because
why they should be called automatically
even before we refer to any of the
fields within that class you know any of
the static sales within that class
that's why it doesn't allow access
modifier but anyhow so why do we use
static constructor to initialize static
fields so I want to initialize the
static field so instead of initializing
that there what you can do is circle dot
on the scope pi equals 3.14 one F so
keep in mind steady
practice doesn't allow access modifiers
and you have a static keyword in that
and static constructors I used to
initialize static fields and static
constructors are called before instance
constructors are called and even before
you refer to any static field okay let's
actually prove that point you know just
a bit later but now let's go ahead and
see so now with this change what's going
to happen your program there's not going
to be any difference within your program
it's going to work exactly the same way
except that we made this program a
little efficient instead of having you
know copies of Fifield which does not
change on a pair of dick basis you know
for every object we are now having a
single copy so the amount of memory
comes you where your application will be
you know much lesser now when compared
to or was it before and I went with PI
in radius or instance fields I hope
that's clear okay static and instance
class members we have already spoken
about this when a class member includes
static modifier the member is called a
static member but no static modifier is
present the member is called as a non
static member or instance member static
members are invoked using class name
whereas instance members are invoked
using instances objects of the class an
instance member belongs to a specific
instance of the class if I create three
objects of the class for example I will
have three sets of instance members in
the memory we have seen the examples of
pi and radius pi being static there will
ever be only one copy of pi
whereas radius is an instance real so
for every different circle size that you
create you have a copy of that radius in
radius 5 radius 6 radius 10 etc so when
we say you know when we use the term
class members we are roughly referring
to all the things that can be present
inside a class like fields methods
properties even set cetera and we have
also spoken about static constructors
static constructors are used to
initialize static fields in the class
will declare a static constructor by
using static keyword in front of the
constructor
name static constructor is called yeah
this is again a very important point
static constructor is called
only once no matter how many instances
you create but where as an instance
constructor is automatically called
every time you create a new object so if
I create thousand objects my instance
constructor is called thousand times
whereas static constructor is called
only once because it just needs to
initialize static fields once which will
be shared by all the objects that you
create we have seen an example for that
and static constructors are called
before instance constructors let's
quickly do a demo on that so this is my
static constructor so before we actually
console dot write line static
constructor and here we will say this is
a very instance constructor so we will
say instance constructor call now if we
go ahead and run this program since we
are creating two circle objects instance
constructor should be called it twice
and static constructor should be called
once
so first static constructor then
instance constructor then instance
constructor call okay so let's go ahead
and see this so static constructor call
instance constructor call that object
God created it area got you know
calculated and another instance
constructor for the knot circle with
radius six got created okay
actually your static constructor gets
called even before you create an object
and even before and when we try to
access any static field for example
let's comment out everything here all I
want to do is console dot write line now
if I want to print the value of pi' that
is
present in this circle but we need to
make this public otherwise we will not
be able to access that outside of the
class so I need that public will be
talking about access modifiers in the
later session so console dot write line
since pi is a static field I can just
use the name of the class circle under
school I so now I'm not creating an
instance of the class okay so I'm trying
to just access the static property of
the circle class and if we want to print
that value it should have been
initialized and where is it initialized
in the static constructor so even before
it tries to print the value of this one
the static constructor is called so
let's go ahead and run that so look at
that static constructor call and my
value is printed okay so to brief that
app static constructors are called
before instance constructors are called
and even before you refer to any static
field of that class because they need to
be initialized right so that said okay
so static constructors will fall before
instance constructors that's it for
today thank you for listening have a
great day