Constructores en Java – Part 1

Constructores de Java o constructores en Java es una terminología que se ha utilizado para construir algo en nuestros programas. Un constructor en Java es un método especial que se usa para inicializar objetos. Se llama al constructor cuando se crea un objeto de una clase. Se puede utilizar para establecer valores iniciales para atributos de objetos. 

En Java, un constructor es un bloque de códigos similar al método. Se llama cuando se crea una instancia de la clase. En el momento de llamar al constructor, se asigna memoria para el objeto en la memoria. Es un tipo especial de método que se utiliza para inicializar el objeto. Cada vez que se crea un objeto con la palabra clave new(), se llama al menos a un constructor.

import java.io.*;
 
class Geeks {
    Geeks() { super(); }
    public static void main(String[] args)
    {
        Geeks geek = new Geeks();
    }
}

// Java Program to illustrate calling a
// no-argument constructor
 
import java.io.*;
 
class Geek {
    int num;
    String name;
 
    // this would be invoked while an object
    // of that class is created.
    Geek() { System.out.println("Constructor called"); }
}
 
class GFG {
    public static void main(String[] args)
    {
        // this would invoke default constructor.
        Geek geek1 = new Geek();
 
        // Default constructor provides the default
        // values to the object like 0, null
        System.out.println(geek1.name);
        System.out.println(geek1.num);
    }
}

// Java Program to Illustrate Working of
// Parameterized Constructor
 
// Importing required inputoutput class
import java.io.*;
 
// Class 1
class Geek {
    // data members of the class.
    String name;
    int id;
 
    // Constructor would initialize data members
    // With the values of passed arguments while
    // Object of that class created
    Geek(String name, int id)
    {
        this.name = name;
        this.id = id;
    }
}
 
// Class 2
class GFG {
    // main driver method
    public static void main(String[] args)
    {
        // This would invoke the parameterized constructor.
        Geek geek1 = new Geek("adam", 1);
        System.out.println("GeekName :" + geek1.name
                           + " and GeekId :" + geek1.id);
    }
}

// Java Program to illustrate constructor overloading
// using same task (addition operation ) for different
// types of arguments.
 
import java.io.*;
 
class Geek
{
    // constructor with one argument
    Geek(String name)
    {
        System.out.println("Constructor with one " +
                      "argument - String : " + name);
    }
 
    // constructor with two arguments
    Geek(String name, int age)
    {
 
        System.out.println("Constructor with two arguments : " +
                " String and Integer : " + name + " "+ age);
 
    }
 
    // Constructor with one argument but with different
    // type than previous..
    Geek(long id)
    {
        System.out.println("Constructor with one argument : " +
                                            "Long : " + id);
    }
}
 
class GFG
{
    public static void main(String[] args)
    {
        // Creating the objects of the class named 'Geek'
        // by passing different arguments
 
        // Invoke the constructor with one argument of
        // type 'String'.
        Geek geek2 = new Geek("Shikhar");
 
        // Invoke the constructor with two arguments
        Geek geek3 = new Geek("Dharmesh", 26);
 
        // Invoke the constructor with one argument of
        // type 'Long'.
        Geek geek4 = new Geek(325614567);
    }
}