Constructores con parámetros en Java

En Java se pueden definir constructores a los que se les pasen uno o más parámetros (argumentos).

EJEMPLO { PruebaProducto } Dada la siguiente clase Producto, donde se ha definido un constructor con tres parámetros:

public class Producto
{
    private String nombre;
    private double precio;
    private int cantidad;

    public Producto(String nombre, double precio, int cantidad)
    {
        this.nombre = nombre;
        this.precio = precio;
        this.cantidad = cantidad;
    }

    public String getNombre()
    {
        return nombre;
    }

    public double getPrecio()
    {
        return precio;
    }

    public int getCantidad()
    {
        return cantidad;
    }

    public void setNombre(String nombre)
    {
        this.nombre = nombre;
    }

    public void setPrecio(double precio)
    {
        this.precio = precio;
    }

    public void setCantidad(int cantidad)
    {
        this.cantidad = cantidad;
    }
}

Nota: fíjese que, se ha utilizado varias veces la palabra clave this, haciendo referencia al objeto actual. De esta forma, por ejemplo el escribir this.nombre = nombre en el bloque de código del constructor, se está diferenciando entre el atributo nombre del objeto (this.nombre) y el parámetro formal del constructor llamado igualmente nombre. En el caso de que el identificador de dicho atributo y de dicho parámetro hubiesen sido distintos, no hubiese sido necesario hacer uso de this.

Obsérvese que, al compilar y ejecutar el código fuente siguiente:

import java.util.Scanner;

public class ProgProducto
{
    public static void main(String[] args)
    {
        String nombreProducto;
        double precioProducto;
        int cantidadProducto;

        Scanner teclado = new Scanner(System.in);

        System.out.print("Introduzca nombre: ");
        nombreProducto = teclado.nextLine();

        System.out.print("Introduzca precio: ");
        precioProducto = teclado.nextDouble();

        System.out.print("Introduzca cantidad: ");
        cantidadProducto = teclado.nextInt();

        Producto p1 = new Producto(nombreProducto, precioProducto, cantidadProducto);

        System.out.printf("Nombre: %s\n", p1.getNombre());
        System.out.printf("Precio: %f\n", p1.getPrecio());
        System.out.printf("Cantidad: %d\n", p1.getCantidad());
    }
}

En la pantalla, se podrá visualizar algo parecido a:

Ejecución del programa PruebaProducto escrito en Java, donde se pueden ver los valores asignados a los atributos de un objeto mediante un constructor con parámetros.

Puesto que, en la clase Producto de este ejemplo (PruebaProducto), únicamente se ha definido un constructor en el que hay que pasarle tres parámetros, no se podrá crear un objeto de otra forma que no sea esa, es decir, no se podrán crear objetos invocando al constructor sin parámetros como hicimos en el ejemplo (PruebaArticulo) del apartado anterior al invocar al constructor de la clase Articulo.

Ahora bien, si se quisiera tener la posibilidad de crear objetos invocando a distintos tipos de constructores (sin parámetros o con parámetros), esto se podría hacer –como se indica en el apartado siguiente de este tutorial– utilizando sobrecarga.