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