UNIVERSIDAD DE PANAMÁ

CENTRO REGIONAL UNIVERSITARIO DE VERAGUAS

FACULTAD DE INFORMÁTICA, ELECTRÓNICA Y COMUNICACIÓN
ESCUELA INGENIERÍA EN INFORMÁTICA
LICENCIATURA PARA LA GESTIÓN EDUCATIVA Y EMPRESARIAL

TRABAJO INDIVIDUAL

JERARQUÍA Y HERENCIA

(PROGRAMACIÓN IV)

ESTUDIANTE

Reyes, Isis 2-160-330

PROFESOR

Diego Santimateo

II AÑO

II SEMESTRE

- 2006 -

1
 ÍNDICE

Págs.
INTRODUCCIÓN 2
A- OBJETIVOS 3
- Objetivo general 3
- Objetivos Específicos 3
I- FUENTES DE INFORMACIÓN COMENTADAS. 4
II-GLOSARIO DE TÉRMINOS 9
III- EJEMPLIFICACIÓN DE CONCEPTOS 12
- superclase 12
- herencia/jerarquía 12
- clase abstracta 16
- polimorfismo 18
- sobrecarga de métodos 21
IV- PRESENTACIÓN DE UNA APLICACIÓN EJECUTABLE 23
- Descripción de dominio 23
- Código fuente 23
V- DIAGRAMAS (propuestas del programa) 31
- Diagrama de dominio 31
- Diagrama UML de clases y herencias 32

2
 INTRODUCCIÓN

Este capítulo presenta un repaso de lo que es la programación orientada a

objetos, incluyendo glosario de definiciones básica de conceptos

involucrados al POO "¿Qué es un herencia?", y conceptos como: clase

abstracta, super clase jerarquía y sobrecarga con cada uno con sus

respectivos ejemplos detallados, y la importancia del polimorfismo en el

lenguaje Java.

El mismo se obtendrá un repaso de los aspectos de la creación de objetos

como los constructores, en los que residen los objetos, dónde ponerlos una

vez creados. Se presentarán otros aspectos, incluyendo el manejo de los

modificadores como algunas referencias como this y súper que son

importantes conocer su funcionalidad. Se aprenderá qué convierte a Java en

especial, por qué ha tenido tanto éxito, también se vera una aplicación de

donde se hace uso de los conceptos analizados en este trabajo, la cual da

una posible solución de un problema científico o de la realidad nacional o

institucional. Como la propuesta de diagrama UML de dicha aplicación.

Espero que este trabajo colabore a reforzar algunos aspectos para el

correcto análisis o diseño de un programa en Java.

3
A-OBJETIVOS

Objetivo General

- Analizar los conceptos involucrados con la Jerarquía en Java.

- Objetivos Específicos
- Analizar conceptos involucrados en la jerarquía en Java.

- Presentar y comentar fuentes de información relativas a la

programación Java.

- Realizar e interpretar un glosario detallado de términos relacionados a

las jerarquías en Java.

- Ejemplificar cada conceptos a través de ejemplos bajo un dominio

conocido.

- Presentar una aplicación donde se hace uso de los conceptos

investigados, para la solución de un problema científico o de la
realidad nacional.

- Presentar propuesta de la aplicación apoyada en un diagrama UML.

4
I- FUNTES DE INFORMACIÓN COMENTADAS.

Presentamos una serie de fuentes de información consultadas que

brindan información sobre los conceptos analizados sobre Jerarquías en
Java, y podrá observar un breve comentario con respecto a cada una de
ellas y su respectivo contenido.
1- De Jalón Garcia,Javier;R.Ignacio;M. Inigo. Fecha desconocida.
Aprenda java como si tuviera en primero. [Tutorial en línea].
Disponible en Internet en:
<http://cursosgratis.emagister.com/frame.cfm?id_user=&id_ce
ntro=57953030052957564866666952674548&id_curso=65423
040050153696570496756544557&url_frame=http://www.emag
ister.com/public/pdf/comunidad_emagister/0164301005145068
5267675450524552-APUNTES.pdf >[con acceso el 3-11-2006].
Esta página me explica que el manejo de la estructura java es algo compleja
, ya que explica todo lo relacionado a la estructura y programación java,
como lo es el poliformismo y la herencia como mecanismos indispensables
en el manejo de lenguaje de Java.

2- M.C. Bernabé Ortiz y Herbert. 20 de Junio del 2001. Paradigma de

la orientación a objetos. [Web en línea]. Disponible en Internet en:
<http://www.itlp.edu.mx/posgrado/lengprog/java.html> [con
acceso el 3-11-2006].
Se conoce un poco más de cómo se establece la herencia en Java desde su
concepto, como las clases que son fundamentales, las cuales he
comprendido que una clase se deriva de otra, y hereda todas sus variables y
métodos java permite múltiples niveles de herencia. Y que dentro de cada
clase puede existir a la redefinición de métodos o sobrecarga de clases y
métodos abstractos, la cual su utilidad es permitir que otras clases deriven
de ella.

