Está en la página 1de 19

Direccin General de Educacin Superior Tecnolgica

INSTITUTO TECNOLGICO DE SALINA CRUZ



UNIDAD 5 HERENCIA Y POLIMORFISMO
TRABAJO DE INVESTIGACION DE LA UNIDAD 5
MATERIA:
PROGRAMACIN ORIENTADA A OBJETOS
DOCENTE:
M.C. SUSANA MONICA ROMAN NAJERA

NOMBRE DE LA ALUMNA:
BENITA VILLALOBOS PEREZ

N. DE CONTROL: 131020103
SEMESTRE: 2 GRUPO: E2

CARRERA:
ING. EN TECNOLOGAS DE LA INFORMACIN Y DE LAS COMUNICACIONES.

SALINA CRUZ, OAXACA A MAYO DE 2014.








INDICE

INTRODUCCIN ........................................................................................................................................ 1
CONCEPTO DE HERENCIA Y POLIMORFISMO ........................................................................................... 2
Definicin de una clase base .................................................................................................................... 3
Definicin de una clase derivada ............................................................................................................. 5
Clases abstractas ...................................................................................................................................... 6
Declaracin e implementacin de mtodos abstractos ............................................................... 6
Definicin de herencia mltiple ............................................................................................................... 7
Java y la herencia mltiple ................................................................................................................... 8
Ejemplo: herencia e interfaces ............................................................................................................. 8
Implementacin de herencia mltiple ................................................................................................... 10
Reutilizacin de la definicin de paquetes / libreras. ........................................................................... 12
Clases genricas (Plantillas).................................................................................................................... 14
CONCLUSIONES ...................................................................................................................................... 16
OTRAS FUENTES CONSULTADAS ............................................................................................................ 17












1

INTRODUCCIN
Una de las ventajas de la programacin orientada a objetos es que tiene dos grandes
caractersticas como la herencia y el polimorfismo el cual nos ayuda a utilizar super
clases y subclases.
Conocer el concepto de herencia y polimorfismos, entenderlos y ponerlas en
prcticas en el momento en que estemos programando para as poder conocerlos
como y cuando utilizarlo.
En la unidad 5 se est realizando sobre el tema de herencia y polimorfismo
conociendo sus subtemas correspondientes. As como tambin saber cules sus
caractersticas, desventajas de la herencia y del polimorfismo para eso se est
llevando a cabo esta investigacin.
Esperando que esta investigacin contenga la informacin necesaria as como
tambin las caractersticas y el docente puedan evaluar y de una crtica constructiva
para mejorar da a da.












2

DESARROLLO DEL TRABAJO
CONCEPTO DE HERENCIA Y POLIMORFISMO
La herencia es el mecanismo fundamental de relacin entre clases en la orientacin
a objetos. Relaciona las clases de manera jerrquica; una clase padre o superclase
sobre otras clases hijas o subclases.

Imagen 1
Los descendientes de una clase heredan todas las variables y mtodos que sus
ascendientes hayan especificado como heredables, adems de crear los suyos
propios.
La caracterstica de herencia, nos permite definir nuevas clases derivadas de otra ya
existente, que la especializan de alguna manera. As logramos definir una jerarqua
de clases, que se puede mostrar mediante un rbol de herencia.
En todo lenguaje orientado a objetos existe una jerarqua, mediante la que las clases
se relacionan en trminos de herencia. En Java, el punto ms alto de la jerarqua es
la clase Object de la cual derivan todas las dems clases.
La herencia es una propiedad esencial de la Programacin Orientada a Objetos que
consiste en la creacin de nuevas clases a partir de otras ya existentes. Este trmino
ha sido prestado de la Biologa donde afirmamos que un nio tiene la cara de su
padre, que ha heredado ciertas facetas fsicas o del comportamiento de sus
progenitores.
La herencia es la caracterstica fundamental que distingue un lenguaje orientado a
objetos, como el C++ o Java, de otro convencional como C, BASIC, etc. Java permite
heredar a las clases caractersticas y conductas de una o varias clases denominadas
base. Las clases que heredan de clases base se denominan derivadas, estas a su
vez pueden ser clases bases para otras clases derivadas. Se establece as una
clasificacin jerrquica, similar a la existente en Biologa con los animales y las
plantas.
La herencia ofrece una ventaja importante, permite la reutilizacin del cdigo. Una
vez que una clase ha sido depurada y probada, el cdigo fuente de dicha clase no
necesita modificarse. Su funcionalidad se puede cambiar derivando una nueva clase
que herede la funcionalidad de la clase base y le aada otros comportamientos.

