Facultad de Ciencias

Matemáticas y Físicas
Carrera de Ingeniería en
Tecnologías de Información

Polimorfismo

Proyecto de Investigación de la
asignatura de Programación
Orientada a objetos
correspondiente al ciclo CII - 2020

Paralelo:
Integrantes:
Emily Aguilar
Gissel Rivera
Anthony Caicedo
Yamileth Espinoza
Shamary Muñoz
Instructor:
Ing. ESPINOZA MARTINEZ MARIELA PAOLA

Guayaquil – Ecuador
2020 - 2021
SOBRECARGA
Polimorfismo de sobrecarga: ocurre cuando existen métodos con el mismo nombre y
funcionalidad similar en clases totalmente independientes entre ellas. Por ejemplo,
podemos definir el operador suma (+), llamado igual en dos clases independientes, pero
en una de ellas suma números y en otra suma caracteres produciendo concatenación.

En el polimorfismo por sobrecarga puede darse de 3 formas diferentes:

 Clase: ocurre cuando en una clase existe dos métodos con idéntico nombre,
pero con distinta lista de parámetros.
 Funciones: hay dos o más funciones que pueden compartir el mismo nombre
siempre que la declaración de sus parámetros sean diferentes.
 Operadores: cuando un operador se sobrecarga, adquiere un significado
adicional relativo a una determinada clase. No obstante, sigue manteniendo
todos sus significados anteriores.
Diferencias entre sobrecarga y polimorfismo
La sobrecarga hace referencia a un conjunto de métodos en el mismo nombre, pero
diferente número de parámetro y/o tipos de estos, además que estos métodos se
encuentran definidos en una clase. En cambio, que el polimorfismo hace referencia a un
conjunto de métodos con el mismo nombre e igual número de parámetros y tipos, pero
que se encuentran definidos en diferentes clases.
Sobreescritura
La Sobreescritura es la forma por la cual una clase que hereda puede re-
definir los métodos de su clase Padre, de esta manera puede crear nuevos métodos con
el mismo nombre de su superclase, es decir, si tengo una clase padre con el
método ingresar () yo puedo crear en la clase hija un método que también se
llame ingresar () pero implementándolo según lo que necesite a esto se le
llama sobreescritura.
Así como en la sobrecarga nos fijamos en los parámetros, en la sobreescritura nos
debemos fijar en que la estructura del método sea igual a la de su superClase, no solo el
mismo nombre sino el mismo número de argumentos y tipo de retorno (o al menos un
subtipo de este), así como no tener un nivel de acceso más restrictivo que el original
(que en la clase padre sea protected y en la hija sea private, por ejemplo) .... tampoco se
pueden sobreescribir métodos static ni final.... (ya que static representa métodos
globales y final constantes...)

Algo que también debemos mencionar es que podemos identificar un método

sobreescrito cuando tiene la anotación @override, esto es muy común encontrarlo
cuando trabajamos con clases abstractas o interfaces, donde se obliga a implementar los
métodos de estas si son heredadas o implementadas respectivamente...... sin embargo no
es obligatorio ponerlo pero si es recomendable (tal como lo menciona "David" en un
comentario de esta entrada sobre el polimorfismo) pues de esta manera el compilador
reconoce que se están sobreescribiendo los métodos ayudando a que si nos
equivocamos al crear un método distinto, el compilador
nos avisaría....... adicionalmente si tenemos la anotación inmediatamente podremos
saber que se está aplicando el concepto, algo muy útil cuando trabajamos con código de
otras personas...

Veamos un ejemplo donde se sobreescribe el método tocar ()

Public class Instrumento {

public String tipo;

public void tocar ()

{
System.out.println("Tocar un Instrumento");
}
}

