Sobrecarga de constructores con bloque estático en Java

En Java, Constructor es un bloque de códigos similar al método que se usa para inicializar el estado del objeto. Un constructor se invoca en el momento de la creación del objeto o instancia. Cada vez que se crea un objeto utilizando una palabra clave new() , se invoca al menos un constructor (podría ser el constructor predeterminado) para asignar valores iniciales a los miembros de datos de la misma clase.

// A Java program to demonstrates Constructor
class Emp {
    int id;
    String name;
 
    // this would be invoked while an object
    // of that class is created.
    public Emp() { System.out.println("GeeksforGeeks"); }
}
 
// Driver Code
public class GFG {
    public static void main(String[] args)
    {
        // this would invoke default constructor.
        Emp obj = new Emp();
    }
}

GeeksforGeeks

Sobrecarga de constructores :

Al igual que la sobrecarga de métodos , también podemos sobrecargar el constructor. En la sobrecarga de constructores, podemos crear múltiples constructores con diferentes parámetros. A veces, es necesario inicializar un objeto de diferentes maneras. Esto se puede hacer mediante la sobrecarga del constructor.

En este ejemplo, hemos creado dos constructores con el mismo nombre de clase, los parámetros para cada constructor son diferentes y para acceder al constructor pasamos argumentos a través de la clase de objeto. A medida que pasamos el valor 10 a través de la clase de objeto, se llama al segundo constructor con el argumento int, si no se pasa ningún valor a través de la clase de objeto, se llama al constructor predeterminado.

// Java program to demonstrates
// Constructor Overloading
class Emp {
   
    int id;
   
    // Default Constructor
    public Emp() // Constructor1
    {
        System.out.println("Default Constructor");
    }
 
    // Parameterized Constructor
    public Emp(int id)
    {
        System.out.println("Parameterized Constructor");
    }
}
 
// Driver Code
public class GFG {
   
    public static void main(String[] args)
    {
        // Accessing parameterized constructor
        Emp obj = new Emp(10);
    }
}

Producción:

Parameterized Constructor

Sobrecarga de constructor con bloque estático

Un bloque estático en Java se usa para inicializaciones estáticas de una clase. El bloque estático se ejecuta cuando la clase se carga en la memoria. El código dentro del bloque estático se ejecuta solo una vez. El bloque estático también puede ayudar a reducir las líneas de código. Entendamos por qué necesitamos la sobrecarga de constructores con un bloque estático en Java. Supongamos que una empresa contrató a algunos empleados sin experiencia o con dos años de experiencia para un desarrollador de roles único. Dado que los candidatos recién contratados se encuentran en la categoría de desarrollador, podemos usar un bloque estático para hacer esto.

// Java program to demonstrates Constructor
// Overloading with static block
class Emp {
    int id, exp;
    String name;
    static String category;
 
    // Static block with category Developer
    static { category = "Developer"; }
   
    // Default Constructor
    public Emp()
    {
        System.out.println("-"
                           + "\t"
                           + "-"
                           + "\t"
                           + "-"
                           + "\t"
                           + "\t"
                           + "-");
    }
   
    // Parameterized Constructor with two arguments
    public Emp(int id, String name)
    {
        System.out.println(id + "\t" + name + "\t"
                           + category + "\t" + exp);
    }
   
    // Parameterized Constructor with three arguments
    public Emp(int id, String name, int exp)
    {
        System.out.println(id + "\t" + name + "\t"
                           + category + "\t" + exp);
    }
}
 
// Driver Code
public class GFG {
   
    public static void main(String[] args)
    {
        System.out.println("Id"
                           + "\t"
                           + "Name"
                           + "\t"
                           + "Category"
                           + "\t"
                           + "Exp");
       
        // Passing values to parameterized constructor with
        // two arguments
        Emp obj1 = new Emp(1863, "Kumar");
       
        // Passing values to parameterized constructor with
        // three arguments
        Emp obj2 = new Emp(1864, "ravi", 2);
       
        // Calling Default COnstructor
        Emp obj3 = new Emp();
    }
}

Id    Name    Category    Exp
1863    Kumar    Developer    0
1864    ravi    Developer    2
-    -    -        -

En el ejemplo anterior, dentro del constructor parametrizado con dos argumentos, estamos pasando el único id, nombre del objeto. En la salida, también podemos ver la categoría y también se imprime exp, esto se debe a que hemos creado un bloque estático para el La categoría Desarrollador y Java asigna automáticamente 0 si no se le pasa ningún valor. Dentro del constructor parametrizado con tres argumentos, solo estamos pasando id, nombre, exp pero la categoría también se imprime en la salida, esto se debe a que la categoría está en un bloque estático.