FACULTAD DE INGENIERIA

ESCUELA PROFESIONAL DE INGENIERIA DE SISTEMAS

CURSO: Programacin Visual I.

TEMA: Herencia de Clases en la Programacin Visual Java.

AUTOR:

Cabezas Huanio Rubn Kelvin.

Huaraz 2014

TEMA: Programacin Visual I.

FINALIDAD: Mostrar la importancia de crear clases y heredar, para

extender la funcionalidad de la clase padre,
adems para especializar el comportamiento
de la clase padre

HUARAZ 2014

DEDICATORIA

Le dedico primeramente mi trabajo a Dios, el

creador de todas las cosas, el que me ha dado
fortaleza para continuar cuando a punto de caer he
estado; por ello, le agradezco con toda la humildad
que de mi corazn puede emanar.

De igual forma, a mis Padres, a quien les debo toda

mi vida, les agradezco el cario y su comprensin, a
ustedes quienes han sabido formarme con buenos
sentimientos, hbitos y valores, lo cual me ha
ayudado a salir adelante buscando siempre el mejor
camino.

AGRADECIMIENTO

Los resultados de este proyecto, estn dedicados a todas aquellas personas que tiene como
profesin ingeniera de sistemas, de alguna forma, este proyecto les mostrar cmo aplicar
la herencia de clases en el desarrollo profesional para el curso de programacin visual I.

La imaginacin es ms importante
que el conocimiento. El conocimiento
es limitado, mientras que la
imaginacin no.

INDICE

CAPITULO I ............................................................................................................................... 1
1.

HERENCIA DE CLASES EN LA PROGRAMACIN VISUAL JAVA ......................................... 1

1.1.

Concepto de herencia: ............................................................................................ 1

1.2.

Extensin de una clase. ........................................................................................... 1

1.3.

Sobrescribir atributos. ............................................................................................ 2

1.4.

Sobrescribir mtodos. ............................................................................................. 2

1.5.

La palabra reservada super.................................................................................... 2

1.6.

El constructor por defecto y la clase Object. ........................................................ 3

1.7.

El operador instanceof. ........................................................................................... 3

1.8.

El modificador final. ............................................................................................... 4

1.9.

Mtodos static. ......................................................................................................... 4

CAPITULO II ........................................................................................................................... 6
2.

CLASES ABSTRACTAS ........................................................................................................ 6

2.1.

Interfaces: ................................................................................................................ 7

2.2.

Clases e interface anidados:.................................................................................... 7

CONCLUSIONES ....................................................................................................................... 8
REFERENCIAS BIBLIOGRAFICAS ...................................................................................... 9

RESUMEN

Sin duda alguna la programacin orientada a objeto, es una forma de programar

adecuadamente, la herencia de clases nos ayuda a reutilizar los objetos creados, sin la
necesidad de volverlos a crear, cuando se hace esta prctica, nos ahorramos lneas de
cdigo, sin embargo tiene una estructura y tipo de programacin, que junto con la
abstraccin,

encapsulacin

polimorfismo,

la

herencia

permite

compartir

automticamente mtodos y datos entre clases, subclases y objetos.

En este trabajo aprenderemos a crear algunas clases con ejemplos bsicos utilizando
clases, mtodos y algunas propiedades para poder heredarlas.

INTRODUCCION

En el siguiente trabajo veremos cmo se puede ampliar el conocimiento y

comportamiento de una clase a travs de la herencia. Veremos tambin el concepto, muy
importante, de la vinculacin dinmica para encontrar que mtodo se ha de invocar al
utilizar referencias a clases.
Para lo cual nos daremos cuenta que muchas veces los objetos en este caso seran las
clases, comparten campos y mtodos que hacen aproximadamente lo mismo (por ejemplo
almacenar y devolver un nombre del mbito humano con el que se designa al objeto,
como el ttulo de un lbum de msica, el ttulo de un libro, el ttulo de una pelcula, etc.)
En el siguiente trabajo explicaremos en forma resumida el comportamiento de la herencia
de clases.

