Conceptos sobre polimorfismo y programacin

orientada a objetos
El polimorfismo, en programacin orientada a objetos, se refiere a la
posibilidad de acceder a un variado rango de funciones distintas a travs
del mismo interfaz. O sea, un mismo identificador puede tener distintas
formas

(distintos

cuerpos

de

funcin,

distintos

comportamientos)

dependiendo del contexto en el que se halle. El polimorfismo se puede

establecer mediante sobrecarga, sobre-escritura y enlace dinmico.

Sobrecarga
Este trmino se refiere al uso del mismo identificador u operador en
distintos contextos y con distintos significados.
Si para cada funcionalidad necesitada fuese necesario escribir un mtodo,
el

cdigo

resultante

sera

inmanejable.

Supongamos

que

los

desarrolladores de Java hubiesen creado un mtodo para escribir en

pantalla una cadena de texto, otro diferente para escribir un entero, otro
para un doble, y as para todas las combinaciones posibles, seria casi
imposible

conocer

dichos

mtodos

en

totalidad.

En

cambio,

con

System.out.print() o System.out.println() podemos escribir cualquier

mensaje en pantalla.
Este tipo de codificacin nos es permitido gracias a la sobrecarga, la cual
se aplica a mtodos y constructores.
La sobrecarga de mtodos hace que un mismo nombre pueda representar
distintos mtodos con distinto tipo y nmero de parmetros, manejados
dentro de la misma clase. En el mbito de la POO, la sobrecarga de
mtodos se refiere a la posibilidad de tener dos o ms mtodos con el
mismo nombre pero distinta funcionalidad. Es decir, dos o ms mtodos
con el mismo nombre realizan acciones diferentes y el compilador usar
una u otra dependiendo de los parmetros usados. Esto tambin se aplica
a los constructores (de hecho, es la aplicacin ms habitual de la
sobrecarga).

Podemos diferenciar varios mtodos sobrecargados a travs de sus

parmetros, ya sea por la cantidad, el tipo o el orden de los mismos.
Veamos un ejemplo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class Articulo {

private float precio;
public void
precio
}
public void
precio
}
public void
precio
}

