trabajo individual
DESCRIPTION
Aqui muestro mi trabajo individual de conceptos involucrados a la programacion orientado a Objetos, espero que sea de ayuda para reforsar algunos conceptos no aclarados.TRANSCRIPT
UNIVERSIDAD DE PANAMÁCENTRO REGIONAL UNIVERSITARIO DE VERAGUAS
FACULTAD DE INFORMÁTICA, ELECTRÓNICA Y COMUNICACIÓNESCUELA INGENIERÍA EN INFORMÁTICA
LICENCIATURA PARA LA GESTIÓN EDUCATIVA Y EMPRESARIAL
-
0
TRABAJO INDIVIDUAL
JERARQUÍA Y HERENCIA
(PROGRAMACIÓN IV)
ESTUDIANTE
Reyes, Isis 2-160-330
PROFESOR
Diego Santimateo
II AÑO
II SEMESTRE
- 2006 -
Í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
1
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.
2
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.
3
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_centro=57953030052957564866666952674548&i
d_curso=65423040050153696570496756544557&url_frame=h
ttp://www.emagister.com/public/pdf/comunidad_emagister/
01643010051450685267675450524552-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.
4
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=basico >[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.
5
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_orientada_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.
6
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/categorias/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.
7
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.
8
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
9
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.
10
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.
11
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.
12
- jerarquías:
- 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
13
<<superclase Petroleo1>>
<<subclase Gasolina1>>
<<subclase Diesel>>
}// fin clase
// superclase
class Petroleo1 { // Hereda de Object
/ /Atributos de la superclase
private float Precio_venta;
private float Precio_compra;
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;
}
// 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);
}
14
Esta es la superclase llamada Petroleo1 de la cual de ella se derivan otras clases como la clase Gasolina1 y Diesel.
La referencia this se utiliza sólo dentro de un método- produce la referencia a la clase que se invoque.
}
***// 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"); //
}
}
***// 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);
}
}
15
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 el término extends. En este ejemplo, Gasolina1 y y Diesel son clases hijas de Petroleo1.
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”, para indicar el nombre del mismo.
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
ffloat P_venta;
float P_compra;
int cant;
String Nom_derivado;
public Petroleo()
{
this.P_venta=P_venta;
this.P_compra=P_compra;
16
En clase base abstracta Petróleo, no se puede crear instancias de dicha clase (new). Y de declaran con el modificador abstract
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;
}
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;
return cant;
}
public void imprimirInforma()
{
System.out.println("Precio"+" "+P_venta+" "+"cantidad"+" "+cant+" "+Nom_derivado);
}
}
17
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 métodos abstractos getPrecioVenta y getCantidad, se deben redefinir en las subclases.
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 imprime el precio de venta, cantidad de galones y nombre del derivado.
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;
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
}
}
}
}
18
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 reutilización del código.
//
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
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);
}
}
19
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.
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.
20
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[]){
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);
21
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 Object.Imprime(String, int). Para poder hacer un llamado a un método especifico es necesario detallar los parámetros correspondientes al método a llamar.
m1="edad";
edad=m.Capturar(m1);
m.Imprime(edad,nombre);// metodo de 2 parametros
} // fin del main
} // fin clase
22
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;
23
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.getCuen()+"\
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
24
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;
}
25
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
***************************************************************
26
// 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
27
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
28
{
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
29
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].
30
V- DIAGRAMAS
- DOMINIO DEL PROGRAMA: clases del programa.
Class Banco
Clase CuentaClase CapturaDespliega
Clase CuentaCorrienteClase CuentaAhorro
superclase
clase que hereda de Object
Subclases heredan de la Superclase
Clase auxiliar
310
- DIAGRAMA UML DE LA APLICACIÓN
Este diagrama UML detalla, las herencia y jerarquías de las clases del programa.
<< class abstract Cuenta>>
NombreCliente: StringNumeroCuenta:StringSaldo: float
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
<<class BANCO>>
Void main
<<class CapturaDespliega>>
String Capturar(String Mensaje)Void Desplegar (String Mensaje)
1