1. Sobrecarga de Constructores.
Además de la sobrecarga de métodos normales, también puede sobrecargar métodos de
constructor. De hecho, para la mayoría las clases reales que cree, constructores sobrecargados será
la norma, no la excepción. Para entender por qué, volvamos a la clase de cuadro desarrollada en el
capítulo anterior. Lo que sigue es la última versión del cuadro:
class Box {
double width;
double height;
double depth;
// This is the constructor for Box.
Box(double w, double h, double d) {
width = w;
height = h;
depth = d;
}
// compute and return volume
double volume() {
return width * height * depth;
}
}
Como se puede ver, el Box( ) constructor requiere tres parámetros. Esto significa que todas las
declaraciones de un cuadro de objetos deben pasar tres argumentos para el constructor de box ().
Por ejemplo, la siguiente declaración es actualmente no válida:
Box ob = new Box();
Box( ) requiere tres argumentos, es un error llamarlo sin ellos. Esto plantea algunas cuestiones
importantes. ¿Qué sucede si simplemente quería un cuadro y no cuidado (o saber) lo que fueron sus
dimensiones iniciales? O, ¿qué sucede si desea poder inicializar un cubo mediante la especificación
de un único valor que se utilizaría para las tres dimensiones? Como la clase de cuadro actualmente
está escrita, estas otras opciones no están disponibles para usted. Afortunadamente, la solución a
estos problemas es muy fácil: simplemente de sobrecarga del constructor de cuadro para que maneja
las situaciones que se acaba de describir. Aquí es un programa que contiene una versión mejorada
del cuadro que hace exactamente eso:
/* Here, Box defines three constructors to initialize
the dimensions of a box various ways.
*/
class Box {

2. double width;
double height;
double depth;
// constructor used when all dimensions specified
Box(double w, double h, double d) {
width = w;
height = h;
depth = d;
}
// constructor used when no dimensions specified
Box() {
width = -1; // use -1 to indicate
height = -1; // an uninitialized
depth = -1; // box
}
// constructor used when cube is created
Box(double len) {
width = height = depth = len;
}
// compute and return volume
double volume() {
return width * height * depth;
}
}
class OverloadCons {
public static void main(String args[]) {
// create boxes using the various constructors
Box mybox1 = new Box(10, 20, 15);
Box mybox2 = new Box();
Box mycube = new Box(7);
double vol;
// get volume of first box
vol = mybox1.volume();
System.out.println("Volume of mybox1 is " + vol);
// get volume of second box
vol = mybox2.volume();
System.out.println("Volume of mybox2 is " + vol);
// get volume of cube
vol = mycube.volume();
System.out.println("Volume of mycube is " + vol);
}
}
Aquí se muestra la salida producida por este programa:
Volume of mybox1 is 3000.0
Volume of mybox2 is -1.0

3. Volume of mycube is 343.0
Como puede ver, se llama al constructor sobrecargado adecuado en función de los parámetros
especificados cuando se ejecuta en nuevo.
Uso de objetos como parámetros
Hasta ahora hemos sólo se ha utilizando tipos simples como parámetros a los métodos. Sin embargo,
es correcto y común para pasar objetos a métodos. Por ejemplo, considere el siguiente programa
corto:
// Objects may be passed to methods.
class Test {
int a, b;
Test(int i, int j) {
a = i;
b = j;
}
// return true if o is equal to the invoking object
boolean equals(Test o) {
if(o.a == a && o.b == b) return true;
else return false;
}
}
class PassOb {
public static void main(String args[]) {
Test ob1 = new Test(100, 22);
Test ob2 = new Test(100, 22);
Test ob3 = new Test(-1, -1);
System.out.println("ob1 == ob2: " + ob1.equals(ob2));
System.out.println("ob1 == ob3: " + ob1.equals(ob3));
}
}
Este programa genera el siguiente resultado:
ob1 == ob2: true
ob1 == ob3: false
Como puede ver, el método equals de () dentro de prueba compara dos objetos para la igualdad y
devuelve el resultado. Es decir, compara el objeto invocando con uno que se pasa. Si contienen los
mismos valores, el método devuelve true. De lo contrario, devuelve false. Observe que el parámetro
o es igual a () especifica la prueba como su tipo. Aunque la prueba es un tipo de clase creado por el
programa, se utiliza en sólo del mismo modo que los tipos integrados de Java. Uno de los usos más
comunes de los parámetros del objeto implica constructores. Frecuentemente se desea construir un
nuevo objeto, por lo que inicialmente es el mismo que algún objeto existente. Para ello, debe definir

4. un constructor que toma un objeto de su clase como un parámetro. Por ejemplo, la siguiente versión
del cuadro de permite que un objeto inicializar otro:
// Here, Box allows one object to initialize another.
class Box {
double width;
double height;
double depth;
// construct clone of an object
Box(Box ob) { // pass object to constructor
width = ob.width;
height = ob.height;
depth = ob.depth;
}
// constructor used when all dimensions specified
Box(double w, double h, double d) {
width = w;
height = h;
depth = d;
}
// constructor used when no dimensions specified
Box() {
width = -1; // use -1 to indicate
height = -1; // an uninitialized
depth = -1; // box
}
// constructor used when cube is created
Box(double len) {
width = height = depth = len;
}
// compute and return volume
double volume() {
return width * height * depth;
}
}
class OverloadCons2 {
public static void main(String args[]) {
// create boxes using the various constructors
Box mybox1 = new Box(10, 20, 15);
Box mybox2 = new Box();
Box mycube = new Box(7);
Box myclone = new Box(mybox1);
double vol;
// get volume of first box
vol = mybox1.volume();
System.out.println("Volume of mybox1 is " + vol);
// get volume of second box
vol = mybox2.volume();

5. System.out.println("Volume of mybox2 is " + vol);
// get volume of cube
vol = mycube.volume();
System.out.println("Volume of cube is " + vol);
// get volume of clone
vol = myclone.volume();
System.out.println("Volume of clone is " + vol);
}
}
Como puede ver cuando comience a crear sus propias clases, proporcionando muchas formas de
métodos de constructor normalmente es necesario para permitir que los objetos que se construirán
en una manera conveniente y eficiente.