Comentarios

El método constructor de Java

El método constructor de Java

Un constructor de Java crea una nueva instancia de un objeto ya definido. Este artículo describe cómo usar los métodos de constructor Java para crear un objeto Person.

Nota: Necesita crear dos archivos en la misma carpeta para este ejemplo: Person.java define la clase de persona y PersonExample.java contiene el método principal que crea objetos Persona.

El método del constructor

Comencemos creando una clase Persona que tenga cuatro campos privados: nombre, apellido, dirección y nombre de usuario. Estos campos son variables privadas y juntos sus valores forman el estado de un objeto. También hemos agregado el más simple de los métodos de construcción:

Persona de clase pública {
Nombre de cadena privada;
Cadena privada apellido;
dirección de cadena privada;
nombre de usuario de cadena privada;
// El método constructor
Persona pública ()
{
}
}

El método constructor es similar a cualquier otro método público, excepto que comparte el mismo nombre que la clase y no puede devolver un valor. Puede tener ninguno, uno o muchos parámetros.

Actualmente, nuestro método de construcción no hace nada, y es un buen momento para considerar lo que esto significa para el estado inicial del objeto Person. Si dejamos las cosas como están o no incluimos un método constructor en nuestra clase Persona (en Java puede definir una clase sin una), entonces los campos no tendrían valores, y ciertamente queremos que nuestra persona tenga un nombre y dirección, así como otras características. Si cree que existe la posibilidad de que su objeto no se use como espera y que los campos no se inicialicen cuando se crea el objeto, siempre defínalos con un valor predeterminado:

Persona de clase pública {
cadena privada firstName = "";
Private String lastName = "";
dirección de cadena privada = "";
private String nombre de usuario = "";
// El método constructor
Persona pública ()
{
}
}

Normalmente, para garantizar que un método constructor sea útil, lo diseñaríamos para esperar parámetros. Los valores pasados ​​a través de estos parámetros se pueden usar para establecer los valores de los campos privados:

Persona de clase pública {
Nombre de cadena privada;
Cadena privada apellido;
dirección de cadena privada;
nombre de usuario de cadena privada;
// El método constructor
Persona pública (String personFirstname, String personLastName, String personAddress, String personUsername)
{
firstName = personFirstName;
lastName = personLastName;
address = personAddress;
username = personUsername;
}
// Un método para mostrar el estado del objeto en la pantalla
public void displayPersonDetails ()
{
System.out.println ("Nombre:" + nombre + "" + apellido);
System.out.println ("Dirección:" + dirección);
System.out.println ("Nombre de usuario:" + nombre de usuario);
}
}

Nuestro método de construcción ahora espera que se le pasen los valores de cuatro cadenas. Luego se utilizan para establecer el estado inicial del objeto. También hemos agregado un nuevo método llamado displayPersonDetails () para permitirnos ver el estado del objeto después de haber sido creado.

Llamando al Método Constructor

A diferencia de otros métodos de un objeto, el método del constructor debe llamarse utilizando la palabra clave "new":

Clase pública PersonExample {
public static void main (String args) {
Person dave = nueva persona ("Dave", "Davidson", "12 Main St.", "DDavidson");
dave.displayPersonDetails ();
}
}

Esto es lo que hicimos:

  1. Para crear la nueva instancia del objeto Person, primero definimos una variable de tipo Person que contendrá el objeto. En este ejemplo, lo hemos llamado Dave.
  2. En el otro lado del signo igual, llamamos al método constructor de nuestra clase Person y le pasamos cuatro valores de cadena. Nuestro método de construcción tomará esos cuatro valores y establecerá el estado inicial del objeto Persona en: firstName = "Dave", lastName = "Davidson", address = "12 Main St", username = "DDavidson".

Observe cómo hemos cambiado a la clase principal de Java para llamar al objeto Person. Cuando trabajas con objetos, los programas abarcarán múltiples archivos .java. Asegúrese de guardarlos en la misma carpeta. Para compilar y ejecutar el programa, simplemente compile y ejecute el archivo de clase principal de Java (es decir, PersonExample.java) El compilador de Java es lo suficientemente inteligente como para darse cuenta de que desea compilar el Person.java archivo también porque puede ver que lo ha usado en la clase PersonExample.

Nombramiento de Parámetros

El compilador de Java se confunde si los parámetros del método constructor tienen los mismos nombres que los campos privados. En este ejemplo, puede ver que hemos distinguido entre ellos al prefijar los parámetros con la palabra "persona". Vale la pena mencionar que hay otra manera. Podemos usar la palabra clave "this" en su lugar:

// El método constructor
Persona pública (String firstName, String lastName, String address, String username)
{
this.firstName = firstName;
this.lastName = lastName;
this.address = dirección;
this.username = nombre de usuario;
}

La palabra clave "this" le dice al compilador de Java que la variable a la que se le asignará el valor es la definida por la clase, no el parámetro. Es una cuestión de estilo de programación, pero este método nos ayuda a definir los parámetros del constructor sin tener que usar varios nombres.

Más de un método de constructor

Al diseñar sus clases de objetos, no está limitado a usar solo un método de constructor. Puede decidir que hay un par de formas en que se puede inicializar un objeto. La única restricción para usar más de un método de constructor es que los parámetros deben diferir.

Imagine que en el momento en que creamos el objeto Persona, es posible que no conozcamos el nombre de usuario. Agreguemos un nuevo método de constructor que establece el estado del objeto Persona usando solo el nombre, el apellido y la dirección:

Persona de clase pública {
Nombre de cadena privada;
Cadena privada apellido;
dirección de cadena privada;
nombre de usuario de cadena privada;
// El método constructor
Persona pública (String firstName, String lastName, String address, String username)
{
this.firstName = firstName;
this.lastName = lastName;
this.address = dirección;
this.username = nombre de usuario;
}
// El nuevo método constructor
Persona pública (String firstName, String lastName, String address)
{
this.firstName = firstName;
this.lastName = lastName;
this.address = dirección;
this.username = "";
}
// Un método para mostrar el estado del objeto en la pantalla
public void displayPersonDetails ()
{
System.out.println ("Nombre:" + nombre + "" + apellido);
System.out.println ("Dirección:" + dirección);
System.out.println ("Nombre de usuario:" + nombre de usuario);
}
}

Tenga en cuenta que el segundo método constructor también se llama "Persona" y tampoco devuelve un valor. La única diferencia entre él y el primer método constructor son los parámetros; esta vez solo espera Tres valores de cadena: nombre, apellido y dirección.

Ahora podemos crear objetos Persona de dos maneras diferentes:

Clase pública PersonExample {
public static void main (String args) {
Person dave = nueva persona ("Dave", "Davidson", "12 Main St.", "DDavidson");
Persona jim = Persona nueva ("Jim", "Davidson", "15 Kings Road");
dave.displayPersonDetails ();
jim.displayPersonDetails ();
}
}

Persona Dave se creará con un nombre, apellido, dirección y nombre de usuario. Persona jim sin embargo, no obtendrá un nombre de usuario, es decir, el nombre de usuario será la cadena vacía: username = "".

Un resumen rápido

Los métodos de constructor solo se invocan cuando se crea una nueva instancia de un objeto. Ellos:

  • Debe tener el mismo nombre que la clase
  • No devuelva un valor.
  • Puede tener ninguno, uno o muchos parámetros
  • Puede numerar más de uno siempre que cada método de constructor tenga un conjunto diferente de parámetros
  • Puede tener nombres de parámetros iguales a los campos privados siempre que se use la palabra clave "this"
  • Se llaman utilizando la palabra clave "nuevo"