CAPITULO I
1. HERENCIA DE CLASES EN LA PROGRAMACIN VISUAL JAVA
1.1. Concepto de herencia: La herencia es un mecanismo que permite la
definicin de una clase a partir de la definicin de otra ya existente.
La herencia permite compartir automticamente mtodos y datos entre
clases, subclases y objetos.
Para poder crear una clase, necesitamos crear una clase base.
1.2. Extensin de una clase.
La capacidad para extender clases se llama herencia parque la nueva
clase herede todos los atributos y mtodos a la que extiende. Dicho de
otro modo, una clase hija no puede tener ms de una clase padre.
Caracterstica:
Una clase no puede tener ms de una clase padre.

Cuando se extiende una nueva clase se puede aadir nuevos atributos y

mtodos. Por ejemplo:

1.3. Sobrescribir atributos.

En algunas circunstancias, podemos vernos en la necesidad de definir
un atributo en una clase hija con el mismo nombre que en su clase
padre, como muestra el siguiente cdigo de ejemplo:

1.4. Sobrescribir mtodos.

Para introducir el modo de sobrescribir mtodos imaginemos que
hemos aadido al cdigo de la clase Distancia un nuevo mtodo que
nos permita incrementar la distancia actual:

1.5. La palabra reservada super.

La palabra reservada super permite a una subclase referenciar a su
superclase inmediata. Es utilizada en las siguientes situaciones:

Para llamar al constructor de la superclase desde el

constructor de la subclase.
En este caso super () debe ser la primera sentencia
ejecutada dentro del constructor.

Para acceder a un miembro de la superclase que ha sido

ocultado por un miembro de la subclase.

1.6. El constructor por defecto y la clase Object.

En el cdigo de los ejemplos de prueba, nunca hemos utilizado el
constructor sin parmetros de las clases Distancia ni de la clase
Distancia Doble Precisin, luego, podemos intentar eliminar estos dos
constructores e iniciar el atributo distancia de ambas clases en el
momento de la definicin, tal y como se muestra en el siguiente
listado:

1.7. El operador instanceof.

Ya sabemos que cuando llamamos a los mtodos de un objeto a travs
de una referencia, es el tipo del objeto (la clase a la que pertenece) el
que determina que mtodo se ha de llamar. A este mecanismo lo hemos
llamado Vinculacin dinmica. No importa el tipo de la referencia a
la que asignemos el objeto siempre que, evidentemente, el tipo de la
referencia sea compatible con el tipo del objeto , en tiempo de
ejecucin el mecanismo de vinculacin dinmica determinar la cual es
el mtodo que se ha de llamar si es que ese mtodo esta sobrescrito.
Estos son algunos casos de uso:

1.8. El modificador final.

El operador final tambin se puede aplicar a los mtodos de una clase,
de tal modo que si un mtodo se declara como final estamos indicando
que ese mtodo no puede ser sobrescrito por ninguna clase hija. Con
ello estamos garantizando que el trabajo que realiza el mtodo es
siempre el mismo con independencia de si el objeto sobre el que se
llama es instancia de la clase padre o instancia de alguna de sus clases
hijas. Por Ejemplo:

1.9. Mtodos static.

Suelen emplearse para realizar operaciones comunes a todos los
objetos de la clase. No afectan a los estados de los mismos (a los
valores de sus variables de instancia). Por ejemplo, si se necesita un
mtodo para contabilizar el nmero de objetos creados de una clase,
tiene sentido que sea esttico ya que su funcin (aumentar el valor de
una variable entera) se realizara independientemente del objeto
empleado para invocarle.