3

Reutilizando el cdigo existente, el programador ahorra tiempo y dinero, ya que
solamente tiene que verificar la nueva conducta que proporciona la clase derivada.
El concepto de Polimorfismo es uno de los fundamentos para cualquier lenguaje
orientado a Objetos, las mismas races de la palabra pueden ser una fuerte pista de
su significado: Poli = Multiple, morfismo= Formas, esto implica que un mismo Objeto
puede tomar diversas formas.
El polimorfismo es una de las cualidades de ms difcil comprensin de la POO. Una
de las ventajas de estos lenguajes es su flexibilidad y el polimorfismo una de las
herramientas que potencian esta cualidad. El polimorfismo tiene un uso muy grfico
cuando hacemos uso de la herencia.

El polimorfismo consiste en que toda referencia a un objeto de una clase especfica
puede tomar la forma de una referencia a un objeto de una clase heredada a la suya.

Con el polimorfismo (sig. Varias formas) se consigue que las instancias de una clase
padre puedan hacer uso de las funcionalidades de las clases hijas: misma instancia
que se comporta de varias (poli) maneras (morfismo).

Imagen 2

Definicin de una clase base
Una clase base es aquella que no dependen ninguno de sus atributos u objetos de la
clase de alguna otra clase, se podra decir que en trminos de herencia, sera la
clase padre, la clase que se mantiene fija, en el aspecto de herencia.

4

