The static keyword in Java is used for memory management. Static can be applied to variables, methods, blocks, and nested classes. Static members belong to the class rather than objects of the class. Static variables and methods are used for properties and behaviors that are common to all objects. A static nested class can access static members of the outer class without creating an instance of the outer class.

1. Static Members

2.  The ‘static’ keyword in java is mainly
used for memory management.
 ‘static’ is applied to variables, methods,
blocks and nested classes.

3.  The variables and methods declared
in the class are referred as instance
members because a new copy of each
of them is created for each object.
 A member that is common to all the
objects and accessed without using a
particular object, those are declared
using static keyword.

4. Example:
 static int count;
 static int max(int x, int y);
 The members that are declared as
static are referred as static members,
and the static variables, static methods
are also referred as class variables,
and class methods.

5. ‘static’ variables
 If you declare any variable with ‘static’, it is
known as ‘static variable’.
 The ‘static’ variable is used to refer common
properties of all objects(not unique for each
object).
 Ex: Company name of all employees,
College name for all the students.
 It gets memory only once in class area at the
time of class loading.

6. ‘static’ methods
 ‘static’ keyword is used with any
method, is called ‘static method’.
 ‘static method’ belongs to the class
rather than object of a class.

7.  Methods declared as static have several
restrictions.
 1. They can only call other static methods.
 2. They must only access static data.
 3. They cannot refer to this or super in
any way.
 4. We can access the static member by
using the class name itself.

8.  Example 1:
//Defining and using static members
class MathOperation
{
static float mul(float x,float y)
{
return x*y;
}
static float divide(float x,float y)
{
return x/y;
}
}

9. class MathApplication
{
public static void main(String args[])
{
float a=MathOperation.mul(4.0,5.0);
float b=MathOperation.divide(a,2.0);
System.out.println("b="+b);
}
}

10. Example 2:
class Student
{
int rollno;
String name;
static String college=“VLITS”;
static void change() {
college=“Vignan University”;
}
Student(int r,int n) {
rollno=r;
name=n;
}
void display() {
System.out.println(roll no+” ”+name+” ”+college);
}
}

11. class StudentsInfomethod
{
public static void main(String args[])
{
Student.change()
Student s1=new Student(501,“Pavan”);
Student s2=new Student(502,“Kalyani”);
Student s3=new Student(503,“Vignesh”);
s1.display();
s2.display();
s3.display();
}
}

12. Static Block
 A static block is a block of statements declared as
static, something like this:
static
{
Statements;
}
 JVM executes a static block on a highest priority
bases. This means JVM first goes to static block
even before it looks for the main() method in the
program.

13. Example:
class Test
{
static
{
System.out.println("static block");
}
public static void main(String args[])
{
System.out.println("main block");
}
}
Output:
Static block
main block

14. Static class
 When we declare a certain member as
static, we do not have to create an
instance of the class to access it.
 Syntax
class Outer
{
static class Nested
{
}
}
 Here we have declared an Outer class
and then declared a nested class.

15.  Static classes in Java can be created
only as nested classes.
 Inner class- Inner classes are the
classes that are non-static and nested.
 They are written inside an outer class.
 We are unable to create an instance of
the inner class without creating an
instance of its given outer class.
 This is needed when the user has to
create a class but doesn't want other
classes to access it. Here we can use
an inner class for that reason.

16. Outer class- Outer classes are the
classes in which nested or inner classes
are defined.
Nested class- Nested class can be static
or non-static. The non-static nested
class is known as an inner class.
An instance of a static nested class
can be created without the instance of
the outer class. The static member of the
outer class can be accessed only by the

17. ‘static’ class
 Static class in Java is a nested class and it
doesn't need the reference of the outer
class.
 Static class can access only the static
members of its outer class, cannot access
the non-static members.
 Inner classes can access the static and
the non-static members of the outer class.

19. class Outer {
// static member of the outer class
private static char grade = 'A';
// Static class
static class Nested {
//non-static method
public void fun() {
// nested class can access the static
members // of the outer class
System.out.println("Grade: " + grade);
}
}

20. public static void main(String args[]) {
Outer.Nested obj = new Outer.Nested();
//creating an object of nested
// class without creating an object
// of the outer class.
obj.fun();
}
}

21. Example 2:
class TestOuter1{
static int data=30;
static class Inner{
void msg()
{
System.out.println("data is "+data);}
}
public static void main(String args[])
{
TestOuter1.Inner obj=new TestOuter1.Inner
();
obj.msg();
}
}

22. Thank you