CAPITULO II
2. CLASES ABSTRACTAS
Hasta este momento, siempre que hemos definido los mtodos de las
clases que hemos creado, siempre hemos escrito cdigo en la
definicin de los mtodos. A veces es til simplemente declarar
mtodos un una clase padre, sin dar ninguna implementacin para
ellos, y delegar la implementacin a las clases hijas que la extiendan.
Esta es una tcnica muy potente que utiliza el concepto de
Polimorfismo de la POO. De este modo estamos garantizando que
todas las clases hijas de la misma clase padre tiene un mtodo con la
misma signatura, aunque, obviamente, cada una de la clase hijas puede
tener una implementacin distinta para el mtodo polimrfico.

2.1. Interfaces: La implementacin concreta es el modo en que cada una de

las clases hija se dibuja. El uso de esta buena prctica en el Listado 3.5 es
que las referencias deben ser siempre del tipo ms general posible (clase
abstracta o interface como veremos en la siguiente seccin), y no de una
clase concreta. Rescribamos el cdigo del _ultimo listado haciendo caso
omiso de esta buena prctica:

2.2. Clases e interface anidados:

No obstante, en un mismo fichero podemos definir ms de una clase
siempre que solo una de ellas sea public y su nombre coincida con el del
fichero. El mbito o visibilidad del resto de clases debe ser el paquete
(recuerda, visibilidad por defecto). Aunque lo aconsejable es que, con
independencia del _mbito, cada clase este de finida en un _chero distinto,
ya que esto favorece el mantenimiento del cdigo.

CONCLUSIONES
Las dos tcnicas fundamentales para construir nuevas clases a partir de otras
ya existentes son la herencia. En el diseo y programacin orientada a objeto
se debe decidir cul de estos dos tipos usar en las relaciones entre las clases
que modelas las entidades del mundo real. Se debe comprender que ambos
tipos de relaciones pueden existir al mismo tiempo en u n problema en donde
hay varias clases y diversos tipos de relaciones.
La composicin de clases expresa el hecho de que se pueden componer o
constituir clases nuevas a partir de objetos de otras clases. Lo mismo que en
el mundo real, en donde observamos objetos formados por otros objetos:
computadores formados por teclado, pantalla y unidad central de proceso;
rectas formadas por puntos, vehculos formados por motor, transmisin y
chasis, etc.
La herencia de clases es un concepto diferente al de la composicin. La
herencia permite construir una clase derivada a partir de una clase base. La
clase derivada hereda todas las propiedades de la clase base, es decir, sus
variables (datos), y sus funciones y operadores miembro. Todas las nuevas
caractersticas que se quiere dar a la clase derivada se le confieren por medio
de nuevas variables, y de nuevas funciones y operadores .

REFERENCIAS BIBLIOGRAFICAS

Luis Guerra Velasco (2010), Programacin en Java, Programacin Orientada a Objetos.

(El Caso del rea Metropolitana de Guadalajara).
Gonzalo Mndez Pozo (2008), Programacin Orienta a Objetos en Java Herencia y
Polimorfismo, Universidad Complutense de Madrid.
Begoa Moros Valle (2009-2010), Programacin Orientada a Objetos Herencia en Java,
Departamento de Informtica y Sistemas.
Brian Goetz Tim Peierls Joshua Bloch Joseph Bowbeer David Holmes Doug Lea. Java
Concurrency in Practice. AddisonWesley Professional, 2006.
Elena Hernndez Pereira, Oscar Fontenia Romero, Antonio Faria (2008), Introduccin
a la programacin con Java, Departamento de Computacin, Facultad de informtica
Universidad de la Corua.
WU, Thomas (2001), Introduccin a la Programacin Orientada a objetos con Java,
Editorial McGraw Hill.
Wang, Paul (2000), Java con Programacin orientada a Objetos y aplicaciones en la www,
International Thomson Editores S.A.

Lemay, Laura, Cadenhead, Rogers (1999.), Aprendiendo Java 2 en 21 das, Editorial

Prentice Hall.

Deitel, H.M. (1999), Como Programar en Java, Editorial Prentice Hall, X

Bobadilla Jess (2003), Comunicaciones y Bases de Datos con Java, Editorial Alfa
omega,