Es tambin por as llamarlo la clase principal de un programa, sera la clase primaria
sin incluir la clase main en donde se corre todo el programa en s.
Adems de las clases bases, existen las llamadas clases derivadas, son clases que
dependen de las clases bases, ya que algunos de sus mtodos son tambin
heredados, y muchas veces, el compilador arrojara malos resultados, ya que al ser
dependientes estas clases, a veces podrn generar errores lgicos.
He aqu un ejemplo de lo que seran las clases bases y clases derivadas, y de cmo
se demuestra la dependencia de la derivada con la clase base:
public abstract class Figura {
protected int x;
protected int y;
public Figura (int x, int y) {
this.x=x;
this.y=y;
}
public abstract double area ();
}
class Rectangulo extends Figura {
protected double ancho, alto;
public Rectangulo (int x, int y, double ancho, double alto){
super (x,y);
this.ancho=ancho;
this.alto=alto;
}
public double area () {
return ancho*alto;

5

}
}
Definicin de una clase derivada
La clase derivada heredar los miembros dato de la clase base y las funciones
miembro, y tendr un miembro dato ms, el ttulo de la ventana.
public class VentanaTitulo extends Ventana {
protected String titulo;
public VentanaTitulo (int x, int y, int w, int h, String nombre) {
Super(x, y, w, h);
titulo=nombre;
}
Extends es la palabra reservada que indica que la clase VentanaTitulo deriva, o es
una subclase, de la clase Ventana.
La primera sentencia del constructor de la clase derivada es una llamada al
constructor de la clase base mediante la palabra reservada super. La llamada
super(x, y, w, h);
Inicializa los cuatro miembros dato de la clase base Ventana: x, y, ancho, alto. A
continuacin, se inicializan los miembros dato de la clase derivada, y se realizan las
tareas de inicializacin que sean necesarias. Si no se llama explcitamente al
constructor de la clase base Java lo realiza por nosotros, llamando al constructor por
defecto si existe.
La funcin miembro denominada desplazar cambia la posicin de la ventana,
aadindoles el desplazamiento.
public void desplazar (int dx, int dy){
x+=dx;
y+=dy;
}
Redefine la funcin miembro mostrar para mostrar una ventana con un ttulo.
public void mostrar (){
super.mostrar();
System.out.println ("titulo : "+titulo);
}

6

En la clase derivada se define una funcin que tiene el mismo nombre y los mismos
parmetros que la de la clase base. Se dice que redefinimos la funcin mostrar en la
clase derivada. La funcin miembro mostrar de la clase derivada VentanaTitulo hace
una llamada a la funcin mostrar de la clase base Ventana, mediante
super.mostrar();
De este modo aprovechamos el cdigo ya escrito, y le aadimos el cdigo que
describe la nueva funcionalidad de la ventana por ejemplo, que muestre el ttulo.
Si nos olvidamos de poner la palabra reservada super llamando a la funcin mostrar,
tendramos una funcin recursiva. La funcin mostrar llamara a mostrar
indefinidamente.
public void mostrar (){ //ojo!, funcin recursiva
System.out.println ("titulo : "+titulo);
mostrar ();
}
Para indicar que una clase deriva de otra, heredando sus propiedades (mtodos y
atributos), se usa el trmino extends, como en el siguiente ejemplo:
public class SubClase extends SuperClase {
// Contenido de la clase
}
Clases abstractas
Un mtodo abstracto es un mtodo declarado en una clase para el cual esa clase no
proporciona la implementacin (el cdigo). Una clase abstracta es una clase que
tiene al menos un mtodo abstracto. Una clase que extiende a una clase abstracta
debe implementar los mtodos abstractos (escribir el cdigo) o bien volverlos a
declarar como abstractos, con lo que ella misma se convierte tambin en clase
abstracta.
Declaracin e implementacin de mtodos abstractos
Siguiendo con el ejemplo del apartado anterior, se puede escribir:
abstract class FiguraGeometrica {
. . .
abstract void dibujar ();
. . .
}

7


class Circulo extends FiguraGeometrica {
. . .
void dibujar() {
// codigo para dibujar Circulo
. . .
}
}
La clase abstracta se declara simplemente con el modificador abstract en su
declaracin. Los mtodos abstractos se declaran tambin con el mismo modificador,
declarando el mtodo pero sin implementarlo (sin el bloque de cdigo encerrado
entre {}). La clase derivada se declara e implementa de forma normal, como
cualquier otra. Sin embargo si no declara e implementa los mtodos abstractos de la
clase base (en el ejemplo el mtodo dibujar) el compilador genera un error indicando
que no se han implementado todos los mtodos abstractos y que, o bien, se
implementan, o bien se declara la clase abstracta.
Clases Abstractas.
Al ser utilizado Herencias ("Inheritance") y/o Polimorfismo es muy comn que en la
Clase Base existan mtodos diseados nicamente con el propsito de ofrecer una
gua para las Clases heredadas, en Java existe un vocablo que permite prohibir el
uso de mtodos en Clases Base, este calificativo es : abstract. Al ser definido un
mtodo como abstract se restringe que ste sea llamado directamente, cuando una
Clase contiene un mtodo de este tipo a sta se le llama: Clase Abstracta.
Al ser definida una Clase, adems de ser declarados los mtodos/campos como
abstract tambin es necesario utilizar el vocablo abstract en la definicin de cada
Clase.
Una de las caractersticas de las Clases que Heredan ("Inherit") de una Clase
abstracta, es que stas deben definir los mismos mtodos definidos en la Clase
Base; en Java existe otro mecanismo que permite llevar acabo diseos donde se
parte de una Estructura o Cpsula.
Definicin de herencia mltiple
En la orientacin a objetos, se consideran dos tipos de herencia, simple y mltiple.
En el caso de la primera, una clase slo puede derivar de una nica superclase. Para
el segundo tipo, una clase puede descender de varias superclases.

8

En Java slo se dispone de herencia simple, para una mayor sencillez del lenguaje,
si bien se compensa de cierta manera la inexistencia de herencia mltiple con un
concepto denominado interface, que estudiaremos ms adelante.
Herencia mltiple hace referencia a la caracterstica de los lenguajes de
programacin orientada a objetos en la que una clase puede heredar
comportamientos y caractersticas de ms de una superclase. Esto contrasta con la
herencia simple, donde una clase slo puede heredar de una superclase.
Lenguajes que soportan herencia mltiple en su mayor parte son: C++, Centura SQL
Windows, CLOS, Eiffel, Object REXX, Perl y Python.
La herencia mltiple permite a una clase tomar funcionalidades de otras clases,
como permitir a una clase llamada MusicoEstudiante heredar de una clase llamada
Persona, una clase llamada Msico, y una clase llamada Trabajador. Esto puede ser
abreviado como MusicoEstudiante : Persona, Msico, Trabajador.
En algn momento, un programador puede estar tentado a derivar una clase nica
de varias clases. Esto se conoce como "herencia mltiple" y aunque parece til,
puede provocar problemas, como el importante "problema del diamante". Este
problema ocurre cuando dos clases heredan de la misma clase (como la clase B y C
derivan de la clase A), mientras que otra clase (D) deriva de B y C. Cuando se crea
un objeto D, el sistema lo trata como un tipo de clase base (clase "Ball" o bola y
"Sphere" o esfera, por ejemplo). En el problema del diamante, el sistema no puede
determinar de forma decisiva qu clase D (es tipo A-B-D o tipo A-C-D?) es la que
causa problemas.
Java y la herencia mltiple
Debido a los problemas con la herencia mltiple, Java no la permite. Pero en realidad
las clases derivadas de varias clases base pueden conseguirse de una forma segura
usando "interfaces". Una interfaz es parecida a una clase, pero no slo define la
estructura de la clase, sino tambin su cdigo real. Una clase base que implementa
una interfaz no "hereda" necesariamente la funcionalidad de la interfaz: slo promete
el uso de su estructura. Puesto que una clase que implementa una interfaz no hereda
de otra clase (y no es un tipo de la clase base), un programador puede implementar
varias interfaces usando la misma clase.
Ejemplo: herencia e interfaces
El siguiente ejemplo muestra la diferencia entre la herencia de objetos y una interfaz.
Una clase que hereda de otra consigue acceso a la clase base porque se convierte
bsicamente en un tipo de esa clase (como en las clases "Ball" y "Sphere"). Una
clase que implementa una interfaz slo promete implementar la estructura de su

9

interfaz: no es un tipo de esa interfaz: interface Basic {int doubl A(); // nota: no se
define cdigo real en la interfaz } public class B implements Basic{ public int a; public
int doubleA() //la clase B debe definir el mtodo "doubleA()" para implementar "Basic"
{return a * 2;} }
Java es un lenguaje que incorpora herencia simple de implementacin pero que
puede aportar herencia mltiple de interfaz. Esto posibilita la herencia mltiple en el
diseo de los programas Java.
Una interfaz puede heredar de ms de una interfaz antecesora.
interface InterfazMultiple extends Interfaz1,Interfaz2{ }
Una clase no puede tener ms que una clase antecesora, pero puede implementar
ms de una interfaz:
class MiClase extends SuPadre implements Interfaz1,Interfaz2{ }
El ejemplo tpico de herencia mltiple es el que se presenta con la herencia en
diamante:

Imagen 3
Para poder llevar a cabo un esquema como el anterior en Java es necesario que las
clases A, B y C de la figura sean interfaces, y que la clase D sea una clase (que
recibe la herencia mltiple):
interface A { }
interface B extends A { }
interface C extends A { }
class D implements B, C { }
Colisiones en la herencia mltiple

10

En una herencia mltiple, los identificadores de algunos mtodos o atributos pueden
coincidir en la clase que hereda, si dos de las interfaces padres tienen algn mtodo
o atributo que coincida en nombre. A esto se le llama colisin.
Esto se dar cuando las clases padre (en el ejemplo anterior B y C) tienen un atributo
o mtodo que se llame igual. Java resuelve el problema estableciendo una serie de
reglas.
Para la colisin de nombres de atributos, se obliga a especificar a qu interfaz base
pertenecen al utilizarlos.
Para la colisin de nombres en mtodos:
Si tienen el mismo nombre y diferentes parmetros: se produce sobrecarga de
mtodos permitiendo que existan varias maneras de llamar al mismo.
Si slo cambia el valor devuelto: se da un error de compilacin, indicando que
no se pueden implementar los dos.
Si coinciden en su declaracin: se elimina uno de los dos, con lo que slo
queda uno.
Implementacin de herencia mltiple
Mediante el uso de interfaces, en algunos casos, se pueden simular relaciones de
herencia mltiple en Java. Una interfaz impone un protocolo de mtodos a
implementar
Una interfaz introduce un nuevo tipo
Las clases que implementan la interfaz son compatibles con este tipo
Las interfaces posibilitan la herencia mltiple en cuanto a jerarqua de tipos:
Una interfaz define un tipo una clase puede tener mltiples supertipos
Sin embargo una interfaz no tiene contenido que heredar:
los mtodos no tienen cdigo
las variables se heredan pero son inamovibles (son estticas y constantes)
Una interfaz no proporciona funcionalidad a un objeto, sino la posibilidad de ser
objeto de la funcionalidad de otros objetos Una interfaz puede derivar de varias otras
interfaces con extends
Las interfaces tambin pertenecen a un package
Las interfaces pueden ser public o del package

11

Los mtodos implementados deben ser public en las clases que implementan las
interfaces
Al implementar una interfaz, la clase pierde las definiciones de los mtodos que
coincidan con mtodos definidos en sus superclases
Hacer un cast de un objeto a cualquier interfaz es siempre sintcticamente legal
(aunque puede haber error en ejecucin)
Un interfaz se utiliza definiendo una clase que implemente el interfaz a travs de su
nombre. Cuando una clase implementa un interfaz, debe proporcionar la definicin
completa de todos los mtodos declarados en el interfaz y, tambin, la de todos los
mtodos declarados en todos los superinterfaces de ese interfaz.
Una clase puede implementar ms de un interfaz, incluyendo varios nombres de
interfaces separados por comas. En este caso, la clase debe proporcionar la
definicin completa de todos los mtodos declarados en todos los interfaces de la
lista y de todos los superinterfaces de esos interfaces.
Ejemplo:
class ClaseA implements Constantes,MiInterfaz {
double dDato;
// Define las versiones de put () y get () que utiliza la Clase A
public void put (int dato) {
// Se usa "pi" del interfaz Constantes
dDato = (double) dato * pi;
System.out.println (
"En put () de Clase A, usando pi del interfaz " +
"Constantes: + dDato);
}
public int get () {
return ((int)dDato);
}
// Se define un metodo show () para la Clase A que no esta
// declarado en el interfaz MiInterfaz
void show () {
System.out.println (
"En show () de Clase A, dDato = " + dDato);
}
}
Como se puede observar, esta clase proporciona la definicin completa de los
mtodos put () y get () del interfaz MiInterfaz, a la vez que utiliza las constantes
definidas en el interfaz Constantes. Adems, la clase proporciona la definicin del

12

mtodo show () que no est declarado en ninguno de los interfaces, sino que es
propio de la clase.
La definicin de un interfaz es una definicin de un nuevo tipo de datos. Se puede
utilizar el nombre del interfaz en cualquier lugar en que se pueda utilizar un nombre
de tipo de dato. Sin embargo, no se pueden instanciar objetos del tipo interfaz,
porque un interfaz no tiene constructor. En esta seccin, hay numerosos ejemplos de
uso del nombre de un interfaz como tipo.
Un interfaz no es solamente una forma ms pura de denominar a una clase
abstracta, su propsito es mucho ms amplio que eso. Como un interfaz no tiene
ninguna implementacin, es decir, no hay ningn tipo de almacenamiento asociado al
interfaz, no hay nada que impida la combinacin de varios interfaces. Esto tiene
mucho valor porque hay veces en que es necesario que un objeto X sea a y b y c. En
C++ es donde esto se acu como herencia multiple y no es sencillo de hacer
porque cada clase puede tener su propia implementacin. En Java, se puede hacer
lo mismo, pero solamente una de las clases puede tener implementacin, con lo cual
los problemas que se presentan en C++ no suceden con Java cuando se combinan
mltiples interfaces.
En una clase derivada, el programador no est forzado a tener una clase base sea
esta abstracta o concreta, es decir, una sin mtodos abstractos. Si se hereda desde
una clase no interfaz, solamente se puede heredar de una. El resto de los elementos
base deben ser interfaces. Todos los nombres de interfaces se colocan despus de
la palabra clave implements y separados por comas. Se pueden tener tantos
interfaces como se quiera y cada uno de ellos ser un tipo independiente.
Reutilizacin de la definicin de paquetes / libreras.
Un paquete o package de Java es un conjunto de clases e interfaces relacionadas
entre s. Por un lado, las clases e interfaces que forman parte de la plataforma Java
se estructuran en varios paquetes organizados por funciones o tareas. Por ejemplo,
las clases fundamentales estn en java.lang, las clases para operaciones de entrada
y salida de datos estn en java.io, etctera.

Aprender a utilizar y familiarizarse con las clases y mtodos implementados en estos
paquetes
Representa la mayor parte del aprendizaje del lenguaje de programacin Java.
ontenido
java.lang: Contiene las clases e interfaces ms empleadas en la mayora de los
programas de Java. Es importado automticamente por todos los programa Java: no
se necesita sentencia import para utilizar lo declarado en este paquete.

java.io: Contiene clases que permiten las operaciones de entrada y salida de datos
de un
programa.

13


java.util: Contiene clases e interfaces de utilidades: operaciones con la fecha y la
hora,
generacin de nmeros aleatorios...

java.applet: Contiene todas las clases e interfaces necesarias para la construccin
de applets de Java

java.net: Contiene clases que permite a un programa comunicarse a traves de redes
(Internet o intranet)

java.text: Contiene clases e interfaces que permiten operaciones de nmeros,
fechas, caracteres y cadenas.

java.awt: Es el paquete Abstract Windowing Toolkit. Contiene muchas clases e
interfaces
necesarias para trabajar con la interfaz de usuario grfica clsica.

java.beans: Contiene clases para facilitar a los programadores la generacin de
componentes de software reutilizables. Por otro lado, cualquier programador puede
introducir sus clases e interfaces en paquetes para facilitar tanto su uso en el
desarrollo de un programa como su reutilizacin en varios de ellos. Para incluir una
clase en un paquete debe incluirse la siguiente sentencia al principio del archivo
fuente que contiene la clase:

package identificadordelPaquete;

Por ejemplo, para incluir la clase Rectangulo dentro del paquete geometria:

package geometria;
public class Rectangulo extends FiguraGeometrica {
// Declaracion de atributos y metodos
. . .
}
El alcance de la sentencia package es todo el archivo fuente. Si se incluyen varias
clases dentro de un nico archivo fuente, slo puede declararse como pblica una
clase y debe tener el mismo nombre que el archivo fuente. Slo las componentes
pblicas de esa clase son accesibles desde fuera del paquete.

Si no se emplea una sentencia package, las clases o interfaces pertenecen al
paquete por defecto (sin identificador). Normalmente, este paquete por defecto slo
se emplea en aplicaciones pequeas o temporales o al inicio de un desarrollo. En
cualquier otro caso, las clases e interfaces deben pertenecer a paquetes con un
identificador explcito.

Las ventajas de agrupar clases e interfaces en un paquete son las siguientes:


14

a) Se puede determinar ms fcilmente qu clases e interfaces estn relacionadas

b) Se evitan conflictos por el empleo de los mismos identificadores en diferentes
clases si stas estn en paquetes distintos.

