If you’re deep dive into Java, you’ve probably come with the terms “constructor” and “static block.” These are fundamental concepts, Specially when working with object-oriented programming in Java. In this article, we’ll revel what they are, how they work, and why they matter. Whether you’re new to Java or just need a refresher, let’s dive in!
What is a Constructor?
Think of a constructor as the blueprint of your object, The very thing that gives it life! When you create (or instantiate) an object in Java, the constructor is the block of code that runs first. Its job? To set up the object, initialise variables, and get everything ready for use. Simple!
Key Points About Constructors:
- Same Name as Class: The constructor has the same name as the class. No exceptions.
- No Return Type: Unlike methods, constructors do not return anything—not even
void. - Automatically Invoked: When you create an object using
new, the constructor will automatically call. - Can Be Overloaded: You can have multiple constructors in the same class with different parameters. This is known as constructor overloading (Operator Overloading).
Let’s take an example of constructor
class Car {
String model;
int year;
// Constructor
public Car(String model, int year) {
this.model = model;
this.year = year;
}
}
In the above example, when you create a Car object, the constructor gets called to initialize the model and year.
Car myCar = new Car("Tesla", 2022);
Here, "Tesla" and 2022 are passed to the constructor, setting the values of the model and year fields.
Types of Constructors:
1. Default Constructor
If you don’t define arguments in a constructor, Java provides a default one. It doesn’t do much, just initialises the object without any setup.
class Bike {
// Default constructor provided by Java
}
Bike myBike = new Bike(); // Works fine
2. Parameterised Constructor
As the name suggests, this constructor takes arguments to initialise specific fields of an object.
class Bike {
String brand;
public Bike(String brand) {
this.brand = brand;
}
}
What is a Static Block?
Now, let’s talk about static blocks. While constructors deal with initialising objects, static blocks help initialise static variables. These blocks of code run before the main method and are executed only once when the class is loaded into memory.
Key Points About Static Blocks:
- Run Once: Static blocks run only once, when the class is loaded.
- Before Main Method: They execute even before the
main()method starts. - Used for Static Initialisation: Ideal for initialising static variables or executing setup code that needs to run once per class (not per object).
Let’s take an example
class DatabaseConnection {
static String dbUrl;
// Static block
static {
dbUrl = "jdbc:mysql://localhost:3306/mydb";
System.out.println("Static block executed. Database URL initialized.");
}
public static void connect() {
System.out.println("Connecting to: " + dbUrl);
}
}
In this example, the static block initializes the dbUrl only once when the class is loaded into memory. You don’t need to create an object of the DatabaseConnection class to execute the static block.
Why Use Static Blocks?
- One-time Setup: Perfect for things that need to happen only once in your program’s lifecycle (e.g., setting up configuration or database connections).
- Static Variable Initialisation: If your static variable needs a more complex initialisation (e.g., reading from a file or performing a calculation), static blocks are ideal.
Static Block vs Constructor: What’s the Difference?
Now that we’ve see both concepts, let’s clarify the differences between a static block and a constructor via table.
- Static Block: Runs when the class is loaded
- Constructor: Runs when an object is created
- Static Block: Executes only once, no matter how many objects are created
- Constructor: Executes every time an object is instantiated
- Static Block: Used to initialise static members
- Constructor: Used to initialise instance (non-static) members
- Static Block: Cannot take arguments
- Constructor: Can take arguments (via constructor overloading)
- Static Block: No access to this keyword (since it’s class-level)
- Constructor: Has access to this keyword (since it’s object-level)
Use Cases: When to Use What?
- Use constructors when you want to initialise the state of a new object (like setting the model and year of a
Carobject). - Use static blocks when you need to perform one-time initialisation of static variables (like setting up a database URL).
What If ,We Combining Static Blocks and Constructors ?
class Example {
static int counter;
static {
counter = 100;
System.out.println("Static block: Counter initialized to 100");
}
public Example() {
counter++;
System.out.println("Constructor: Counter incremented. Current counter: " + counter);
}
}
Here’s what happens when you create objects of Example:
Example ex1 = new Example(); // Static block runs first, then constructor
Example ex2 = new Example(); // Only constructor runs, static block is skipped
Final Thoughts
Remember, constructors focus on individual object initialization, while static blocks handle class-level initialization. Knowing when and how to use them will make your Java programs more organized, efficient, and maintainable.
SOCIAL SHARE CARD GENERATOR