setPrecio() {
= 3.50;
setPrecio(float nuevoPrecio) {
= nuevoPrecio;
setPrecio(float costo, int porcentajeGanancia) {
= costo + (costo * porcentajeGanancia);

Sobreescritura
La sobreescritura se aplica a los mtodos y est directamente relacionada
a la herencia; se refiere a la redefinicin de los mtodos de la clase base
en las subclases. Por ejemplo, en la relacin de herencia del ejemplo de
las figuras aunque la clase base Figura tiene los mtodos calcularArea
y calcularPerimetro, las subclases Circulo, Cuadrado, Triangulo y
Rectangulo redefinen estos mtodos ya que el calculo del rea y el
permetro de cada uno de ellos es diferente.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class Figura {
protected double area;
protected double perimetro;
public Figura() {
this.area=0;
this.perimetro=0;
}
public double getArea() {
return area;
}
public double getPerimetro() {
return perimetro;
}
public void calcularArea(){}
public void calcularPerimetro(){}
}

16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

public class Circulo extends Figura {

private double radio;
public Circulo() {
super();
}
public double getRadio() {
return radio;
}
public void setRadio(double radio) {
this.radio = radio;
}
public void calcularArea() {
this.area = Math.PI*Math.pow(this.radio,2.0);
}
public void calcularPerimetro() {
this.perimetro = 2*Math.PI*this.radio;
}
}

Enlace dinmico
Esto permite invocar operaciones en objetos obviando el tipo actual de
stos hasta el momento de ejecutar el cdigo. O sea, nos permite definir
elementos como un tipo e instanciarlos como un tipo heredado. Pero qu
utilidad tiene obviar el tipo de un objeto para luego tomar esta decisin?.
Gracias a que en java la definicin de los tipos de objetos se puede
producir por enlazado posterior (late binding), no nos debe preocupar a
qu tipo de elemento le paso un mensaje, ya que el compilador tomar la
decisin sobre qu objeto ejecutar qu mtodo de acuerdo a la forma de
crear la instancia.
Este concepto es bastante complejo de entender, ya que estamos
acostumbrados a definir los elementos de acuerdo a lo que necesitamos.
Es decir, si requiero un entero lo declaro como entero; para que declarar
un elemento como un tipo y luego usarlo como otro?. La respuesta est en

que no siempre se puede determinar exactamente el tipo de elemento que

va a usarse en la ejecucin de nuestro programa.
Se debe tener por lo menos una relacin de herencia que permita
determinar un tipo base para la declaracin, sea cual sea el subtipo que se
instancie. Veamos un ejemplo que nos aclare un poco las cosas:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

class Mamifero {
public void mover() {
System.out.println("Ahora es un mamifero el que se mueve");
}
}
class Perro extends Mamifero {
public void mover() {
System.out.println("Ahora es un perro el que se mueve");
}
}
class Gato extends Mamifero {
public void mover() {
System.out.println("Ahora es un gato el que se mueve");
}
}
public class Polimorfismo {
public static void muevete(Mamifero m) {
m.mover();
}
public static void main(String[] args) {
Gato bisho = new Gato();
Perro feo = new Perro();
muevete(bisho);
muevete(feo);
}
}

Vemos que el mtodo muevete llama al mtodo mover de un mamfero y

aunque no sabe con qu clase de mamfero trata, funciona y se llama al
mtodo correspondiente al objeto especfico que lo llama (es decir,
primero un gato y luego un perro). Si no existiera el enlace dinmico,
tendramos que crear un mtodo muevete para los mamferos de tipo
Gato y otro para los de tipo Perro.

Veamos otro ejemplo donde las instancias se crean de forma aleatoria:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

public abstract class Instrumento {

public Instrumento() { }
public abstract void tocar();
public abstract void tocar(String nota);
public abstract void afinar();
}
public class Cuerda extends Instrumento{
public Cuerda() {}
public void afinar() {
System.out.println("Cuerda.afinar()");
}
public void tocar() {
System.out.println("Cuerda.tocar()");
}
public void tocar(String nota){
System.out.println("Cuerda.tocar()"+nota);
}
}
public class Percusion extends Instrumento{
public Percusion() {}
public void afinar() {
System.out.println("Percusion.afinar()");
}
public void tocar() {
System.out.println("Percusion.tocar()");
}
public void tocar(String nota){
System.out.println("Percusion.tocar()"+nota);
}
}
public class Viento extends Instrumento{
public Viento() {}
public void afinar() {
System.out.println("Viento.afinar()");
}
public void tocar() {
System.out.println("Viento.tocar()");
}
public void tocar(String nota){
System.out.println("Viento.tocar()"+nota);
}
}
public class LigaduraDinamica {
public static void main(String[] args){
String[] notas = {"Do","Re","Mi","Fa","Sol","La","Si"};
Instrumento orquesta[] = new Instrumento[10];
for(int i=0;i<10;i++){
orquesta[i]=generarInstrumento(new java.util.Random().nextInt(3));

45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

}
for(int i=0;i<10;i++){
afinarInstrumento(orquesta[i]);
}
for(int i=0;i<10;i++){
tocarInstrumento(orquesta[i]);
}
for(int i=0;i<10;i++){
tocarInstrumento(orquesta[i],notas[i%7]);
}
}
public static Instrumento generarInstrumento(int i){
switch(i){
default:
case 0:
return new Viento();
case 1:
return new Percusion();
case 2:
return new Cuerda();
}
}
public static void afinarInstrumento(Instrumento o){
o.afinar();
}
public static void tocarInstrumento(Instrumento o){
o.tocar();
}
public static void tocarInstrumento(Instrumento o,String nota){
o.tocar(nota);
}
}

92
Vemos que el mtodo generarInstrumento crea aleatoriamente las
instancias de los diferentes tipos de instrumentos y que el arreglo de
elementos del tipo de instrumentos es llenado con diferentes elementos
de los cuales slo sabemos que son objetos basados en Instrumento.
Sin embargo, los mtodos tocarInstrumento y afinarInstrumento que
reciben como parmetro un Instrumento llaman adecuadamente a los
mtodos afinar o tocar segn la instancia que reciben.