c) Puede configurarse un acceso especfico dentro de las clases de un mismo
paquete diferente al acceso desde otras clases fuera del paquete.
Es relativamente fcil que dos programadores de Java escojan el mismo identificador
para dos clases diferentes. El compilador permite que haya dos clases con el mismo
identificador si pertenecen a paquetes diferentes: el identificador de la clase debe ir
precedida del identificador del paquete (a este identificador compuesto se le
denomina identificador cualificado). En el ejemplo anterior: geometria.Rectangulo.
Eso s, existe una convencin para evitar que dos programadores diferentes empleen
el mismo identificador cualificado para sus paquetes:

Convencin: las empresas, compaas u organizaciones deben usar el nombre de
dominio de Internet inverso para identificar los nombres de los paquetes que han
desarrollado. Por ejemplo:

com.nombreEmpresa.nombrePaquete.
Clases genricas (Plantillas)
Las clases genricas encapsulan operaciones que no son especficas de un tipo de
datos concreto. El uso ms comn de las clases genricas se da con las colecciones,
como listas vinculadas, tablas hash, pilas, colas, rboles, etc., en las que las
operaciones tales como agregar y quitar elementos de la coleccin se realizan de
forma similar independientemente del tipo de datos que se almacena.
Normalmente, para crear clases genricas se empieza a partir de una clase concreta
existente y se cambian los tipos, uno a uno, por parmetros de tipo hasta que se
obtiene un equilibrio ptimo entre generalizacin y utilidad. Al crear sus propias
clases genricas, se deben tener en cuenta las siguientes consideraciones
importantes:
Tipos que se generalizan como parmetros de tipo.
Como regla general, cuantos ms tipos se puedan parametrizar, ms flexible y
reutilizable ser el cdigo. Sin embargo, un exceso de generalizacin puede producir
cdigo difcil de leer y comprender para otros programadores.
Una buena regla consiste en aplicar las restricciones mximas posibles que sigan
permitiendo controlar los tipos que es necesario controlar. Por ejemplo, si sabe que
la clase genrica est exclusivamente destinada al uso con tipos de referencia,

