Antes que nada definiré lo que es herencia y polimorfismo. Después de lo anterior describiré las relaciones de herencia y polimorfismo presente en mi proyecto (si es que hay).
La herencia es una de las características más importantes y útiles de los lenguajes orientados a objetos. Consiste en definir una clase tomando como base una ya existente. Esto a la vez da origen a otra propiedad de los OO: la reutilización de código.
En Java, para poder llevar a cabo la herencia se tendrá que hacer uso de la palabra reservada extends después del nombre de la clase “hija”. Justo después de extends se escribirá el nombre de la clase de la cual se quiere heredar (padre).
Al heredar de una clase, heredaremos tanto sus atributos y métodos, siempre y cuando no sean privados; y en la clase “hija” aparte de utilizar esos atributos o métodos heredados, también se es posible agregar nuevas campos y funciones para cumplir con la situación nueva.
A la clase de la cual se hereda se le puede llamar de varias formas: clase padre (como ya se apreció arriba), superclase o clase base.
A la clase heredada se le llama comúnmente clase hija, subclase o clase derivada.
A continuación se presenta un sencillo ejemplo de herencia en java:
/*************************************************
* Clase cuya principal función es definir las
características habituales de una persona
*
*
*
**************************************************/
// Clase creada con la finalidad de ser superclase
public class Persona{
// Atributos protegidos que al ser heredados podrán ser manejados por la subclase
protected String nombre;
protected int edad;
// Contructor de la clase Persona
public Persona(String nombre, int edad){
this.nombre = nombre;
this.edad = edad;
}
//Método que devuelve el nombre
public String getNombre(){
return nombre;
}
//Método que devuelve la edad
public int getEdad(){
return edad;
}
//Método que permite modificar la edad
public void cambiarEdad(int edad){
this.edad = edad;
}
}
/*************************************************
* Clase que permite definir estudiantes
*
*
*
**************************************************/
/* Clase llamada Estudiante que hereda de la clase Persona y por lo tanto
tiene la capacidad de manejar los atributos y métodos de la superclase*/
public class Estudiante extends Persona{
//Aparte de tener un nombre y edad, el estudiante cuenta con una matrícula
private int matricula;
//Constructor de la clase Estudiante
public Estudiante(int matricula){
/*Con la llamada de super aplicamos la reutilización de código lo cual hace que
no tengamos que escribir más*/
super("Juan", 19); //Hace referencia al constructor de la superclase
this.matricula = matricula;
}
//Devuelve la matrícula
public int getMatricula(){
return matricula;
}
}
/*************************************************
* Clase que permite crear estudiantes
*
*
*
**************************************************/
public class Main{
public static void main(String[] args){
//Se crea un objeto de la clase Estudiante con el nombre de est1
Estudiante est1 = new Estudiante(1464573);
/*Imprime los datos del estudiante además de que comprueba que la herencia
fue un éxito*/
System.out.printf("\n El nombre del estudiante est1 es %s cuya edad es %d anios \n ", est1.getNombre(),est1.getEdad());
System.out.printf("y tiene por matricula %d\n\n", est1.getMatricula());
}
}
El polimorfismo es otra de las características distintivas de los Lenguajes Orientados a Objetos. Significa muchas formas y una de sus aplicaciones se encuentra en los métodos o constructores.
Hay varios tipos de polimorfismo. Tratar todos ellos sería muy largo, por eso me basare solamente en el polimorfismo paramétrico.
El polimorfismo paramétrico es cuando dos o más métodos o constructores tienen el mismo nombre pero reciben parámetros distintos. Por ejemplo:
public class Pez{
private int velocidad;
private int profundidad;
public Pez(){
}
public void nadar(int velocidad){
}
public class nadar(int velocidad, int profundidad){
}
}
El ejemplo de arriba es un poco vago sin embargo es bueno para mostrar el polimorfismo paramétrico.
Mi proyecto
Mi proyecto, como ya está mencionado en las primera entradas de este blog, es un editor de texto. Si lo divido podría pensar en una parte lógica y en una parte gráfica.
La parte lógica es la parte funcional de mi aplicación, mientras que la gráfica es la parte con lo que interactuará el usuario.
Lo ideal es que la herencia y el polimorfismo se apliquen a mi parte lógica sin embargo en mi proyecto no pasa así.
Mi proyecto lo ideé para que cada menú tuviera su clase, por ejemplo, crearé la clase menu_archivo y ahí entrarán las funcionalidades de mis menú ítems, y así sucesivamente. Ya verifique cada una de las clases y no se aplicará la herencia ni el polimorfismo en la parte funcional, y eso no significa que este mal, sin embargo la intención es aplicarlo para entenderlo.
FUENTES