5
 3- Google.com [Tutorial en línea]. Disponible desde Internet en:
<http://www.mundotutoriales.com/tutorial_tutorial_de_java-
mdtutorial311974.htm> [Con acceso el 3-11 2006].

Aprendí algunos conceptos más detallados de herencia, y muestra un

ejemplo de su aplicación o sintaxis como el acceso a variables de instancias
de una clase, a través de palabras reservadas como this y super, las
cuales hacen referencia a los miembros de la propia clase. También
muestra el manejo de clases abstractas, la cual son muy útil en cualquier
lenguaje orientado a objetos. Y que antes no conocí que existían en java
este tipo de referencias, las cuales son fundamentales para los llamados de
las superclases.

4- Google.com.2001-2005. Fecha de actualización desconocida.

Página de colaboración www.Javahispano.org [tutorial en
línea]. Disponible en la Internet en:
<http://www.javahispano.org/cursotext.viewer.action?file=bas
ico >[con acceso 3-11-2006].

Este es un tutorial completo en formato pdf que explican detalladamente

las herencias, el poliformismo java, el mismo es bastante completo y
sencillo de interpretar, la cual explica que la herencias se basa en la
existencia de generalización entre clases, muestra un ejemplo claro del
manejo de las mismas, también contamos otros de los paradigmas de la
programación orientada a objetos como es el poliformismo, el mismo
consiste en que una vez que se ha definido una superclase para un grupo de
subclases, cualquiera instancias de esas subclases puede ser usada en el
lugar de la superclase, este paradigma es muy utilizado para permitir
múltiples mensajes enviados a diferentes objetos.

6
 5- Google.com.2006. Herencia y Programación orientada a
Objetos [web en línea]. Disponible desde Internet en: <
http://es.wikipedia.org/wiki/Herencia_(programaci%C3%B3n_or
ientada_a_objetos) > [con acceso el 6 de noviembre de 2006].

Observe el ejemplo de herencia y polimorfismo, la cual muestra que para

realizar una clase polimórfica es necesario que haya herencia en nuestras
clases. La herencia permite que existan clases que nunca sean instanciadas
directamente.

6- Mateu, Luis. Apuntes de java. 7 de Noviembre de 1996 [web

en línea]. Diponible desde en Internet en:
<http://www.dcc.uchile.cl/~lmateu/Java/Apuntes/index.htm >
[con acceso el 6 de noviembre 2006].

En el lenguaje Java posee ciertas características que hoy día se consideran

estándares en los lenguajes OO, como son clases, encapsulamiento,
métodos y subclases, y otros. Se dice, quePara programar orientado a
objetos es necesario primero diseñar un conjunto de clases. La claridad,
eficiencia del programa resultante dependerá principalmente de la calidad
del diseño de clases. Un buen diseño de clases significará una gran
economía en tiempo de desarrollo y mantención.

7- Puchol, Antonio. 17-Junio-2001. Apuntes Lenguaje

Java.(Herencia).[web en línea]. Disponible desde en Internet
en:
<http://www.arrakis.es/~abelp/ApuntesJava/Herencia.htm
>

Aprendí en cuanto a la herencia y complejidad con respecto a las variables

de instancias de otras clases. Es decir una clase es como otra y además
tiene algún tipo de característica propia que la distingue. Además hace
énfasis a redefinición de métodos, de la clase base pero haciendo que
métodos con el mismo nombre y características se comporten de forma
distinta.

7
 8- Puchol, Antonio. 17-Junio-2001. Apuntes Lenguaje Java.(Clase
Abstracta).[web en línea]. Disponible desde en Internet
en:http://www.arrakis.es/~abelp/ApuntesJava/ClasesAbstractas.htm>

Clase abstracta en java, como la declaración e implementación de los

métodos abstractos de la clase abstracta. La clase derivada se declara e
implementa de forma normal, como cualquier otra. Sin embargo una clase
abstracta no se puede instanciar, es decir, no se pueden crear objetos de
una clase abstracta. El compilador producirá un error si se intenta.

9- Panadero, F. Carmen y otros .11-7-2006. Practica 13-Herencia

en java. Universidad Carlos III de Madrid [web en línea].
Disponible desde Internet en: <
http://www.it.uc3m.es/tsirda/practicas/P13/enunciado.html#ej
2 > [con acceso el 6-12-2006].

Puede observar 4 ejercicios relacionados a la herencias de clases. Donde la

clase principal es la clase figura, la de ella se heredan otras clases como
circulo, triangulo y otros. Los ejercicios son bastantes concretos y sencillos
para elaborar clases con herencias.