15

aplique una restriccin de clase. Esto evitar el uso imprevisto de la clase con tipos
de valor y permitir utilizar el operador as en T y comprobar si hay valores nulos.
Factorizar o no el comportamiento genrico en las clases base y las subclases.
Dado que las clases genricas pueden actuar como clases base, se aplican las
mismas consideraciones de diseo que con las clases no genricas. Vea ms
adelante las reglas para la herencia de clases base genrica.
Implementar o no una o varias interfaces genricas.





















16

CONCLUSIONES
La herencia es una propiedad esencial de la Programacin Orientada a Objetos que
consiste en la creacin de nuevas clases a partir de otras ya existentes. Este trmino
ha sido prestado de la Biologa donde afirmamos que un nio tiene la cara de su
padre, que ha heredado ciertas facetas fsicas o del comportamiento de sus
progenitores.
Al principio vimos que nuestro objetivo era conocer las caractersticas y ventajas de
utilizar la herencia y polimorfismos vamos a mostrar la conclusin y vimos que
nuestro objetivo si se cumpli. La herencia ofrece una ventaja importante, permite la
reutilizacin del cdigo. Una vez que una clase ha sido depurada y probada, el
cdigo fuente de dicha clase no necesita modificarse. Su funcionalidad se puede
cambiar derivando una nueva clase que herede la funcionalidad de la clase base y le
aada otros comportamientos. Reutilizando el cdigo existente, ya que solamente
tiene que verificar la nueva conducta que proporciona la clase derivada.
Vimos que la herencia a partir de la creacin de nuevas clases utilizamos una
palabra clave el cual nos ayuda hacer la herencia (Extends) con esta palabra
podemos hacer la herencia por ejemplos tenemos una clase que se llamara da y
creamos otro que se llama recibe, la clase recibe llevara a continuacin la palabra
extends el cual heredara todo lo que haga la clase da, por decirlo as la clase da es
el padre y la clase recibe el hijo,, la clase recibe recibir toda lo que haga la clase da
por decirlo asi heredara todo lo que el programador le asigne en valores este es un
ejemplo que yo pude dar para explicar lo que le entend a esta investigacin.






