The ‘Maya’ of static

What if you want to implement main() function in the program. What should be the syntax?
public static void main( string[] args)
is the customary declaration of main() function followed by its definition.

Why to declare main() function static?
The reason is that there is only one main() method in a particular class and it doesn’t require an object to access the main(). main() is available througout the execution of program.In fact, all the fields and methods declared static are available throughout the class and are stored in a heap whereas local variables are stored in stack

let us take an example, it will clear some of my and ur doubts:
class Demo
{
private int count ;
public static void main(String[ ] args)
{
int newValue;
system.out.println(newValue + ” = ” +count );
}
}
Here, the field private to the class (if not static) when used in main() give Compile Time Error. as main() is static.To make it code compilable, alter the code so that
class Demo
{
private static int count ;
public static void main(String[ ] args)
{
int newValue;
system.out.println(newValue + ” = ” +count );
}
}

When ‘Demo’ is executed , it creates ‘count’ variable immediately as it is declared as a static member of class. But ‘newValue’ is created only when main() is called. Variables inside a method are dynamically created when they are called.

Can static field be shared?
Yes static field can be shared. For example
class A
{
static int a;
A()
{
int value;
}
}
if we instantiate in another class the object a1, a2, a3, a4… of class A. All we share the variable ‘a’ with individual ‘value’ variable. The advantage of such a variable is that a lot of space is saved but it also has disadvantage: any object can modify its value.

How to access static members?
Inside class, static fields are accessed by their name only, while outside class the static field are accessed in this way.
classname.fieldname
only if it is public.

In constructor, can we declare static methods or fields?
The answer is obvious no. The constructor is used to instantiate object and we know that the static members r available throughout the class, not when the object is instantiated.

Now let us consider the code:
class xyz
{
public double x()
{ …. }
public static int getcount()
{
x();
return count;
}
}
It will give an compile time error as static method getcount() cannot access non-static method x().
To access the non-static method, we need to instantiate an object in getcount()
{
xyz x1= new xyz();
x1.x();
return count;
}
Recall C! Is there any such restriction related to static storage class??

Till now, we saw that static methods can access members outside the function only if
(i) they r static or
(ii) they r accessed by the object which belongs to that class.

Are there any such restriction on non-static members?
I didn’t find any, non-static methods can access both static and non-static methods.

There are some static blocks in the program. Like static method, static blocks can access only static members. Static blocks are executed first, that too only once. Static block execution is followed by static sub blocks and then by non-static blocks.

class A
{
static //static block
{

}
{ //non-static block

}
}

Why static blocks are created?
I’m not really sure why they r created but they can be created to avoid repetition of initialization. Remeber, non-static members can use static members.

Why non-static blocks are created?
I think they are useful in creating anonymous classes.

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s