class Guitarra extends Instrumento {

@Override
public void tocar () {
System.out.println("Tocar La Guitarra");
}

Como vemos la clase Guitarra hereda de la clase Instrumento, esta última tiene
el método tocar () con una implementación diferente a la del método en la clase Guitarra
(el mensaje es distinto), al tener la anotación @Override nos damos cuenta que se está
sobreescribiendo dicho método y se le puede dar la lógica que queramos específica para
la clase.Guitarra....

Ingresar a uno u otro método depende de la lógica del llamado.... también es algo muy
ligado al polimorfismo donde por medio de este se puede acceder a uno u otro
método…. por ejemplo, si queremos acceder al método tocar () de la clase guitarra
aplicando la sobreescritura y el polimorfismo tendríamos que hacer una instancia de la
clase padre con un objeto de la clase hija así:

Instrumento miGuitarra=new Guitarra ();

miGuitarra.tocar();
Enlace dinámico
Es importante entender qué método es usado al invocar a un nombre que se puede referir
a instancias de distinta clase. Al momento de la compilación, el compilador intenta
resolver el método que corresponde según su nombre y parámetros.
Si la superclase y la clase base tienen definido el mismo método, el problema es a cuál
llama. Si el método en la clase declarada para la variable no es privado, static, o final, se
invocará en forma dinámica. Esto es, se invocará el método definido según el objeto
referenciado por el nombre y no según la declaración del nombre. Por ello, si una clase
derivada redefine el mismo método, éste será invocado para sus instancias.
Ejemplo:

El ligado o enlace dinámico se resuelve a tiempo de ejecución.

Ventajas del enlace dinámico:
1. La sobreescritura de métodos permite a Java admitir el polimorfismo en tiempo
de ejecución.
2. El polimorfismo es esencial en la programación orientada al objeto ya que
permite que una clase general especifique métodos que serán comunes a todas
las clases derivadas, permitiendo a éstas definir la implementación específica de
alguno de estos métodos.
3. Esta forma de polimorfismo dinámico durante la ejecución es uno de los
mecanismos más poderosos que ofrece la orientación a objeto para soportar
reutilización de código y robustez.
4. La capacidad que tienen las bibliotecas de código existentes de llamar métodos
de instancias nuevas de clases sin volver a compilarlos, pero manteniendo a vez
la interfaz abstracta y limpia, es una herramienta poderosa.
UpCasting y DownCasting
Queremos guardar una serie de objetos Mesa en un ArrayList.
El ArrayList sólo admite objetos de tipo Object, pero como Mesa hereda de Object (como
todos los objetos) puedes meter mesas directamente en el ArrayList:
ArrayList miLista = new ArrayList();
miLista.add(new Mesa());
Cuando metes un objeto Mesa en un ArrayList, Java hace un cast implícito al tipo Object.
Esto se conoce como «upcasting», es decir, moldear un objeto al tipo de una de sus
superclases.
Ahora bien, si necesitamos recuperar uno de esos objetos Mesa, debemos hacer lo
siguiente:
Mesa m = (Mesa)miLista.get(0);
El cast es necesario porque el método get() devuelve objetos de tipo Object. Pues bien, a
esta operación se le llama «downcasting», porque estás moldeando un objeto a una de sus
subclases.
Ahora cuidado: no puedes moldear un objeto Mesa a Object y luego moldear ese Object
a Silla, por ejemplo, porque no funcionará. Sólo puedes hacer upcasting y downcasting
dentro de la jerarquía de herencia del objeto, o dicho de otra forma, sólo puedes moldear
el objeto a una de las clases comprendidas entre la clase Object y el tipo original del
objeto (ambos inclusive), pasando por todas sus superclases.
Wrappers Classes
Los Wrappers java (envoltorios) son clases diseñadas para ser un complemento de los
tipos primitivos siendo los únicos elementos de Java que no son objetos, el cual, tiene
algunas ventajas desde el punto de vista de la eficiencia, pero algunos inconvenientes
desde el punto de vista de la funcionalidad. Por ejemplo, los tipos primitivos siempre se
pasan como argumento a los métodos por valor, mientras que los objetos se pasan por
referencia. No hay forma de modificar en un método un argumento de tipo primitivo y
que esa modificación se trasmita al entorno que hizo la llamada. Una forma de conseguir
esto es utilizar un Wrapper, esto es un objeto cuya variable miembro es el tipo primitivo
que se quiere modificar. Las clases Wrapper también proporcionan métodos para realizar
otras tareas con los tipos primitivos, tales como conversión con cadenas de caracteres en
uno y otro sentido.
Funcionamiento de los Wrappers
Los Wrappers java son utilizados para convertir cadenas de caracteres (texto) en números.
Esto es útil cuando se leen valores desde el teclado, desde un fichero de texto, etc. Los
ejemplos siguientes muestran algunas conversiones: String numDecimalString = "8.978";
float numFloat = Float.valueOf(numDecimalString).floatValue();
double numDouble = Double.valueOf(numDecimalString).doubleValue();
String numIntString = "1001";
int numInt = Integer.valueOf(numIntString).intValue();
En el caso de que el texto no se pueda convertir directamente al tipo especificado se lanza
una excepción de tipo NumberFormatException, por ejemplo si se intenta convertir
directamente el texto “4.897” a un número entero. El proceso que habrá que seguir será
convertirlo en primer lugar a un número float y posteriormente a número entero.