Exam en 30

Jerarquía en Java
UNIVERSIDAD NACIONAL DE PANAMÁ

CENTRO REGIONAL UNIVERSITARIO DE VERAGUAS
FACULTAD DE INFORMÁTICA, ELECTRONICA Y COMUNICACIÓN
INGENIERIA EN INFORMÁTICA
TRABAJO
INF 222
TEMA
JERARQUÍA Y HERENCIA EN JAVA
PROFESOR
DIEGO SANTIMATEO
ESTUDIANTE
FÁTIMA DEL R. ÁLVAREZ 9-722-549
FECHA DE ENTREGA
JUEVES 30 DE NOVIEMBRE DE 2006
Elaborado por: Fátima del R. Álvarez

Jerarquía en Java
Introducción
El propósito de este trabajo, presentando en dos partes una teórica y otra

experimental, consiste en manejar y aplicar los conceptos que implican la
jerarquía de Java.
Primero a través de la investigación y apoyado a la nueva tecnología
comenzamos a relacionarnos con conceptos y principios de temas como
herencia, sobrecargas entre otros que señalo a lo largo de este trabajo.
Lo más importante es que aprendimos a manejar conceptos, que antes
desconocíamos como implementar y que esto contribuirá a nuestro desarrollo
como estudiantes y como futuros profesionales.

Jerarquía en Java
Comentarios
Una de las primeras fuentes consultadas fue el manual de java publicado por la
escuela de ingeniería de la Universidad de Navarra en España, es un manual
completo que resalta las características y conceptos del lenguaje en Java así
como la programación OOP.
Para ellos la Herencia permite la creación de nuevas clases a partir de clases
ya existentes, ayudando así a reutilizar el código que ya se ha implementado
en otra ocasión heredando métodos y variables.
Resaltan que en Java a diferencia de otros lenguajes orientados a objetos, una
clase solo puede derivar de una única clase con lo cual es posible realizar
herencias múltiples. Sin embargo es posible simular la herencia múltiple en
base a interfaces.
Por su parte la jerarquía de clases en Java es la relación de herencia entre
clases: como la información de los distintos paquetes de las librerías en Java.
Con respecto a la clase abstracta señalan que es una clase de la cual no se
pueden crear objetos su utilidad es permitir que otras clases deriven de ella.
El polimorfismo tiene que ver con la llamada a un método y el código que se
efectivamente se asocia con dicha llamada. Esto permite al programador
separar las cosas que cambian de las que no cambian, de esta manera hace
más fácil la ampliación, el mantenimiento y reutilización de los programas.
Al igual que C++, Java permite métodos sobrecargados, es decir métodos
distintos con el mismo nombre pero que se diferencian por el tipo de
argumento.
En el libro Thinking In Java (segunda edición) el concepto de herencia es

normal es una manera para tomar una clase existente y agregar a su código
la funcionalidad necesaria. Señalan que la herencia es a menudo una manera
de rehusar el código, remendando las cosas simplemente aquí y allí para que
produzca lo que usted quiere. Bruce Eckel creador de este libro hace la
observación que en cuanto al polimorfismo nos podría tomar mas o menos
nueve meses en entender y descubrir el concepto de polimorfismo ya que una

Jerarquía en Java
piedra angular de la OOP. El polimorfismo de Java le permite tratar todos los

