Trabajo Individual

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 INTRODUCCIÓN A- OBJETIVOS - Objetivo general - Objetivos Específicos I- FUENTES DE INFORMACIÓN COMENTADAS. II-GLOSARIO DE TÉRMINOS III- EJEMPLIFICACIÓN DE CONCEPTOS - superclase - herencia/jerarquía - clase abstracta - polimorfismo - sobrecarga de métodos IV- PRESENTACIÓN DE UNA APLICACIÓN EJECUTABLE - Descripción de dominio - Código fuente V- DIAGRAMAS (propuestas del programa) - Diagrama de dominio - Diagrama UML de clases y herencias

Págs. 2 3 3 3 4 9 12 12 12 16 18 21 23 23 23 31 31 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:

[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:

[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: [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: [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: [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:

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: [con acceso el 611-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 Gasolina1>>

<<subclase Diesel>>

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 / /Atributos de la superclase private float Precio_venta; private float Precio_compra;

Esta es la superclase llamada Petroleo1 de la cual de ella se derivan otras clases como la 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; this.Precio_compra=Precio_compra; this.cantidad=cantidad; this.Nom_derivado=Nom_derivado;

La referencia this se utiliza sólo dentro de un métodoproduce la referencia a la 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

} } ***// subclase Gasolina1 (hija) class Gasolina1 extends Petroleo1 { public Gasolina1 (float Precio_venta,float Precio_compra, int cantidad, String Nom_derivado )// constructor { super(2,Precio_compra,cantidad,"90 octano"); // }

Los subclases heredan todas las variables y métodos que sus ascendientes hayan especificado como heredables, además pueden crear sus propios métodos. Para 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(); } } // clase base o superclase abstracta public abstract class Petroleo{ // Atributos de la clase abstracta

En clase base abstracta Petróleo, no se puede crear instancias de dicha clase (new). Y de declaran con el 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 abstract public float getPrecioVenta(); // método abstracto abstract public int getCantidad(); public String getNombre() // método no abstracto { Nom_derivado="91 octanos"; return Nom_derivado; }

En clase base abstracta Petróleo , los métodos se declaran abstractos y s código que ejecutará se encuentra en otro lado, pero no obstante no todos los métodos de una clase abstracta tienen que ser 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 { // se crea un constructor por defecto public float getPrecioVenta() { P_venta=2; return P_venta; } public int getCantidad() { cant=5;

En las subclases se ejecutan los códigos de los métodos de la clase abstracta inicializando el precio de venta actual del producto y en el método de getCantidad que inicializa la cantidad en galones del producto y se adiciona otra método imprimirInforma() que

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 class CombustiblesPoli{ public static void main(String args[]){ float P_venta=3; float P_compra=2; int cant=4;

El poliformismo dinámico, la cual se hace referencia en este ejemplo es uno de los mecanismos más poderosos que ofrece el diseño orientado a 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; this.Precio_compra=Precio_compra; this.cantidad=cantidad; this.Nom_derivado=Nom_derivado; } // Métodos

Las tres clases implementadas a continuación tienen una relación subclases/superclase simple , donde la clase hija GasolinaPoli hereda todos los atributos y métodos de la superclase.

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) { String dato; dato=JOptionPane.showInputDialog(null,mens); return (dato); } public void Imprime(int valor, String mens) { JOptionPane.showMessageDialog(null,mens+" "+valor); } public void Imprime(String mens )// metodo sobrecargado { JOptionPane.showMessageDialog(null, mens); } // clase principal class Principal{ public static void main (String args[]){

Aquí en este ejemplo, tenemos una clase con dos métodos Imprime() uno recibe un string (mens) y un int (valor). Al llamar el método de esta manera m.Imprime(String, int) llamara sin problemas al método que tiene 2 parámetros, pero al sobrecargar el método para que reciba solo un String (mens), y un segundo método en la que el llamado sería m.Imprime (String) y no aquel metodo que tiene 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
"+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 Cuenta

Clase CuentaAhorro

superclase

Clase CuentaCorriente

clase que hereda de Object

Clase CapturaDespliega

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 abstract Cuenta>> NombreCliente: String NumeroCuenta:String Saldo: float

Void main

<> String Capturar(String Mensaje) Void Desplegar (String Mensaje)

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

<< class CuentaAhorro extends Cuenta>>

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

<< class CuentaCorriente extends Cuenta>>

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

32 33