17

OTRAS FUENTES CONSULTADAS
Herencia. Internet. En lnea. Pagina consultada el da 1 de junio de 2014. Disponible
en: http://codejavu.blogspot.mx/2013/05/herencia-en-java.html
Herencia. Internet. En lnea. Pagina consultada el da 1 de junio de 2014. Disponible
en: http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/herencia/herencia.htm
Herencia y polimorfismo. Internet. En lnea. Pagina consultada el da 1 de junio de
2014. Disponible en: http://odelys2003.wordpress.com/category/programacion-
orientada-a-objetos/
Ejemplo. Polimorfismo. Internet. En lnea. Pagina consultada el da 1 de junio de
2014. Disponible en: http://codejavu.blogspot.mx/2013/05/polimorfismo-en-java.html
Polimorfismo. Internet. En lnea. Pagina consultada el da 1 de junio de 2014.
Disponible en: http://codejavu.blogspot.mx/2013/06/ejemplo-de-polimorfismo-en-
java.html
Reutilizacin de paquetes. Internet. Fuera de lnea. Pagina consultada el da 1 de
junio de 2014. Disponible en:http://ocw.upm.es/lenguajes-y-sistemas-
informaticos/programacion-en-java-i/Contenidos/LecturaObligatoria/19-packages-o-
paquetes.pdf