10- Google.com. Julio 18,2004-.Clase Abstracta en Java [Web en

línea]. Disponible desde en Internet en:
<http://www.error500.net/garbagecollector/archives/categoria
s/java/las_clases_abstractas_en_java.php > [con acceso el 6-
11-2006].

Encontre una definición completa de que es una clase abstracta y los

métodos que esta clase trabaja. La misma señala que estos métodos serán
declarados a su vez abstractos. Si una clase tiene un método abstract es
obligatorio que la clase sea abstract.

8
Nota: Es importante visitar estas webgrafías que he detallado, ya que cada
una brinda referencias completas en cuanto a los conceptos relacionados al
lenguaje Java, que al momento de programar cada uno de estos, nos
ayudan a diseñar nuestros trabajos.

No cabe duda que el conocimiento, en cuanto a un tema están ahí, y es de

nosotros buscar ese conocimiento, no basta con lo que algunos autores
opinan, sino hacer nuestros propios análisis y tomar ideas para hacer un
trabajo eficiente y eficaz acorde a nuestros objetivos.

9
II- GLOSARIO DE TÉRMINOS

Este es un glosario de términos que nos ayudarán a comprender mejor

algunos conceptos relacionados a la programación orientado a objetos , y
que son información relevante a la hora de programar.

1.- Java: Java es un lenguaje originalmente desarrollado por un grupo de

ingenieros de Sun, utilizado por Netscape, posteriormente como base para
Javascript. Si bien su uso se destaca en el Web, sirve para crear todo tipo de
aplicaciones (locales, intranet o internet).

2.- Objeto: Un objeto, desde nuestro punto de vista, puede verse como una
pieza de software que cumple con ciertas características: encapsulamiento,
herencia.

3.- herencia: simplemente significa que se pueden crear nuevas clases que
hereden de otras preexistentes; esto simplifica la programación, porque las
clases hijas incorporan automáticamente los métodos de las madres.Todas
las clases de Java creadas por el programador tienen una super-clase.
Cuando no se indica explícitamente una super-clase con la palabra
extends. En otras palabras una herencia es un mecanismo que denota que
una clase se deriva de otra, como un hijo hereda lo de su padre. Ver
ejemplo

4.- Encapsulamiento: significa que el objeto es auto-contenido, o sea que

la misma definición del objeto incluye tanto los datos que éste usa
(atributos) como los procedimientos (métodos) que actúan sobre los
mismos.

5. Clase abstracta: Una clase abstracta (abstract) es una clase de la

que no se pueden crear objetos. Su utilidad es permitir que otras clases

10
deriven de ella, proporcionándoles un marco o modelo que deben seguir y
algunos métodos de utilidad general. Las clases abstractas se declaran
anteponiéndoles la palabra
abstract, como por ejemplo, public abstract class Geometria { ... }

6. Interfaces: es un conjunto de declaraciones de métodos (sin

definición). También puede definir constantes.

7. Método abstracto: es un método declarado en una clase para el cual

esa clase no proporciona la implementación (el código).

8. Polimorfismo: El polimorfismo en java consiste en declarar y definir

varios métodos con el mismo nombre, pero con diferente numero y/o tipo de
argumentos y que realizan diferentes operaciones. Sin embargo, el tipo que
devuelven los métodos debe coincidir.

9. Subclase: es una clase que desciende de otra clase. Esta hereda el

estado y el comportamiento de todos sus ancestros.

10. Superclase: es la clase padre, o sea, se refiere a la clase que es el

ancestro más directos, así como a todas las clases ascendentes.

11. Jerarquía: es la herencia o el mecanismo fundamental de relación en la

orientación a objetos. Relaciona las clases de manera jerárquica; una clase
padre o superclase sobre otras hijas o subclases.

12.- Clase Object: es la clase superclase de todas las clases de Java. Todas
las clases se derivan de ella, directa o indirectamente de ellas.

11
13.- Sobrescritura en Java: en una jerarquía de herencia puede interesas
volver escribir el cuerpo de un método, para realizar una funcionalidad de
diferente manera dependiendo del nivel de abstracción en que se encuentra
a esta modificación se le llama sobrescritura de un método.

14.- Sobrecarga de java: es crear más de un método con el mismo

nombre, pero con listas de parámetros distintas. Y se utiliza en java para
determinar un comportamiento polimórfico.
15. This: es una referencia de ámbito, hace continua referencia a la clase
en la que se invoque, también vale para sustituir a sus constructores,
utilizándola como método.

16.- Super: es referencia que se usa para acceder a métodos o atributos de

la superclase.

17.- Mensaje: son simples llamadas a funciones o métodos del objeto con
el que se quiere comunicar para decirle que haga cualquier cosa.

12
III- EJEMPLIFICACIÓN DE CONCEPTOS

Aquí muestro ejemplos de la aplicación de concepto a través de un solo

dominio, de manera que puedan visualizar las diferencias en cada uno y
llegar a la mejor comprensión y visualización de los mismos.

