Advertisement

---

Top

< Prev

Next >

The main feature of the static keyword is that when anything is marked with a static keyword in a class, it belongs to the class and not to the object of the class.

The static keyword is used to create :

• static variables
• static methods







Features of a static variable and static method



• A static variable and a static method belong to the class in which they are created, therefore, a static variable is called a class variable and a static method is called a class method.


• A static variable and a static method can be accessed by their class name with a dot operator.


• When a static variable is initialized with a value, its value remains the same value for all the objects of a class.


• A single copy of both, a static variable and a static method is shared by all the objects of a class.

A static variable/static method of a class can be accessed -

• Inside the scope of its class.
• Outside the scope of its class.

Access of a static variable/static method inside the scope of its class.


Inside the scope of its class, a static variable or a static method can be accessed directly or by using its class name and a dot operator.



//C# Example of accessing a static variable/static method within the scope of its class.

using System;

class A
{
//A static variable of class A is initialized to 20
static int i = 20;	     


//A static method of class A
public static void Display() 
{
	Console.WriteLine("A");
}


public static void Main(String[] ar)
{
	 //Directly accessing a static variable
	Console.WriteLine(i);  

	//Accessing a static variable by using its class name and a dot operator 
	Console.WriteLine(A.i);     

	//Directly accessing a static method
	Display();   	

	//Accessing a static method by using its class name and a dot operator	     
	A.Display(); 		    
}
}





Output is :




20
20
A
A






Advertisement






Incorrect access of a static variable/static method outside the scope of its class gives an error.


Outside the scope of its class, a static variable or a static method cannot be accessed directly(without using its class name with a dot operator).



//C# Example of incorrect direct access of a static variable/static method outside its class.

using System;

class A
{
//A static variable of class A is initialized to 10
public static int i=10;	     


//A static method of class A
public static void Display() 
{
	Console.WriteLine("A");
}
}

class B
{
public static void Main(String[] ar)
{
	//Directly accessing a static variable, outside the scope of its class
	//Outside the scope of its class
	Console.WriteLine(i);  

	//Directly accessing a static method, outside the scope of its class
	Display();   	 		    
}
}





Output is :




A.cs(23,20): error CS0103: The name 'i' does not exist in the current context
A.cs(26,2): error CS0103: The name 'Display' does not exist in the current context
A.cs(8,12): warning CS0414: The field 'A.i' is assigned but its value is never used





Program Analysis


A static variable and a static method belong to the class in which they are declared, and they have no identity of their own outside the scope of their class, therefore, trying to directly access a static variable or a static method outside the scope of their class, gives a compile error.

We have received multiple compile errors as we have directly accessed a static variable, i and a static method, Display() outside the scope of their class A.






Correct access of a static variable/static method outside the scope of its class.


Outside the scope of its class, a static variable or a static method can only be accessed by using its class name and a dot operator.



//C# Example of correct access of a static variable/static method outside its class.

using System;

class A
{
//A static variable of class A is initialized to 10
public static int i=10;	     


//A static method of class A
public static void Display() 
{
	Console.WriteLine("A");
}
}

class B
{
public static void Main(String[] ar)
{
	//Accessing the static variable outside its class, 
	//using its class name and a dot operator
	Console.WriteLine(A.i);  

	//Accessing the static method outside its class, 
	//using its class name and a dot operator
	A.Display();   	 		    
}
}}





Output is :




10
A

This program is the same as the last one but in this code, we have accessed the static variable, i, and the static method, Display(), outside the scope of its class A, by using its class name and a dot operator, therefore, no compile errors are issued.






Cannot directly access instance variables/methods from within a static method.


You can only access static variables or call static methods from a static method, and we cannot access an instance variable or instance methods from within a static method. Let us see an example.



//C# We cannot access an instance variable or instance methods from within a static method

using System;

class A
{
//A non-static i.e. instance variable of class A is initialized to 10
int i = 10; 


//A non-static i.e instance method of class A
public void ShowA() 
{
	Console.WriteLine(i);
}


//A static method of class A
public static void Display() 
{
	//Accessing the instance variable from the static method, won't work
	Console.WriteLine(i);

	//Accessing the instance method from static method, won't work
	ShowA();
}



public static void Main(String[] ar)
{
	//Accessing a static method directly in its class is fine
	Display(); 
}
}





Output




A.cs(21,20): error CS0120: An object reference is required for the non-static field, method, or property 'A.i'
A.cs(22,2): error CS0120: An object reference is required for the non-static field, method, or property 'A.ShowA()'








Default value of a static variable


A static variable and a static method of a class are available and accessible even before creating any objects of this class. Hence, if a static variable is not initialized to a value, it is given a default value when its class is loaded for the first time by the Common Language Runtime(CLR) system of C#.



//C# Default values of static variables 

using System;

class A
{
//Uninitialized static variables
static int i;
static float f;
static String s;
static bool b;

public static void Main(String[] ar)
{
	//Printing the values of uninitialized static variables
	Console.WriteLine(i);
	Console.WriteLine(f);
	Console.WriteLine(b);
	if(s == null) 	//A static object of any class is always initialized to null by default
		Console.WriteLine("null");
}
}





Output is :




0
0
False
null





Program Analysis


In this code, we have declared 3 static variables in class A but, we haven't initialized them to any value. However, a static variable of a class is initialized by default when its class is loaded for the first time(please refer the table for default values of static variable).



Static Type	Default Value
int, short, byte, long, float, double	0
bool	False
Object	null


Hence, static numerical type variables(int, float) were initialized to 0, while the static String object was initialized to null because String class is a subclass of Object class.






A single copy of static variable is shared by all the objects of the class.

//C# The value of a static variable is same and shared by all objects of its class.


using System;

class A
{

//A static variable of class A
static int value = 10;	            

//An instance method
public void SetValue(int v)
{
	value = v;
}

//An instance method
public int GetValue()
{
	return value;
}

public static void Main(String[] ar)
{
	//Creating first object of class A
	A ob1 = new A();
	
	//Setting the value of static variable
	//by using the first object
	ob1.SetValue(20); 
		    
	//Creating second object of class A
	A ob2 = new A();
	
	//Setting the value of static variable 
	//by using the second object
	ob2.SetValue(30);		    

	//Accessing value of static variable
	//by using the first object
	Console.WriteLine(ob1.GetValue()); 

	//Accessing value of static variable
	//by using the second object
	Console.WriteLine(ob2.GetValue());
}
}

Output is :

30
30

Program Analysis

• Here, we have created a class with a static variable, i, initialized to 10. Then we have created two objects of the class and have assigned them to the references ob1 and ob2.
• Using the reference of the first object, ob1, we have given a new value to a static variable, 20.
• Using the reference of the first object, ob2, we have given a new value to a static variable, 30.
• In the end, we have accessed the value of this static variable with each object of the class, which gives us the same value(30), because it was the last value given to the static variable and it is shared by both objects of class A.

Please share this article -

< Prev

Next >

< C# This Keyword

C# Polymorphism >

Advertisement