objetos genéricamente en familia.
Al tratar con las jerarquías del tipo, usted quiere a menudo no tratar un objeto
como el tipo específico que es, pero en cambio como su tipo bajo. Esto lo
permite escribir código que no depende de los tipos específicos.
El manual Java desde cero señala que la herencia, simplemente significa que
se pueden crear nuevas clases que hereden de otras sus métodos y variables;
simplificando la programación.
Un método abstracto sólo puede crearse dentro una clase abstracta. Cuando
la clase se hereda, el método debe ser llevado a cabo, o la clase heredando se
pone abstracta también.
Wikipedia, (http://es.wikipedia.org/wiki/Herencia_(programaci%C3%B3n_orientada_a_objetos) la
enciclopedia libre.htm señala que la herencia es un mecanismo de la
programación orientado a objetos por medio de la cual la clase puede extender
su funcionalidad. Tiene como función proveer el polimorfismo.
También señala las tipos de herencias: la herencia simple es decir solo tiene
un padre y la herencia múltiple el objeto puede obtener las características de
uno o más padres (no soportada en Java). Aunque muchos lenguajes no han
decido admitir la herencia múltiple por la coincidencia en los nombres.
Javahispano (http://www.javahispano.org/licencias/) cuenta con una amplia gama de

textos y tutoriales para el desarrollo de aplicaciones en Java en varios de estos
señalan que debemos usar herencia cuando hay una clase de tipo más
especifico que una superclase o cuando su comportamiento se pueda reutilizar
en varias clases con este concepto he reutilizado parte de los códigos
desarrollados en todo el semestre he reutilizado la clase capturaImprime, la
clase leearchivos, clase escribearchivos y en otros solo he utilizado los
métodos, claro haciendo las modificaciones pertinentes.
En Java2, tutorial de javahispano (http://javahispano.org) hacen referencia a que

las clases se disponen en una jerarquía donde una clase hereda los atributos y
métodos superiores en la jerarquía o por el contrario una clase puede tener
sus propios atributos y métodos.

Jerarquía en Java
Además resalta que las clases que están por debajo de la jerarquía se
conocen como subclases.
Por ser Tutoriales en pdf que facilitan la investigación y la búsqueda de la
información ya que muchos de ellos se elaboran en referencia a temas
específicos como ejemplo Herencia por lo general son bien completas y bien
estructuradas.
Poo.pdf de Miguel Ángel Abián (http://javahispano.org) esta es la segunda parte del
manual Orientación a Objetos, ya que la primera parte la utilizamos en clase
como material de estudio y apoyo. Esta fue una fuente de gran ayuda ya que
Miguel Abián utiliza una metodología interesante, maneja diversidad de
conceptos y fuentes bibliografícas permitiéndonos resolver nuestras
inquietudes en este caso en la jerarquía del lenguaje Java con mayor facilidad.
Practica4.pdf (http://javahispano.org) los objetivos de este manual son explicar

concretamente la herencia en java, aunque cabe señalar que para mi intereses
y comparándolo con otras fuentes de información no es muy completa , ni clara
ya que muestra ejemplos que cuesta un poco interpretar más cuando
comienzas a familiarizar con el tema. Aunque para un nivel avanzado es de
mucha utilidad.
Señalan que en Java, la herencia se gestiona mediante la palabra clave

extends. Cuando una clase hereda de otra, se considera que la clase
descendiente se deriva de la superclase.
Cuando una subclase necesita referirse a su superclase inmediata, lo puede
hacer utilizando la palabra super. Super se puede utilizar de dos formas:
• La primera para llamar al constructor de la superclase.
• La segunda para acceder a un miembro de la superclase que ha sido
ocultado por un miembro de la subclase.
Concepto muy utilizado a través del desarrollo de la parte experimental y
aprendí justamente de este manual.

Jerarquía en Java
Jaba _ básico 4_6(http://www.arrakis.es/~abelp/ApuntesJava/Herencia.htm)de esta pagina de

Internet tome el material de sobrecarga de métodos y constructores en java,
donde se mostraba el la definiciones y conceptos, es una página completa y
cuenta con muchos enlaces así que fácil de acceder mediante cualquier
buscador.
Miguel Ángel Corella publico un material en la web en formato

[slides3]PowerPoint donde habla de la programación avanzada en java y su
tema central es la jerarquía de clases tiene una serie de ejemplos con sus
respectivos UML, explica en detalle que es lo que ocurre cuando se hereda una
clase entre otros aspectos. No utilicé nada de este material pero si lo leí como
apoyo para mi trabajo.
ClasesAbstractas.htm (http://javahispano.org) habla de todo lo referente a la

jerarquía de Java pero de ella me intereso el concepto que explicaban de
Clases Abstractas. En verdad no es una página que merezca un 10 en
comparación con otras citadas.
Encontré un PowerPoint de polimorfismo (http://javahispano.org) desarrollados por

los ingenieros de Telecomunicaciones de la empresa mhProyects que habla de
todo un poco acerca de este gran pilar de la OOP. La utilización de una interfaz
con múltiples métodos, las características del polimorfismo su definición y
algunos ejemplos.
Métodos y Clases en Java: Parte II

En este sitio se encuentra gran cantidad de información acerca de la jerarquía
en Java; el único pero es que no permite guardar tutoriales y demás artículos si
no estas registrado en la base de datos del sitio. Yo me inscribí pero no fui
almacenada en la base de datos y se me fue imposible adquirir información
super buena de tema estos por este inconveniente.

Jerarquía en Java
A continuación comentare un artículo que habla de los conceptos involucrados

en la jerarquía en Java y que no guardo la dirección del sitio donde los
encontré.
En tutorial de programación de Java:

(http://www.javahispano.org/cursotext.viewer.action?file=basico) en su capitulo 4 se refiere a la
sobrecarga de métodos como la creación de varios métodos con el mismo
nombre pero con diferentes firmas y los diferencia de otros métodos en base al
número y tipo de argumento que tiene y aclara que no por el tipo que devuelve.
La herencia es el mecanismo por el que se crean nuevos objetos definidos en
términos de objetos ya existentes. Por ejemplo, si se tiene la clase Reptil, se
puede crear la subclase Serpiente, que es una especialización de Reptil.
Señalan que Java se diseño para que fuera un lenguaje sencillo, por esto no se
le permitió la capacidad de herencia múltiple tal como ocurre el la programación
en C++.
Con esto resalto algunas fuentes de información que me han ayudado en gran
medida a la compresión y aplicación de los temas que exigía esta experiencia.
La programación en Java requiere mucho análisis y conocimiento porque
enfoca los problemas desde una perspectiva real exigiendo mayor entrega
pero a la vez facilitando al programador las aplicaciones de Software.

Jerarquía en Java
Glosario de Términos Involucrados en La Jerarquía de Java
En esta sección se defino algunos conceptos utilizados en este trabajo teórico y

experimental en donde destaco la interpretación y conocimiento que tengo de
los mismos ha base de la investigación y análisis lo que me ha permitido
elaborar mi proyecto con éxito.
Atributos: variables que se declaran dentro del cuerpo de la clase (variables

miembros) o de un método (variables locales), en Java no se usan variables
globales.
Atributos miembros: se encuentran dentro del cuerpo de la clase y pueden

ser: atributo de clase o atributo de instancia.
Atributos de clases: se dicen que son atributos de clase si se usa la palabra

clave static: en ese caso la variable es única para todas las instancias (objetos)
de la clase (ocupa un único lugar en memoria).
Atributos de instancia: si no se usa static, el sistema crea un lugar nuevo

para esa variable con cada instancia (o sea que es independiente para cada
objeto).
Clase: agrupación de datos (variables o campos) y métodos que operan sobre

esos datos. Es el patrón o modelo que define las características y
comportamientos para crear objetos en ella se basa la OOP.
Clase abstracta (clase abstract): clase de la cual no se pueden crear objetos,

su utilidad es permitir que otras clases deriven de ella proporcionándole un
modelo a seguir y algunos métodos que son de utilidad general, puede tener
métodos abstractos o métodos que no son abstractos.

Jerarquía en Java
Extends: palabra reservada del lenguaje java, indica que una clase hereda de
otra.
Herencia: se da cuándo pueden crear nuevas clases que hereden de otras

preexistentes variables y métodos; esto simplifica la programación, porque las
clases hijas incorporan automáticamente los métodos de las madres.
Herencia simple: un objeto puede extender las características de otro objeto y

de ningún otro, en conclusión solo puede tener un padre.
Interfaces: conjunto de declaraciones de métodos. También pueden definir

constantes, que son implícitamente, public, static y final. Además las
interfaces tienen una jerarquía, propia, independiente y más flexible que la de
las clases ya que tienen permitida la herencia múltiple.
Instancia: véase. Definición de objeto.
Jerarquía: cualquier clasificación u ordenación de cualquier modelado

(abstracción). Existen varios tipos de jerarquía como la de
generalización/especialización y de clases entre otras.
Jerarquía de clase: una clase es una especialización (subclase o clase “hija”)

de otra (superclase o clase madre) cuando representa, con respecto a la
superclase, un elemento más especifico en dominio modelado. Permite
apreciar fácilmente qué clases son subclases de otras.
Método: es un bloque de instrucciones que realiza una función específica para

la clase que la invoca o la crea; ella consta de sus propios atributos, aunque
también puede utilizar los atributos miembros de la clase donde se aloja para
realizar las tareas encomendadas. Pueden retornar (return) o no (void) valores.

Jerarquía en Java
Objeto: un objeto (también conocido como instancia), es una variable concreta

de una clase, con su propia copia de los atributos miembros.
Polimorfismo: permite separa las cosas que cambian de las que no cambian,
podemos referenciar un objeto de una subclase mediante una referencia
declarada como una de sus superclases. El polimorfismo tiene que ver con la
relación que se establece entre la llamada a un método y el código que se
asocia con dicha llamada.
Sobrecarga de Método: métodos distintos que tiene el mismo nombre, que se

diferencian por la cantidad y tipo de argumentos que contienen.
UML: lenguaje gráfico que permite modelar, construir y captar la

documentación necesaria para el desarrollar componentes de un software (en
nuestro caso clase en Java).
Subclase: clase hija que hereda los atributos de la superclase. Por eso se
implementa mediante la herencia.
Superclase: clase padre o madre de una clase determinada, de ella las

subclases heredan los atributos. Por ejemplo Geometría es una superclase de
triangulo mientras triangulo grafico es una subclase.
Super y this: son dos palabras claves de Java. Super referencia al objeto
actual pero apuntando al padre. Se utiliza para acceder desde un objeto a
atributos y métodos (incluye constructores) del padre.

Jerarquía en Java
Ejemplo de Conceptos Analizados
• Sobrecarga de Constructores:
/*Compilador: Eclipse SDK.

Autor: Fátima Álvarez G
Cédula: 9-722-549
*Comentario: Aquí muestro un ejemplo de sobrecarga de constructores en
la clase Cliente, Java diferencia los métodos sobrecargados con base en el
número y tipo de argumentos que tiene el método y no por el tipo que
devuelve. */
public class Cliente {
String nombre;
int edad;
String direccion;
/* El constructor de la clase Cliente esta sobrecargado */

Cliente ( )
{
nombre = null;
edad = 0;
direccion = null;
}
Cliente (String nombre, int edad, String direccion)

{
this.nombre = nombre;
this.edad = edad;
this.direccion = direccion;
}
Cliente (Cliente fat)

{
nombre = fat.getNombre();
edad = fat.getEdad();
direccion = fat.getDireccion();
}
void setNombre(String nom)

{
nombre = nom;
}
String getNombre()
{
return nombre;
}
/* El metodo fatEdad () está sobrecargado */

void setEdad(int ed)
{
edad = ed;
}
void setEdad(float ed)

{

Jerarquía en Java
edad = (int)ed;
}
int getEdad()
{
return edad;
}
void setDireccion(String direc)

{
direccion = direc;
}
String getDireccion ()
{
return direccion;
}
}
/* Aquí muestro la segunda parte de la Clase Cliente
donde hago sobrecarga nuevamente de constructores. */
public class PrograCliente {
void imprimeCliente(Cliente fat)

{
// fat.nombre equivale en este caso a fat.getNombre ()
System.out.println ("\nNombre: " + fat.nombre );
System.out.println("Edad: " + fat.getEdad() );
System.out.println("Direccion: " + fat.getDireccion() +"\n \n");
}
public static void main(String args[])

{
PrograCliente prog = new PrograCliente ( );
/* Se declaran dos objetos cada uno de la clase Cliente */

Cliente fat1,fat2;
/* Usamos el constructor por omisión */

fat1 = new Cliente( );
prog.imprimeCliente(fat1);
/* Usamos el segundo constructor de Cliente */

fat2 = new Cliente("Fátima Álvarez",21,"Montijo City");
prog.imprimeCliente (fat2);
/* Usamos el tercer constructor de Cliente */

fat1 = new Cliente(fat2);
fat1.setEdad(50);
fat2.setEdad(30.45f);
prog.imprimeCliente(fat1);
prog.imprimeCliente (fat2);

Jerarquía en Java
• Ejemplo de Sobrecarga de Métodos:
/*Compildor:Eclipse SDK.
Autor: Fátima Álvarez G
Cédula: 9-722-549
En este ejemplo sencillo muestro la Sobrecarga de métodos en Java
creo 3 métodos pero dos con el mismo nombre (f_nombre) pero cambian
en los parámetros que le asigne a cada uno esto indicara a cual método estoy
llamando en determinado momento */
import javax.swing.*;
public class animal {
String edad=new String("Tengo 21 años");

String nombre=new String("Soy Fátima Álvarez");
public void nace(){

System.out.println ("Hola Amigos...");
}
//se construye el método f_nombre no le asigno parámetros
public void f_nombre(){
System.out.println (nombre);
/*Aquí ya producimos una sobrecarga al construir otro método. Lo único que

diferencia a los métodos f_nombre() son sus parámetros este tiene unString*/
public void f_nombre(String i){
System.out.println (nombre +" " +edad);
}
public void f_edad(){
System.out.println(edad);
}
public static void main(String[] args) {
animal objeto= new animal();
objeto.nace ();
//Llamada al método sobrecargado

/*Según el los parámetros que pasamos se invocará
a uno u otro método*/
objeto.f_nombre ();
objeto.f_edad ();
}
}

Jerarquía en Java
• Ejemplo de Herencia y Polimorfismo:
Creo la clase mamífero, a la que le agrego datos como el número de patas del
animal o el color del pelaje, y luego derivamos de esta clase las clases Caballo
y Toro (ya que ambos son mamíferos), a las que no hace falta agregar que
poseen patas o que tienen pelajes, porque ya lo hemos hecho en la clase base,
mamífero.
Además podemos agregarles otros datos o funciones a los que ya nos brinda la
clase base (ampliándola, llevándola a una situación más particular) como, por
ejemplo, la cantidad de relinchos o bramidos (según cada caso).
/*Compildor:Eclipse SDK.
Autor:Fátima Álvarez G
Cédula:9-722-549
Ejemplo de Herencia: Este es main aquí invoco la clase Caballo y Toro que
heredan de la clase mamífero sus características */
public class PrograCarrera {
public static void main(String [] args) {
Caballo zeus = new Caballo("Zeus");
Toro luna= new Toro ("Ese Toro enamorado de la Luna");
zeus.imprimirPatas (); /*Está en la clase mamífero*/
luna.imprimirPatas ();
}
}
/*En este segmento muestro la Clase Mamífero que es la SuperClase, de ella
heredan la clase perro y gato la condición de mamíferos.*/
public class Mamifero {
private int patas;

private int colorPelo;
private String nombre;
public void imprimirPatas() {

System.out.println (nombre + " corre con " + patas + " patas\n");
}
public Mamifero(String nombre, int patas) {

this.nombre = nombre;
this.patas = patas;
}
}
Luego creo la clase Caballo y Toro cada una por separado:
public class Caballo extends Mamifero {

private int relinchos;
public Caballo(String nombre) {
super(nombre, 4);
relinchos= 0;
}
}
//Segmento de la clase Toro lo programo como extensión de la clase mamífero
public class Toro extends Mamifero {
private int bramidos;

Jerarquía en Java
public Toro (String nombre) {

super(nombre, 4);
bramidos= 0;
}
}
• Ejemplo de Polimorfismo:
Es un programa parecido al anterior tiene una clase (conjunto de objetos con
características en común), pueda tener diferentes comportamientos aunque
este es uno muy sencillo.
public class ClaseFatima{
void metodoDinamico() {
System.out.println ("En el método dinámico de la claseFatima");

}
}
class claseFaty extends ClaseFatima { /*señalo que la claseFaty es una extensión de la
claseFatima*/
void metodoDinamico()
System.out.println ("En el método dinámico de la claseFaty");
}
public static void main(String[] args) { //construyo el main dentro de la clase

ClaseFatima referencia = new claseFaty ();
referencia.metodoDinamico();//luego hago el llamado del método
}
}
• Ejemplo Clase Abstracta:
Cuando una clase contiene un método abstracto tiene que declararse

abstracta. No obstante, no todos los métodos de una clase abstracta tienen que
ser abstractos. Las clases abstractas no pueden tener métodos privados (no se
podrían implementar) ni tampoco estáticos. Una clase abstracta tiene que
derivarse obligatoriamente, no se puede hacer un new de una clase abstracta.
public abstract class ClaseFatima {
abstract void metodoAbstracto();

void metodoConcreto() {
System.out.println("En el método concreto de ClaseFatima");
}
}
class claseFaty extends ClaseFatima{
void metodoAbstracto(){
System.out.println("En el método abstracto de claseFaty");
}

Jerarquía en Java

ClaseFatima referencia= new claseFaty ();
referencia.metodoAbstracto();
referencia.metodoConcreto();
}
}
• Super Clase
En este sencillo ejemplo se muestra una clase padre o Superclase que hereda
a su clase hija o subclase el detalle es que la subclase no puede ser pública
public class ClasePadre {

public void imprimir()
{
System.out.println("Método del padre");
}
}
class claseHija extends ClasePadre //no puede ser publica
{
public void imprimir()
{
super.imprimir(); //referencia al objeto actual pero apuntando al padre con ella podemos
acceder los métodos provenientes del padre//.
System.out.println("Método del Hijo");
}

ClasePadre fa=new claseHija ();
fa.imprimir();

Jerarquía en Java
Propuesta para resolver un problema de de control de Inventario en el

departamento de farmacia y laboratorio de un Centro de salud
El desarrollo de un programa que maneje los registros de compras de

productos y demás insumos en un departamento, permitirá la creación de
archivos digitales que faciliten el inventario y almacenamiento de información
importante, como lo es el estado del producto que se esta distribuyendo.
Mi propuesta consiste en almacenar en archivos lo códigos de cada producto

que se posee, así como la cantidad de ese producto que se posee y cantidad
mínima que se debe tener para ordenar otra compra de producto claro cada
una se pasara a un archivo donde se indica la lista de productos en orden y la
otra, la cantidad de producto que se necesita comprar, incluimos también el
valor unitario y su fecha de expiración si la tiene.
Incluye también un clase que me permite con solo marcar las fecha actual y
código del producto, si el producto expiro de lo contrario me indicara cuanto
tiempo le falta por hacerlo.
Esta opción es de mucha importancia por que de esta manera se podrá sacar
del medio productos que no estén en condiciones para el consumo humano, o
advertir cuales productos tendremos que compran muy pronto.

Jerarquía en Java
Esquema Final del Programa De Inventario de

Mercancía en una Farmacia
CapturaImprime
+capturaInventario() : string(idl)
+condicion() : string
+Consulta(int modo)() : string(idl)
*
+escribirarchivo(String[] articulo, String nombrearch)() : void
+instancias(String[] mercancia,int modo)() : Inventario
en
Esta es la Fátima
clase main +articulos : string(idl)
donde se hace +en : CapturaImprime 1
la invocación +sa : Reorden
de los +sa1 : Orden
+mercancia : Inventario
métodos. +sa2 : TiempoVencimiento
1
1 1
sa2
sa1
sa
TiempoVencimient
*
+tiempoexpiracion(Inventario dat)() : void
**
La clase TiempoVencimient
Inventario cuenta con el método que permite
#codigo : string = null con solo introducir la fecha actual
#existencia : string = null
#orden : string = null y el código de producto o
#reorden : string = null
#precio : string = null
medicamento el tiempo de
#expiracion : string = null expiración o cuanto le falta el
producto para que pueda ser del
consumo humano.
Reorden
Orden
+dividir (Inventario[] a1, String[] mercancia)() : string

+dividir (Inventario[] a1, String[] mercancia)() : string
La superclase Inventario, tiene dos clase hijas que heredan: las clase Reorden
y Orden estas leen el archivo y determinan la cantidad de producto disponible
para el mercado y además la cantidad limite que debe haber de mismo
producto.
Toda la información de la Orden y Reorden se escribirá en un nuevo archivo
para que el Inventarista o Farmacéutico tenga Acceso a la información del
estado del producto que poseen.

Jerarquía en Java
Código Fuente
//Main aloja los constructores y objetos que nos permitirá llamar a las clases de
Tiempo de vencimiento, orden, reorden e inventario.
import java.io.*;
import javax.swing.*;
class Fátima {
public static void main(String[] args) throws IOException{
String cod = null,ex = null, ord = null, reord = null, prec = null, exp = null;
CapturaImprime en = new CapturaImprime();
Reorden sa = new Reorden(cod,ex,ord,reord,prec,exp);
Orden sa1 = new Orden(cod,ex,ord,reord,prec,exp);
Inventario[] mercancia = new Inventario[100];
String[] articulos = new String[100];
int i = 0;
String cond = "S";
String c1 = "S";
try{
/*Esta sección permite procesar la opción de crear un nuevo registro de

mercancía
Compara el símbolo S y permite crear más registros hasta que el símbolo de
entrada sea N*/
cond=JOptionPane.showInputDialog(null,"Desea crear un nuevo Registro de Inventario

S/N");
if((cond.equals("s"))||(cond.equals("S")))
while((cond.equals("s"))||(cond.equals("S")))
{//hasta cuantos registros quiero crear
articulos[i] = en.capturaInventario();
i = i + 1;
cond = en.condicion();
}
en.escribirarchivo(articulos,"inventario.txt");
articulos = en.Consulta(0);
en.imprimirenpantalla(articulos);
mercancia = en.instancias(articulos,0);
articulos = sa.dividir(mercancia,articulos);
en.escribirarchivo(articulos,"reorden.txt");
articulos = sa1.dividir(mercancia,articulos);
en.escribirarchivo(articulos,"orden.txt");
JOptionPane.showMessageDialog(null,"Se iniciara una busqueda para determinar\nla fecha de
caducidad de un producto");
cond = en.condicion();
if((cond.equals("S"))||(cond.equals("s")))
{
articulos = en.Consulta(1);
JOptionPane.showMessageDialog(null,""+articulos[1]);
if(Integer.parseInt(articulos[3])== 1)
{
mercancia = en.instancias(articulos,1); //modo 1 solo un objeto

Jerarquía en Java
TiempoVencimiento sa2 = new TiempoVencimiento();

sa2.tiempoexpiracion(mercancia[0]);
}
else
JOptionPane.showMessageDialog(null,"clave no encontrada");
}
}
catch(IOException err){
JOptionPane.showMessageDialog(null,""+err.toString());
}
}
La clase Captura Imprime hace el típico trabajo de captar los datos que son
referenciados desde main, además cuenta con dos métodos.
public class CapturaImprime{
public String capturaInventario() //Captura datos desde la entrada estandar

{
String a,b,c,d,e,f;
a = JOptionPane.showInputDialog(null, "Código del producto");

b = JOptionPane.showInputDialog(null, "Existencia en inventario");
c = JOptionPane.showInputDialog(null, "Cantidad de Orden del producto");
d = JOptionPane.showInputDialog(null, "Cantidad de Reorden del Producto");
e = JOptionPane.showInputDialog(null, "Precio unitario del producto");
f = JOptionPane.showInputDialog(null, "Fecha de vencimiento del producto
dia/mes/año");
return(a+" "+b+" "+c+" "+d+" "+e+" "+f);
}
public String condicion()
{
String cond;
cond = JOptionPane.showInputDialog(null, "Desea continuar S/N");

return(cond);
}
public void imprimirenpantalla(String[] imp) //imprime datos en cosola
{
int i = 0;
while(imp[i] != null)
{
System.out.println(imp[i]);
i = i + 1;
}
}
//Este método permite la consulta de un archivo ya creado con anterioridad o

uno recién construido.
public String[] Consulta(int modo) throws IOException //realiza la captura desde el archivo
{
String[]articulos = new String[100];

Jerarquía en Java
FileReader f_entrada = new FileReader("inventario.txt");;

BufferedReader entrada = new BufferedReader(f_entrada);
StringTokenizer a1;
String aux;
int i = 0;
try
{
if(modo == 0)
{
articulos[i] = entrada.readLine();
while(articulos[i]!=null)
{
i = i + 1;
articulos[i] = entrada.readLine();
}
}
else //realiza búsquedas
{
articulos[0] = JOptionPane.showInputDialog(null,"Indique el código"); //artículos[0] clave
articulos[1] = entrada.readLine(); //artículos[1] línea leída
aux = articulos[1];
if(articulos[0]==null)
aux =".. ..";
a1 = new StringTokenizer(aux," "); //artículos[2] código en línea
articulos[2] = a1.nextToken();
//artículos[3] valor de cierto(1) o falso(0)

while((articulos[1]!=null)&&(articulos[2].equals(articulos[0]) != true)){
articulos[1] = entrada.readLine();
aux = articulos[1];
if(articulos[0]==null)
aux =".. ..";
a1 = new StringTokenizer(aux," "); //artículos[2]
código en línea
articulos[2] = a1.nextToken();
}
if(articulos[0].equals(articulos[2]) != true)
articulos[3] = "0"; //no encontrado
else
articulos[3] = "1";//encontrado
}
}
catch(EOFException a)
{
JOptionPane.showMessageDialog(null, a.toString());
}
return(articulos);
}
public void escribirarchivo(String[] articulo, String nombrearch)
{
FileOutputStream f_escritura;
PrintWriter escritura;
int i = 0;
try
{
f_escritura = new FileOutputStream(nombrearch,false);

Jerarquía en Java
escritura = new PrintWriter(f_escritura,true);

while(articulo[i] != null)
{
escritura.println(articulo[i]);
i = i + 1;
}
escritura.close();
f_escritura.close();
}
catch(IOException error)
{
JOptionPane.showMessageDialog(null,"No se pudo crear el archivo
inventario.txt"+error.toString());
System.exit(1);
}
}
public Inventario[] instancias(String[] mercancia,int modo)
{
String codigo,existencia,orden,reorden,precio,expiracion;
Inventario[] objetos = new Inventario[100];
int i = 0;
if(modo == 0)
while(mercancia[i] != null) //arreglo de objetos
{
StringTokenizer dat = new StringTokenizer(mercancia[i]," ");
codigo = dat.nextToken();
existencia = dat.nextToken();
orden = dat.nextToken();
reorden = dat.nextToken();
precio = dat.nextToken();
expiracion = dat.nextToken();
objetos[i] = new Inventario(codigo,existencia,orden,reorden,precio,expiracion);
i = i + 1;
}
else //Solo un objeto
{
StringTokenizer dat = new StringTokenizer(mercancia[1]," ");

codigo = dat.nextToken();
existencia = dat.nextToken();
orden = dat.nextToken();
reorden = dat.nextToken();
precio = dat.nextToken();
expiracion = dat.nextToken();
objetos[0] = new Inventario(codigo,existencia,orden,reorden,precio,expiracion);
}
return(objetos);
}
//Superclase sus variables son protegidas
public class Inventario

{
protected String codigo;
protected String existencia;
protected String orden;

Jerarquía en Java
protected String reorden;

protected String precio;
protected String expiracion;
public Inventario(String cod, String ex, String ord, String reord, String prec, String exp)
{
this.codigo = cod;
this.existencia = ex;
this.orden = ord;
this.reorden = reord;
this.precio = prec;
this.expiracion = exp;
}
}
class Reorden extends Inventario //Productos que hay que comprar
{
public Reorden(String cod, String ex, String ord, String reord, String prec, String exp)
{
super(cod, ex, ord, reord, prec, exp);
}
public String[] dividir(Inventario[] a1, String[] mercancia)
{
int c1 = 0,b1 = 0,m = -1;
String[] reorden1=new String[100];
int i=0;
while(mercancia[i] != null)
{
c1 = Integer.parseInt(a1[i].reorden);
b1 = Integer.parseInt(a1[i].existencia);
if(b1 <= c1)
{
m = m + 1;
reorden1[m] = mercancia[i];
}
i = i + 1;
}
return(reorden1);
}
}
class Orden extends Inventario{ //Productos que estan en orden
public Orden(String cod, String ex, String ord, String reord, String prec, String exp) {
super(cod, ex, ord, reord, prec, exp);
}
public String[] dividir(Inventario[] a1, String[] mercancia)
{
int c1 = 0,b1 = 0,m = -1;
String[] orden1=new String[100];
int i=0;
while(mercancia[i] != null)
{
c1 = Integer.parseInt(a1[i].reorden);
b1 = Integer.parseInt(a1[i].existencia);
if(b1 <= c1)
{
m = m + 1;
orden1[m] = mercancia[i];
}

Jerarquía en Java
i = i + 1;
}
return(orden1);
}
//La clase que determina la fecha de expiración de un producto dentro del

registro de inventario
import java.util.StringTokenizer;
import javax.swing.JOptionPane;
public class TiempoVencimiento {
public void tiempoexpiracion(Inventario dat) //fecha de expiracion desde el archivo

{
int dia,dia1;
int mes,mes1;
int año,año1;
StringTokenizer a;
String b1;
b1=JOptionPane.showInputDialog(null,"Indique la fecha actual dd/mm/aaaa");

a=new StringTokenizer (b1,"/");
dia1=Integer.parseInt(a.nextToken());
mes1=Integer.parseInt(a.nextToken());
año1=Integer.parseInt(a.nextToken());
a = new StringTokenizer(dat.expiracion,"/");
dia = Integer.parseInt(a.nextToken());
mes = Integer.parseInt(a.nextToken());
año = Integer.parseInt(a.nextToken());
if((dia > dia1)&&(mes > mes1))
if(año > año1)
JOptionPane.showMessageDialog(null,"Producto Vencido");
else
{
año = año1 - año;
if(mes1 > mes)
mes = mes1 - mes;
else
mes = mes1 - mes+12;
if(dia1>dia)
dia = dia1 - dia;
else
{
dia = dia1 - dia + 30;
mes = mes - 1;
}
JOptionPane.showMessageDialog(null,"Tiempo por vencer"+dia+" "+mes+" "+año);
}
}
}

Jerarquía en Java
Muestra del desarrollo de la aplicación en Eclipse 3.1

Jerarquía en Java
Conclusión
El desarrollo de este trabajo me ha permitido ampliar mis conocimientos acerca

de la programación orientada a objetos bajo el dominio del lenguaje Java
Familiarizarse con la estructura de un programa en Java facilita el desarrollo de
aplicaciones para automatizar los sistemas en general ya que permite, analizar
y diseñar soluciones para los problemas y necesidades de nuestra vida diaria
con una visión cercana a la realidad sin contar que la reutilización de clases y
métodos en Java le facilita el trabajo al programador.
Para terminar quisiera resaltar este pensamiento:
“Los objetos en el sentido de la orientación a objetos han estado

presentes
entre nosotros desde que se desarrollo la conciencia en la especie
humana, pero se ha tardado miles de años en aprovecharlos como
técnica. ¿Cuánto tiempo más se necesitará para extraer el máximo
rendimiento de la OO?
Quizás necesitemos un cambio conceptual antes que una sucesión
frenética de cambios llegue pronto.”
Howard Humphry

Exam en 30

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Exam en 30

Transféré par

Droits d'auteur :

Formats disponibles

Jerarquía en Java

UNIVERSIDAD NACIONAL DE PANAMÁ

FÁTIMA DEL R. ÁLVAREZ 9-722-549

JUEVES 30 DE NOVIEMBRE DE 2006

Elaborado por: Fátima del R. Álvarez

El propósito de este trabajo, presentando en dos partes una teórica y otra

Elaborado por: Fátima del R. Álvarez

En el libro Thinking In Java (segunda edición) el concepto de herencia es

Elaborado por: Fátima del R. Álvarez

piedra angular de la OOP. El polimorfismo de Java le permite tratar todos los

Javahispano (http://www.javahispano.org/licencias/) cuenta con una amplia gama de

En Java2, tutorial de javahispano (http://javahispano.org) hacen referencia a que

Elaborado por: Fátima del R. Álvarez

Practica4.pdf (http://javahispano.org) los objetivos de este manual son explicar

Señalan que en Java, la herencia se gestiona mediante la palabra clave

Elaborado por: Fátima del R. Álvarez

Jaba _ básico 4_6(http://www.arrakis.es/~abelp/ApuntesJava/Herencia.htm)de esta pagina de

Miguel Ángel Corella publico un material en la web en formato

ClasesAbstractas.htm (http://javahispano.org) habla de todo lo referente a la

Encontré un PowerPoint de polimorfismo (http://javahispano.org) desarrollados por

Métodos y Clases en Java: Parte II

Elaborado por: Fátima del R. Álvarez

A continuación comentare un artículo que habla de los conceptos involucrados

En tutorial de programación de Java:

Elaborado por: Fátima del R. Álvarez

Glosario de Términos Involucrados en La Jerarquía de Java

En esta sección se defino algunos conceptos utilizados en este trabajo teórico y

Atributos: variables que se declaran dentro del cuerpo de la clase (variables

Atributos miembros: se encuentran dentro del cuerpo de la clase y pueden

Atributos de clases: se dicen que son atributos de clase si se usa la palabra

Atributos de instancia: si no se usa static, el sistema crea un lugar nuevo

Clase: agrupación de datos (variables o campos) y métodos que operan sobre

Clase abstracta (clase abstract): clase de la cual no se pueden crear objetos,

Elaborado por: Fátima del R. Álvarez

Herencia: se da cuándo pueden crear nuevas clases que hereden de otras

Herencia simple: un objeto puede extender las características de otro objeto y

Interfaces: conjunto de declaraciones de métodos. También pueden definir

Instancia: véase. Definición de objeto.

Jerarquía: cualquier clasificación u ordenación de cualquier modelado

Jerarquía de clase: una clase es una especialización (subclase o clase “hija”)

Método: es un bloque de instrucciones que realiza una función específica para

Elaborado por: Fátima del R. Álvarez

Objeto: un objeto (también conocido como instancia), es una variable concreta

Sobrecarga de Método: métodos distintos que tiene el mismo nombre, que se

UML: lenguaje gráfico que permite modelar, construir y captar la

Superclase: clase padre o madre de una clase determinada, de ella las

Elaborado por: Fátima del R. Álvarez

Ejemplo de Conceptos Analizados

/*Compilador: Eclipse SDK.

/* El constructor de la clase Cliente esta sobrecargado */

Cliente (String nombre, int edad, String direccion)

Cliente (Cliente fat)

void setNombre(String nom)

/* El metodo fatEdad () está sobrecargado */

void setEdad(float ed)

Elaborado por: Fátima del R. Álvarez

void setDireccion(String direc)

public class PrograCliente {

void imprimeCliente(Cliente fat)

public static void main(String args[])

/* Se declaran dos objetos cada uno de la clase Cliente */

/* Usamos el constructor por omisión */

/* Usamos el segundo constructor de Cliente */

/* Usamos el tercer constructor de Cliente */