Documente Academic
Documente Profesional
Documente Cultură
TRABAJO INDIVIDUAL
JERARQUÍA Y HERENCIA
(PROGRAMACIÓN IV)
ESTUDIANTE
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
abstracta, super clase jerarquía y sobrecarga con cada uno con sus
lenguaje Java.
como los constructores, en los que residen los objetos, dónde ponerlos una
especial, por qué ha tenido tanto éxito, también se vera una aplicación de
3
A-OBJETIVOS
Objetivo General
- Objetivos Específicos
- Analizar conceptos involucrados en la jerarquía en Java.
4
I- FUNTES DE INFORMACIÓN COMENTADAS.
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].
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].
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>
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.
9
II- GLOSARIO DE TÉRMINOS
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
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 { ... }
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.
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
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.
13
- jerarquías:
<<superclase
Petroleo1>>
- 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;
}
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);
}
}
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:
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
- 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
}
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
}
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.
3132
- DIAGRAMA UML DE LA APLICACIÓN
Este diagrama UML detalla, las herencia y jerarquías de las clases del programa.
<< class CuentaAhorro extends Cuenta>> << class CuentaCorriente extends Cuenta>>
32
33