Table of contents
No headings in the article.
- Introduction
The "static" keyword in Java is used to define class-level members that belong to the class itself, rather than individual instances of the class. It signifies that a variable or method is shared among all instances of the class.
The significance of the "static" keyword lies in its ability to provide consistent values or behaviour across all objects of the class. By using static variables, you can store data that remains the same for every instance, ensuring uniformity. Similarly, static methods allow you to define the functionality that can be accessed without creating an instance of the class.
- Static Variable
Static variables in Java are class-level variables that are shared among all instances of the class. Unlike instance variables (Reference variables ), which have separate copies for each object, static variables belong to the class itself.
public class Car {
private static int numberOfCars = 0;
private String brand;
public Car(String brand) {
this.brand = brand;
numberOfCars++;
}
public static int getNumberOfCars() {
return numberOfCars;
}
}
In this example, the numberOfCars
variable is declared as static. It keeps track of the total number of Car objects created. Each time a new Car object is instantiated in the constructor, the numberOfCars
variable is incremented by one. Since numberOfCars
is a static variable, it is shared among all instances of the Car class.
Using static variables is beneficial when you need to store values that remain consistent across all instances. In our example, the number of cars is a property that should be the same for all Car objects. By using a static variable, we ensure that the count is shared and updated correctly for every Car instance created.
- Static Method
Static methods in Java are class-level methods like static variables
that belong to the class rather than to specific instances of the class. They can be called directly on the class itself without the need to create an instance of the class. In Java, static methods are defined using the static
keyword. And methods which are not defined with static keywords are called an instance methods.
public class Car {
private static int numberOfCars = 0;
private String brand;
public Car(String brand) {
this.brand = brand;
numberOfCars++;
}
public static int getNumberOfCars() {
return numberOfCars;
}
public static void main(){
int totalaCar1 = Car.getNumberOfCars();
System.out.println("Total cars" + ":" + totalaCar1)
// Output is : Total cars : 0
Car bmw = new Car("BMW");
Car nano = new Car("nano");
int totalaCar2 = Car.getNumberOfCars();
System.out.println("Total cars" + ":" + totalaCar2)
// Output is : Total cars : 2
}
}
In the above example, we have a static method getNumberOfCars
, So basically that means we can call it without creating any instance or we can say without creating any object for Car
class. So for the first method call, we are not creating any object for a class method yet, So it gives us 0
is the default value. Why? Because numberOfCars
will only increase when the constructor will be called, And when the constructor will be called? Yes, you are right when we create an object for a class. After we create an object for the class car
by instance variable bmw
and nano
, constructor has been called for each one and it increases the numberOfCars
variable by plus one each time. That is why if we call getNumberOfCars
method after creating an object gives us 2
as a result.
public class Car {
private static int numberOfCars = 0;
private String brand;
public Car(String brand) {
this.brand = brand;
numberOfCars++;
}
public String getNameOfCars() {
return brand;
}
public static void main(){
String nameOfCar = getNameOfCars();
// Now this will throw an error
}
}
In the previous example, we call getNumberOfCars
method inside main
method, and it works fine, but when we try to code the above example and call getNameOfCars
within main
function we will get an error saying "YOU CAN NOT CALL NON-STATIC METHOD FROM STATIC MATHOD", That means you can only call any, method inside the static method if it is static too, You can not call a static method from the non-static method.
The reason for that is, the static method invoked without any object creation or without any instance variable, Which means the main
method invokes initially as code gets run without any object creation, and the method which we are trying to call inside main
is non-static, which means it needs an instance or we can say we need to create an object of class to call it.
Again, the static method will execute without any instance of the class and the non-static method inside the class need an instance for being called. So it gives us an error?
Points to remember :
Static methods do not need any instance or object for being called
You can only be called a static method inside the static method
For the Non-static method to call inside the static method, you need to create an object of class first
Here we get one more answer, Question is, Why do we call getNumberOfCars()
method in the first example with an instance of Car
class Car.getNumberOfCars()
rather than calling it with this
, Because getNumberOfCars
is a static method, does not depends on any object, and this
represents the object's scope. We can also use this
but using class names for static methods is a good practice.
- Static Blocks
Static blocks in Java are used for class initialization and are executed only once when the class is loaded into memory. They play a crucial role in initializing static variables or performing other one-time setup tasks before any instance of the class is created or any static method is called.
Execution timing: Static blocks are executed only once when the class is loaded for the first time by the Java Virtual Machine (JVM).
No explicit invocation: Static blocks are automatically executed by the JVM and do not require any explicit method call.
Order of execution: If a class contains multiple static blocks, they are executed in the order they appear in the source code.
Static blocks can be used for various purposes, such as initializing static variables or performing other one-time setup tasks.
public class MyClass {
static int myStaticVariable;
static {
// This is a static block
// It is executed once when the class is loaded
// Perform initialization or setup tasks here
myStaticVariable = 10;
System.out.println("Static block executed");
}
public static void main(String[] args) {
// The main method or any other code
System.out.println("Value of myStaticVariable: " + myStaticVariable);
// Output: Value of myStaticVariable: 10
}
}
In the above example, we have a class called MyClass that contains a static block. When the class is loaded, the static block is executed. In this case, it initializes the static variable myStaticVariable
with the value 10 and prints "Static block executed" to the console. The main method then accesses the value of myStaticVariable
and prints it.
Static blocks are particularly useful when you need to ensure that certain initialization tasks are performed before any instance of the class is created or any static method is called
- Nested Static
Static nested classes in Java are nested classes that are declared as static within another class. They are closely associated with the outer class but have the unique feature of being instantiated independently, without requiring an instance of the outer class.
One advantage of using static nested classes is that they can access static members of the outer class directly, without the need for an instance. This allows for better encapsulation and organization of related code within a single class structure.
public class OuterClass {
private static int outerStaticVariable = 10;
public static class StaticNestedClass {
private int nestedVariable = 20;
public void nestedMethod() {
int result = outerStaticVariable + nestedVariable;
System.out.println("Result: " + result);
}
}
}
To instantiate the static nested class independently, you can use the following code.
public class Main {
public static void main(String[] args) {
OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();
nestedObject.nestedMethod();
}
}
this example, we create an instance of the StaticNestedClass
without creating an instance of the OuterClass
. We can then call the nestedMethod()
on the nestedObject
, which will access the static variable from the outer class and print the result.
Nested Static is a vast topic in itself, Will discuss it in next blog.
- Important Considerations
When using the static keyword in programming, there are several important considerations to keep in mind. While static members can provide convenience and efficiency in certain scenarios, their excessive use can lead to tight coupling, hinder testability and maintainability, and introduce concurrency issues.
public class Math {
public static final double PI = 3.14159;
public static int add(int a, int b) {
return a + b;
}
}
public class Circle {
public double calculateArea(double radius) {
return MathUtils.PI * radius * radius;
}
}
In this example, the Math
class has a static constant PI and a static method add()
. The Circle class uses the static constant PI to calculate the area of a circle. While this usage is appropriate, imagine if multiple classes relied on the Math
class and its static members. If the value of PI were to change, all the dependent classes would need to be updated accordingly, making the code more rigid and error-prone.
- Conclusion
The "static" keyword in Java is essential for defining class-level members and behavior. It allows the creation of static variables that belong to the class itself, rather than individual instances, ensuring their shared nature among all objects of the class. Static variables are ideal for storing values that need to remain consistent across instances.