o Super Clase:
Una superclase es aquélla clase padre de las cuales una clase hija hereda
todos sus atributos y métodos que en el padre se encuentre.
Un ejemplo de superclase es:
Supongamos que tengamos una clase llamada Transporte de las cuales
se define asi: class Transporte{
Public float velocidad();
Public String marca();
Estos son métodos de la clase padre, y queremos que una clase hija
herede todo de la clase padre, sería así: ejemplo:
Class bicicleta extends Transporte{ // esta clase hija hereda tanto los
atributos y los metodos de la clase padre y para distinguir una clase
padre de una hija es la palabra clave extends, y todas las clases padres
heredan de la class object que se encuentra en la librería java.lang de
Java.
Más adelante podremos observar a través de las explicaciones de este
trabajo.

o Herencia como se ha definido antes, la herencia en java, es lo que

hereda una clase hija de una clase mayor (padre), Y es un mecanismo
por el que se crean nuevos objetos definidos en términos de objetos
ya existentes, aquí observará un ejemplo de herencia aplicado al
dominio Gasolinera, en la que las clase superior es la clase Petroleo1
y las clases que heredan de ella son: gasolina1 y diesel.

13
- jerarquías:

<<superclase
Petroleo1>>

<<subclase <<subclase Diesel>>

Gasolina1>>

- Codigo ejemplo:
import javax.swing.*;
// programa principal
public class Combustibles{
public static void main(String args[]){
float P_venta=3; // variables de la clase
float P_compra=2;
int cant=4;
String nombre;
nombre=JOptionPane.showInputDialog("Nombre de derivado gasolina-diesel");
if (nombre.equals("gasolina"))
{
Gasolina1 deri = new Gasolina1(P_venta,P_compra,cant,nombre);
deri.imprimirInforma();
}
else
{
if (nombre.equals("diesel"))
{
Diesel deri1=new Diesel(P_venta,P_compra,cant,nombre);
deri1.imprimirInforma();
}
}
}// fin main

14
}// fin clase
// superclase
class Petroleo1 { // Hereda de Object
Esta es la superclase llamada
/ /Atributos de la superclase
Petroleo1 de la cual de ella se
private float Precio_venta; derivan otras clases como la
private float Precio_compra; clase Gasolina1 y Diesel.
private int cantidad;
private String Nom_derivado;
// método constructor
public Petroleo1( float Precio_venta, float Precio_compra, int cantidad, String Nom_derivado)
{ // constructor de la clase
this.Precio_venta=Precio_venta;
La referencia this se utiliza
this.Precio_compra=Precio_compra; sólo dentro de un método-
this.cantidad=cantidad; produce la referencia a la
this.Nom_derivado=Nom_derivado; clase que se invoque.

}
// Métodos de la superclase
public float getPrecioVenta() // obtiene el precio de precio de venta del derivado
{
return Precio_venta;
}
private float getCompra() // obtiene el precio de compra del derivado
{
return Precio_compra;
}
public int getCantidad( )// obtiene la cantidad de galones del derivado
{
return cantidad;
}
public String getNombre() // nombre del derivado que se hace referencia.
{
return Nom_derivado;
}

public void imprimirInforma()

{
System.out.println("Precio"+" "+Precio_venta+" "+"cantidad"+" "+cantidad+"
"+Nom_derivado);

15
 }
} Los subclases heredan
***// subclase Gasolina1 (hija) todas las variables y
class Gasolina1 extends Petroleo1 { métodos que sus
ascendientes hayan
public Gasolina1 (float Precio_venta,float Precio_compra, especificado como
int cantidad, String Nom_derivado )// constructor heredables, además
{
pueden crear sus
propios métodos. Para
super(2,Precio_compra,cantidad,"90 octano"); // indicar que una clase
} hereda de otra se utiliza
}
***// subclase Diesel (hija)
class Diesel extends Petroleo1{
public Diesel (float Precio_venta,float Precio_compra,int cantidad, String Nom_derivado)
{ // constructor
super(1,Precio_compra,5,Nom_derivado);
}
}

En toda subclase se crea un constructor de la subclase y si no se crea

el programa lo crea por si solo. La referencia super se utiliza para
acceder a métodos o atributos de la superclase Petroleo1 en este clase
accede a los atributos precio de compra, cantidad, y Nombre del
derivado, en la subclase Diesel se inicializa el atributo “90 octanos”,

16
 o Clase Abstracta: Una de las características más útil de cualquier
lenguaje orientado a objetos es la posibilidad de declarar clases que
definen como se utilizan solamente, sin tener que implementar
métodos. Es muy útil cuando la implementación es específica para
cada usuario, pero todos los usuarios tienen que usar los mismos
métodos. Un ejemplo de esta clase se explicará utilizando el mismo
dominio de la Gasolinera, para una mejor abstracción y diferencia
entre cada concepto a tratar en este trabajo.
- Código ejemplo:
//programa principal
import javax.swing.*;
public class Combustibles1{ public static void main(String args[]){
float P_venta=3;
float P_compra=2;
int cant=4;
String nombre;
nombre=JOptionPane.showInputDialog("Nombre de derivado: Gasolinas");
Petroleo deri = new Gasolina(); // creación de instancia de la subclase Gasolina
deri.getPrecioVenta(); // llamado de los métodos de la superclase
deri.getCantidad();
deri.getNombre();
deri.imprimirInforma();
}
} En clase base abstracta
// clase base o superclase abstracta Petróleo, no se puede crear
public abstract class Petroleo{ instancias de dicha clase
(new). Y de declaran con el
// Atributos de la clase abstracta modificador abstract
ffloat P_venta;
float P_compra;
int cant;
String Nom_derivado;
public Petroleo()

{
this.P_venta=P_venta;
this.P_compra=P_compra;

17
 this.cant=cant;
this. Nom_derivado=Nom_derivado;
}
// Métodos abstractos En clase base abstracta
Petróleo , los métodos se
abstract public float getPrecioVenta(); // método abstracto declaran abstractos y s
abstract public int getCantidad(); código que ejecutará se
public String getNombre() // método no abstracto encuentra en otro lado, pero
no obstante no todos los
{ métodos de una clase
Nom_derivado="91 octanos"; abstracta tienen que ser
return Nom_derivado; abstractos. Estas clases no
pueden tener métodos
} privados, ni estático. Los
public void imprimirInforma()// método no abstracto
{
System.out.println("Precio"+" "+P_venta+" "+"cantidad"+" "+cant+" "+Nom_derivado);
}
}
// subclase Gasolina
class Gasolina extends Petroleo {
En las subclases se
// se crea un constructor por defecto ejecutan los códigos de
public float getPrecioVenta() los métodos de la clase
{ abstracta inicializando el
P_venta=2; precio de venta actual del
producto y en el método
return P_venta;
de getCantidad que
} inicializa la cantidad en
public int getCantidad() galones del producto y se
{ adiciona otra método
imprimirInforma() que
cant=5;
return cant;
}
public void imprimirInforma()
{
System.out.println("Precio"+" "+P_venta+" "+"cantidad"+" "+cant+" "+Nom_derivado);
}
}

18
 o Polimorfismo:
El polimorfismo permite una organización de código y una legibilidad del
mismo mejorada, además de la creación de programas ampliables que
pueden "crecer", no sólo durante la creación original del proyecto sino
también cuando se deseen añadir nuevas características.

- ejemplo código
Recapitulando el mismo dominio de los ejemplos de los concepto
anteriores, aplicamos el polimorfismo en este siguiente ejemplo:
import javax.swing.*;
// ejemplo de polimorfismo
El poliformismo dinámico, la cual
class CombustiblesPoli{
se hace referencia en este
public static void main(String args[]){ ejemplo es uno de los
float P_venta=3; mecanismos más poderosos que
float P_compra=2; ofrece el diseño orientado a
int cant=4;
objetos para soportar la
String nombre;
nombre=JOptionPane.showInputDialog("Nombre de derivado gasolina-diesel");
if (nombre.equals("gasolina"))
{
PetroleoPoli d=new GasolinaPoli(P_venta,P_compra,cant,nombre); // se crea instancia de la clase
d.imprimirInforma(); // GasolinaPoli.
}
else
{
if (nombre.equals("diesel"))
{
PetroleoPoli d=new Diesel(P_venta,P_compra,cant,nombre); // se crea instancia de la clase
d.imprimirInforma(); // llamado del metodo de // Diesel

}
}
}

19
}
//
public class Petroleo1{ // superclase
//Atributos
public float Precio_venta;
public float Precio_compra;
public int cantidad;
public String Nom_derivado;

public Petroleo1()
{ // constructor
this.Precio_venta=Precio_venta;
Las tres clases implementadas a
this.Precio_compra=Precio_compra;
continuación tienen una relación
this.cantidad=cantidad; subclases/superclase simple ,
this.Nom_derivado=Nom_derivado; donde la clase hija GasolinaPoli
} hereda todos los atributos y
métodos de la superclase.
// Métodos
public float getPrecioVenta()
{
return Precio_venta;
}
private float getCompra()
{
return Precio_compra;
}
public int getCantidad()
{
return cantidad;
}
public String getNombre()
{
return Nom_derivado;
}
public void imprimirInforma()
{
System.out.println("Precio"+" "+Precio_venta+" "+"cantidad"+" "+cantidad+" "+Nom_derivado);
}

20
 }
class GasolinaPoli extends Petroleo1 {
public GasolinaPoli (float Precio_venta,float Precio_compra,int cantidad, String Nom_derivado)
{
super(2,Precio_compra,cantidad,"90 octano");
}
}
class Diesel extends Petroleo1{
public Diesel (float Precio_venta,float Precio_compra,int cantidad, String Nom_derivado)
{
Precio_venta=1;
cantidad=5;
}
public void imprimirInforma() // sobrescritura en la subclase
{
System.out.println("Precio"+" "+Precio_venta+" "+"cantidad"+" "+cantidad+" "+”Diesel”);
}
}
En este ejemplo podemos observar que se declara la variable de tipo Petroleo1, y después se
almacena una referencia a una instancia de la clase Diesei en ella, con los parámetros de las variables
de instancia. Al llamar al método imprimirInforma() de clase Petroleo1, el compilador de Java verifica
que clase Petroleo1 tiene un método llamado ImprimirInforma(), pero el interprete de Java observa que
la referencia es realmente una instancia de clase Diesel, por lo que llama al método ImprimirInforma()
de clase Diesel en vez de al de la clase Petroleo1.

21
o Sobrecarga de Métodos:

Como se detalla en el glosario de este trabajo, una sobrecarga es crear

métodos con el mismo nombre , pero con parámetros diferentes, la
misma con la función de tener metodo alternativo para una clase, la cual
dependerá del programador a la hora de diseñar un programa OO, y para
poder distinguir entre dos métodos llamar., no se consideran los nombre
de los parámetros formales sino sus tipos. Ver ejemplo:
- Ejemplo código:
import javax.swing.*; // ejemplo de sobrecarga
class SobrecargaMetodos{
public String Capturar (String mens)
{
Aquí en este ejemplo,
String dato; tenemos una clase con
dato=JOptionPane.showInputDialog(null,mens); dos métodos Imprime()
return (dato); uno recibe un string
(mens) y un int (valor).
}
Al llamar el método de
public void Imprime(int valor, String mens) esta manera
{ m.Imprime(String, int)
JOptionPane.showMessageDialog(null,mens+" "+valor); llamara sin problemas al
método que tiene 2
}
parámetros, pero al
public void Imprime(String mens )// metodo sobrecargado sobrecargar el método
{ para que reciba solo un
JOptionPane.showMessageDialog(null, mens); String (mens), y un
}
segundo método en la que
el llamado sería
// clase principal m.Imprime (String) y no
class Principal{ aquel metodo que tiene
public static void main (String args[]){ dos parámetros
Int edad;;
String nombre;;
SobrecargaMetodos m=new SobrecargaMetodos(); // se crea instancia de la clase
SobrecargaMetodos.
m1="Indique su nombre";
nom=m.Capturar(m1);
mensaje=("Nombre"); // metodo sobrecargado de 1 parametro
m.Imprime(nom,mensaje);

22
 m1="edad";
edad=m.Capturar(m1);
m.Imprime(edad,nombre);// metodo de 2 parametros
} // fin del main
} // fin clase

23
IV- PRESENTACIÓN DE UNA APLICACIÓN EJECUTABLE.
- Dominio: Banco
- Clase Base: Cuenta (clase abstracta)
- subclases: class CuentaAhorro y class CuentaCorriente
- Clases auxiliares: class Banco (main), class CapturaDespliega

- Descripción del dominio: el dominio de esta aplicación hace referencia de

la abstracción de un Banco, donde existe una clase Base abstracta llamada
Class abstract Cuenta, que cuenta con variables de instancias y métodos
tanto abstractos como no abstractos. Y dos clases hijas (subclases) que
hace referencia al tipo de que utilizara el usuario, estas son cuenta de
Ahorro o Cuenta Corriente, donde el mismo realizará un tipo de transacción
deposito o retiro. El programa es capaz de mostrar la actualización de saldo
de clientes, y una lista de los cuenta habientes que realizaron transacciones.

- Código fuente
Donde se pone en practica la herencia de clases, polimorfismo, utilización de
clases abstractas sobrecarga de métodos y redefinición de métodos.

Este un ejemplo sencillo que trata de solucionar una realidad dentro del dominio
de un Banco y las cuentas de clientes del mismo.
// clase principal
import java.lang.String.*;
import java.text.*;
import javax.swing.*;
class Banco{ // clase principal (main)
public static void main(String args[]){
// variables de la clase principal
String no,m1,n_cta,cu,mensaje,tipo_tran,des,m2,m3;
float saldo;
float candiner;

24
 int i;
Cuenta[] datoscuenta=new Cuenta[10]; // se crea un objeto de arreglo de cuenta
habientes
// se capturan los datos del cliente del banco
CapturaDespliega d=new CapturaDespliega();// se crea un objeto de la clase
CapturaDespliega
i=0;
do{
no=d.Capturar(mensaje="Escriba su nombre");
n_cta=d.Capturar(mensaje="Escriba el numero de cuenta");
saldo=Float.parseFloat(d.Capturar(mensaje="Escriba su saldo"));
m1=d.Capturar(mensaje="Tipo de cuenta 01-02");
tipo_tran=d.Capturar(mensaje="Indique transacción 1 retiro - 2 deposito");
candiner=Float.parseFloat(d.Capturar(mensaje="Introduzca la cantidad"));
if (m1.equals("01"))
{
Cuenta ca=new CuentaAhorro(no,n_cta,saldo);
datoscuenta[i]=ca; //arreglo de cuenta habientes
ca.verificarTrans(tipo_tran,candiner);
ca.toString(ca.TipoCuenta()+"\nNOMBRE:"+ca.getNom()+"\nNo.CUENTA:"+ca.getCue
n()+"\nSALDO"+ca.getSaldo());
// metodo que imprime los datos del cliente utilizando el metodo heredado
}
else
{
if (m1.equals("02")) // tipo de cuenta corriente
{
Cuenta c=new CuentaCorriente(no,n_cta,saldo);// se crea una objeto de la clase
hija CuentaCorriente
datoscuenta[i]=c; //arreglo de cuenta habientes
c.verificarTrans(tipo_tran,candiner); // método verifica el tipo de transacción

25
 des=c.toString(); // métodos sobrecargado de la clase padre
c.toString(des); // imprime datos del cliente de banco
}
}
mensaje=JOptionPane.showInputDialog("Desea 1 continuar 2 salir");
i++;
}
while (mensaje.equals("1")); // condición de para del ciclo
for (int m=0; m<i; m++) // ciclo que despliega un listado de los cuenta habientes del
banco
{
m2="\nLISTADO DE CUENTAHABIENTES\n"+"NOMBRE:"+"
"+datoscuenta[m].getNom();
m3="\nNo.CUENTA:"+" "+datoscuenta[m].getCuen()+"\nSALDO:"+"
"+datoscuenta[m].getSaldo();
d.Desplegar (m2+m3);
}
}// fin main
}// fin clase
// *****SUPERCLASE
import javax.swing.*;
abstract class Cuenta{ // superclase abstracta
public String nombreCliente; // variables de instancias de la clase
public String numeroCuenta;
public float saldo;
public Cuenta(String nombreCliente, String numeroCuenta, float saldo)
{ // constructor
this.nombreCliente=nombreCliente;// se utiliza la sentencias this
this.numeroCuenta=numeroCuenta; // llamado de atributos de la misma clase
this.saldo=saldo;
}

26
public abstract void sacarDinero(float cant); // metodos abstracto
public abstract String TipoCuenta();
public abstract void verificarTrans(String tipo,float cant);
// métodos no abstractos de la clase
public void ingresarDinero(float cant)
{
saldo+=cant;
}
public String toString() // método sin parametros que imprime datos de clientes
{
return("\nNOMBRE:"+" "+nombreCliente+" "+"\nNo.CUENTA:"+ " "+numeroCuenta+"
"+"\nSALDO:"+" "+saldo);
}
public void toString(String mensaje) // sobrecarga de metodos parametrizado
{
JOptionPane.showMessageDialog(null, mensaje);
}
public float getSaldo() // captura el saldo del cuenta habiente
{
return (saldo);
}
public String getNom() // captura el nombre de cuenta habiente
{
return (nombreCliente);
}
public String getCuen() // captura el numero de cuenta
{
return (numeroCuenta);
}
}// fin de la superclase
***************************************************************

27
// SUBCLASES HIJA
class CuentaAhorro extends Cuenta{ // subclase CuentaAhorro hereda de clase
Cuenta
public CuentaAhorro(String nombreCliente,String numeroCuenta,float saldo)
{// constructor
super(nombreCliente,numeroCuenta,saldo);// hace llamado al constructor padre
}

public void sacarDinero(float cant) // redifinicion de metodo de la clase abstracta padre

{
if (saldo>0)
{
saldo-=cant; // se realiza un retiro de dinero de la cuenta
super.getSaldo(); // se llama al metodo de la superclase para actualizar saldo
}
else
{
super.toString("\nAVISO\n"+"Su saldo esta en cero");// llamado al metodo de la
superclase
}
}
public String TipoCuenta()
{
return "CUENTA DE AHORRO"; // retorna el tipo de cuenta de cliente
}
public void verificarTrans(String tipo, float cant) // metodo que verifica el tipo de
transacción cliente
{
if (tipo.equals("2")) // verifica un deposito
super.ingresarDinero(cant); // se llama almetodo padre para actualizar el saldo del
cleinte

28
 else
{
if (tipo.equals("1")) // verifica si es un retiro
this.sacarDinero(cant); // se hace llamado al metodo de la misma clase
}
}
}//fin de subclase

// CLASE HIJA
class CuentaCorriente extends Cuenta{ // sublcase CuentaCorriente hereda de clase
Cuenta
public CuentaCorriente(String nombreCliente,String numeroCuenta,float saldo)
{// constructor de la clase
super(nombreCliente,numeroCuenta,saldo); // llamado del constructor de la
superclase
}

public void sacarDinero(float cant) // redifinición de método de la clase abstracta

Cuenta
{ // verifica el retiro en la cuenta
if ((saldo>15)&&(cant<saldo)) // verifica si el saldo se puede realizar
{
saldo-=cant; // se realiza un retiro
super.getSaldo(); // se actualiza el saldo con el llamado del metodo padre
}
else
{
super.toString("\nAVISO\n"+"Ha llegado al limite de retiro");// se envia mensaje de
aviso
}
}
public String TipoCuenta() // imprime el tipo de Cuenta del cliente

29
{
return "CUENTA CORRIENTE";
}
public void verificarTrans(String tipo, float cant) // verifica el tipo de transaccion a hacer
por el cliente
{
if (tipo.equals("1"))// retiro de dinero
this.sacarDinero(cant);// llamado al metodo de verificacion de retiro de la misma clase
else
{
if (tipo.equals("2")) // deposito en la cuenta del cliente
super.ingresarDinero(cant); // se hace llamado al metodo de clase padre, actualiza
}
}
}// fin de la subclase
***********************************************************
// CLASES AUXILIARES
import javax.swing.*;
class CapturaDespliega{ // clase que captura y despliega información
public String Capturar(String mensaje){ // captura datos (cadenas)
String datos;
datos=JOptionPane.showInputDialog(null, mensaje);
return datos;
}
public void Desplegar(String mensaje){ // despliega datos (cadenas)
System.out.println(mensaje);
JOptionPane.showMessageDialog(null, mensaje);
}
}// fin de la clase

30
La clase abstracta utilizada en este trabajo es con la finalidad de reutilizar
códigos que son utilizadas por otras clases que se derivan de ella, la cual
sirve para agrupar bajo un mismo tipo a otras clases.
Como pudieron observar en este programa se encuentran las características más
fundamentales de la programación Orientada a Objetos como:
- Herencia: superclases y clases hijas que derivan de ellas clase CuentaAhorro y
clase CuentaCorriente, estas heredan aquellos métodos que tiene la clase padre y
redefine aquellas que están abstractas en la superclase, como :
Abstract void sacarDinero(float cant);
Abstract String TipoCuenta();
Abstract void verificarTrans(String tipo, float cant)
La misma es abstracta con el objetivo de no crear objetos de la clase cuenta, ya
que se creerán objetos de las clases hijas y otros metodos que no son abstractas
que hereda de la superclase:
Void ingresarDinero(float cant)
String toString()
Void toString (string mensaje)
Float getSaldo()
String getNom()
String getCuen()
En el programa principal se solicita los datos del usuario como nombre,
numero de cuenta, y saldo, también se le colicita el código de tipo de
cuenta 01 ó 02 (ahorro o corriente) y la transacción a realizar deposito o
retiro, cada clase tiene sus métodos y atributos que son heredados de la
superclase y la implementación del código de los métodos de la clase
abstracta cuenta.
Se crean las instancias dependiendo de el tipo de cuenta : Cuenta c=new
CuentaCorriente(no,n_cta,saldo) y ca=new CuentaAhorro(no,n_cta,saldo);se
llama a los métodos de cada clase.
Toda los datos de cliente se almacena en un arreglo de objeto para después
desplegar un listado Cuenta[] datoscuenta=new Cuenta[10].

31
V- DIAGRAMAS
- DOMINIO DEL PROGRAMA: clases del programa.

Class Banco clase que hereda de Object

Clase Cuenta superclase

Clase CapturaDespliega

Clase CuentaAhorro Clase CuentaCorriente Clase auxiliar

Subclases heredan de la Superclase

3132
- DIAGRAMA UML DE LA APLICACIÓN
Este diagrama UML detalla, las herencia y jerarquías de las clases del programa.

<<class BANCO>> << class abstract Cuenta>>

NombreCliente: String
Void main NumeroCuenta:String
Saldo: float

Abstract void sacarDinero(float cant);

Abstract String TipoCuenta();
Abstract void verificarTrans(String tipo, float
cant)
<<class CapturaDespliega>> Void ingresarDinero(float cant)
String toString();
String Capturar(String Mensaje) Void toString (string mensaje)
Float getSaldo();
Void Desplegar (String Mensaje)
String getNom();
String getCuen();

<< class CuentaAhorro extends Cuenta>> << class CuentaCorriente extends Cuenta>>

void sacarDinero(float cant); void sacarDinero(float cant);

String TipoCuenta(); String TipoCuenta();
void verificarTrans(String tipo, float cant) Void verificarTrans(String tipo, float cant)
Void ingresarDinero(float cant) Void ingresarDinero(float cant)
String toString(); String toString();
Void toString (string mensaje) Void toString (string mensaje)
Float getSaldo(); Float getSaldo();
String getNom(); String getNom();
String getCuen(); String getCuen();

32
33