Diario de un Aprendiz de Java

Tuesday, May 24, 2005

Sobrecarga, de métodos y de constructores

Los constructores son métodos, con el mismo nombre de la clase, que sirven para definir el valor de las variables de la clase cuando creas el objeto.
Un ejemplo sería este
class UnaClase {
  byte unaVariable, otraVariable;

/*Ahora crearemos el constructor. Como veis, tiene el mismo nombre que la clase.*/
  UnaClase(byte x, byte y) {
   unaVariable = x; otraVariable = y;
  }
}

Con este constructor ya definido, podremos asignar valores a las variables de la clase justo en el momento en que creamos el objeto.
UnaClase objeto1 = new UnaClase(10,12)
Como podeis ver, en este caso la variable unaVariable del objeto objeto1 tendría el valor 10, y objeto1.otraVariable valdría 12.

Por otro lado, es muy posible que diferentes objetos que se basan en la misma clase no necesiten usar el mismo constructor. Imaginemos una clase Clientes, con su nombre, su edad y el nombre de la empresa como variables. De algunos de los objetos que creemos basandonos en esta base conoceremos todos los datos, pero siempre habrá alguno del que desconozcamos la edad, o incluso su nombre. Aqui entra en juego la sobrecarga de constructores, que consiste en crear un constructor para cada posibilidad (real[*]) que tengamos.

[*]Como estoy cansado de decir, se tiene que conseguir un equilibrio entre usabilidad (muchos constructores) y codigo entendible (pocos constructores). El programador eficiente debe ser capaz de declarar solo aquellos constructores que realmente se van a usar, sin caer en la tentació de crear constructores para todos los posibles casos, por muy incoherentes que parezcan.

class Cliente {
  String nombre, nombreEmpresa;
  int edad;

/*El constructor que viene a continuación se usará en el caso de que se conozcan todas las variables*/
  Cliente(String nombre, String nombreEmpresa, int edad) {
   this.nombre = nombre;
   this.nombreEmpresa = nombreEmpresa;
   this.edad = edad;
  }

/*También es provable que conozcamos el nombre del cliente, y el nombre de su empresa, pero desconozcamos su edad. Por esto vamos a declarar un constructor asi. */
  Cliente(String nombre, String nombreEmpresa) {
   this.nombre = nombre;
   this.nombreEmpresa = nombreEmpresa;
  }
}

class Sobrecarga {
  public static void main(String [] args) {
   String nombre, empresa;
   int edad;

/*Ahora creamos un objeto basandonos en la clase cliente, imaginando que conocemos todos los valores*/
   Cliente paco = new Cliente("Paco","EmpresaFalsa",55);
/*Aqui un objeto de la clase Cliente del que desconocemos la edad*/
   Cliente julian = new Cliente("Julian","EmpresaFalsa");

   nombre = paco.nombre;
   empresa = paco.nombreEmpresa;
   edad = paco.edad;

   System.out.println(nombre + ", de " + empresa + ", tiene " + edad);

   nombre = julian.nombre;
   empresa = julian.nombreEmpresa;
   edad = julian.edad;

   System.out.println(nombre + " trabaja en " + empresa + ".");
  }
}


La sobrecarga de métodos es justo lo mismo; creamos varios métodos con el mismo nombre que actuen diferente segun el tipo de los parámetros de entrada. Por ejemplo, queremos hacer un método que devuelva el resultado de la suma de los dos parametros de entrada, pero no sabemos si será un entero o si tendrá decimales, así que tendremos que hacer un método para el caso de los decimales, y otro con el mismo nombre para el caso de los enteros.

class Calculadora {
  int suma(int x, int y) {
   return (x + y);
  }

  float suma(float x, float y) {
   return (x + y);
  }
}

class Servo {
  public static void main(String[] args) {
   int operacion1;
   float operacion2;

   Calculadora sumador = new Calculadora();
   operacion1 = sumador.suma(2,3);
   operacion2 = sumador.suma(0.23F, 12.53F);

   System.out.println("La suma de los enteros 2 y 3 es " + operacion1);
   System.out.println("Sumando 0.23 y 12.53, se consigue " + operacion2);
  }
}

25 Comments:

Post a Comment

<< Home