UNIVERSIDAD DE PANAMÁ

CENTRO REGIONAL UNIVERSITARIO DE VERAGUAS

LICENCIATURA EN INFORMÁTICA PARA LA GESTIÓN
EDUCATIVA Y EMPRESARIAL

TRABAJO DE PROGRAMACIÓN

30%DE SEMESTRAL

PROFESOR
DIEGO SANTIMATEO

PERTENECE A:
ZULEYKA POVEDA SANTOS
9-724-1338

FECHA DE ENTREGA:
30/11/2006

1
 TABLA DE CONTENIDO

TRABAJO DE PROGRAMACIÓN............................................................................................1
30%DE SEMESTRAL.............................................................................................................1
INTRODUCCIÓN...........................................................................................................................3
FUENTES DE INFORMACIÓN....................................................................................................4
GLOSARIO DE TÉRMINOS..........................................................................................................8
EJEMPLOS DE LOS CONCEPTOS ............................................................................................10
EJEMPLO DE HERENCIA:.....................................................................................................10
EJEMPLO DE POLIMORFISMO:...........................................................................................11
EJEMPLO DE CLASE ABSTRACTA:.....................................................................................12
EJEMPLO DE SOBRECARGA:...............................................................................................13
APLICACIÓN DE TODOS LOS CONCEPTOS APRENDIDOS................................................14
DESCRIPCIÓN DE LA APLICACIÓN EJECUTABLE..............................................................19

2
 INTRODUCCIÓN

Este trabajo contiene conceptos involucrados con la Programación orientada a Objetos

Entre ellos están la Herencia, Jerarquía, Clase Abstracta, entre otros.

Para cada uno de estos conceptos observaremos un ejemplo donde se presenta y se

explica mejor como se utiliza el mismo. También contiene un glosario de conceptos
importantes en la programación orientada a objetos donde se explica cada concepto de
una manera fácil de comprender .

Por ultimo presento una aplicación donde se aplican todos los conceptos aprendidos, con
sus debidas especificaciones UML.

3
 FUENTES DE INFORMACIÓN

1. Agustín Froufe.(1996). Ultima Actualización (1 de Enero de 1997 ).Tutorial de

Java. disponible en Internet en:
<http://www.cica.es/formacion/JavaTut/Cap1/heren.html>.[con acceso 07-11-
2006].

Comentario:

En este tutorial se presenta una visión general del lenguaje de programación Java,
contiene un índice de contenido en el cual se encuentra la Herencia y Las Clases
Abstractas en lo que concierne a la Herencia presentan una breve explicación sobre
el mecanismo de la herencia, la importancia de al herencia, así como también
presenta algunos ejemplos prácticos que explican mejor lo que es la herencia. Y sobre
las Clases Abstractas presentan una breve explicación referente a las Clases
Abstractas y varios ejemplos para enriquecer el concepto.

2. Miguel Ángel Manzanéelo del Campo ,otros.(5 octubre 1998).Guía Rápida de

Aprendizaje del Lenguaje Java. Universidad de Burgos España. Disponible en
Internet
en<http://pisuerga.inf.ubu.es/lsi/Invest/Java/Tuto.Oct98/2_Lengua/4_Herenc.htm>
[con acceso 08-11-2006]

comentario:

Esta pagina en su contenido presenta una guía rápida de aprendizaje del lenguaje Java, en
el contenido presentan una introducción a la programación orientada a objetos (Poo),
contiene una introducción al mecanismo Herencia y algunos ejemplos para enriquecer el
concepto de Herencia.

4
 3. Antonio Bel Puchol. Apuntes Lenguaje Java. Ultima actualización ( 17-Junio-
2001) Disponible en Internet en:
<http://www.arrakis.es/~abelp/ApuntesJava/indice.htm>.[con acceso 08-11-2006]

Comentario:

Esta pagina contiene apuntes divididos en dos partes, la primera parte de estos apuntes
cubre todos los aspectos del lenguaje (Clases, Interfaces, herencia, control de flujo, tipos
de datos, etc.). La segunda parte, actualmente en elaboración, trata materias de la API de
Java, agrupándolos por temas (Entrada / salida, Threads, applets, etc.).

4. Laura González Partida , otros. (20 de Junio del 2001). Partida Paradigma de la
orientación a objetos: lenguaje java. Baja California Sur. Disponible en Internet
en: < http://www.itlp.edu.mx/posgrado/lengprog/java.html>. [con acceso 08-11-
2006].

Comentario:

La misma nos muestra la importancia de la programación orientada a objetos, también

contiene una leve historia de java, explica muy bien los mecanismos de Herencia,
Encapsulamiento, Polimorfismos y otros. Contiene varios ejemplos que explican los
mismos.

5. Carlos Alberto Román Zamitiz. Temas Especiales de Computación. disponible en

Internet en: < http://www.fi-b.unam.mx/pp/profesores/carlos/toc.html>. [con
acceso 08-11-2006].

Comentario:

Esta pagina esta contiene un temario que esta dividido en dos partes la primera es:
Análisis y diseño Orientado a objetos en UML y la segunda Programación Orientada A
Objetos con Java, la segunda contiene un extenso temario que entre estos puntos se
encuentra los conceptos de programación orientado a objetos como por ejemplo Clases y
objetos, Mensaje y métodos, Encapsulamiento, Herencia, Superclase y Subclases,
Polimorfismo, Abstracción

5
 6. Moisés Burgos.(1999).Tutoriales. España. documento en línea en:
<http://members.tripod.com/~MoisesRBB/index.htm>[con acceso 07-11-2006].

Comentarios:

Esta pagina contiene tutoriales en línea, así como tutoriales que se pueden bajar e
imprimir para aprender sobre los temas de programación que en la pagina se encuentran
, Entre los temas se encuentra todo sobre Java explican muy bien la programación
orientada a objetos, también explican como se estructura un programa en Java. por fin es
una excelente pagina.

7. Ángel Franco García.(1998).Programación en lenguaje java. Ultima actualización

(enero de 2000). Disponible en Internet
en:<http://www.sc.ehu.es/sbweb/fisica/curso.htm>[con acceso 11-11-2006].

Comentario:

Esta es una pagina muy completa esta dividida en tres partes: Curso Interactivo de Física
en Internet, programación en lenguaje java y procedimientos numéricos en lenguaje java.
En cuando a la parte de programación en lenguaje java contiene aspectos fundamentales
de la Programación Orientada a Objetos como lo son la herencia, la reutilización del
código, el concepto de clase abstracta y su diferencia con el concepto de interfase. El
significado de polimorfismo y de enlace dinámico.

8. Agustín Froufe.(1996-1999).Tutorial de java. última actualización ( lunes, 17 de

Mayo de 1999). Disponible en Internet en:
<http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/index.html>. [con acceso
11-11-2006].

6
Comentario:

Esta pagina es muy interesante contiene un extenso índice referente a java, entre estos se
encuentran, los conceptos básicos de java por ejemplo Clases, Objetos, Constructor,
Control de acceso, Super, Herencia, Subclases, Clases abstractas etc .En cuanto al
concepto de herencia explican muy bien en que consiste la herencia y presenta pequeños
ejemplos para explicar la misma, al igual que el concepto de la Clases abstractas explican
en que consiste este mecanismo y presenta ejemplos del mismo.

9. Berzal.(2005-02-18).Clases Abstractas e Interfases. Ultima actualización(2005-06-

12).disponible en Internet en:

<http://elvex.ugr.es/decsai/java/pdf/AC-interfaces.pdf>[con acceso el 11-11-2006].

Comentario:

Este pdf explica muy bien lo que Clases Abstractas, cuando es una clase abstracta,
cuando se utilizan las Clases Abstractas, presenta definiciones fáciles de entender,
ejemplos en UML y ejemplos codificados en lenguaje java que ,también contiene la
definición de interfase y varios ejemplos y varios ejemplos para explicar la definición de
interfase. Este pdf no permite modificar el contenido ni hacer copia del mismo, solo es
para lectura.

10. Muller ,P.; Globewide. Actualizado en Agosto 31, 1997.[Documento en

línea].Programación orientada a objeto, Network Academy (GNA). Disponible
desde Internet en : <http://www.gnacademy.org/text/cc/Tutorial/Spanish>.[con
acceso el 8-11-2006 ]

Comentario:
Esta pagina se trata de las principales características de la programación orientada a
objetos en la que esta muy íntimamente ligada la herencia en la que nosotros podemos
forzar a una subclase para que ofrezca las mismas propiedades de sus superclases,
Jerarquía, clases abstractas, sobrecarga.

7
 GLOSARIO DE TÉRMINOS
 Clase
Una clase define datos y métodos y es una unidad de organización de un programa Java.
Puede traspasar sus datos y métodos públicos a sus subclases. Unidad fundamental de
programación en Java. Contiene métodos y proporcionan la estructura para los objetos.

 Herencia:

Es la característica por la cual los objetos para su creación se basan en una clase de base,
heredando todas sus propiedades, métodos y atributos; los cuales a su vez pueden o no ser
implementados y/o modificados. En Java, sólo existe herencia simple.

 Extends :

La palabra estends es una palabra clave que se utiliza para indicar que una Subclase esta
heredando métodos y atributos de una Superclase.

 Super:

La palabra Super es una palabra clave que se utilaza para hacer referencia a la clase
principal o Superclase.

 Polimorfismo:

Las mismas raíces de la palabra pueden ser una fuerte pista de su significado: Poli =
Múltiple, morfismo = Formas. 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.

 Sobrecarga de Métodos:

La sobrecarga de métodos consiste en declarar métodos con el mismo nombre que son
diferenciados por los parámetros que reciben o que retornan. De esta forma no es

8
necesario declarar un método con distinto nombre para métodos similares en los que
solamente cambia el tipo de parámetros que han de utilizar.

 Subclase

Se puede decir que una subclase es aquella que hereda todos los métodos y atributos de
una Superclase.

 Jerarquía

La jerarquía y la herencia están altamente relacionadas ya que una depende de la otra y

viceversa. El mecanismo de al herencia consiste en ordenar las clases de manera que las
super clases estén arriba de las subclases y que las ultimas Subclases ordenadas heredaran
métodos, atributos y todas las características de las Superclase.

 Superclase

La Superclase es aquella de la cual se heredan sus métodos y variables, los mismos se le

heredan a otras clases denominadas Subclases. Una Superclase puede tener un sin
numero de subclases.

 Clases Abstractas

Una clase abstracta es una clase de la que no se puede crear objetos. La utilidad de estas
clases estriba en que otras clases hereden de ésta, por lo que con ello conseguiremos
reutilizar código.

 Abstract

Esta es una palabra clave que se utiliza para declarar una clase como clase abstracta.

 Métodos Abstractos:

Los métodos abstractos son aquellos que no contienen ningún tipo de implementación,
inclusive no se declaran entre llaves sino entre paréntesis.

9
 EJEMPLOS DE LOS CONCEPTOS

(Herencia, Polimorfismo, Clase Abstracta, Sobrecarga)

EJEMPLO DE HERENCIA:
import javax.swing.*;
public class Mujer { Esta es la Superclase
private String sexo; contiene atributos y
public String getsexo() { metodos
return(sexo); }

public Mujer(String sexo) {

this.sexo = sexo;
}
}
Esta es la Subclase hereda
class Senorita extends Mujer {
(extends)los atributos y
private int edad;
métodos de la Superclase,
public Senorita(String sexo) {
contiene un atributo que es
super(sexo);
la edad.
edad=15;
}
public int getedad (){
return(edad);
}
}

import java.text.*; Esta es la clase principal en

import java.lang.String.*; donde se crean las instancias
public class Alicia { de la Superclase y de la
public static void main(String [] args) { subclase y se imprimen los
String mensaje,sexo,color; resultados para observar la
herencia.
Captur Captu = new Captur();
mensaje="indique el sexo de la mujer";
sexo=Captu.Captura(mensaje);

Mujer Abuelita = new Mujer(sexo,color);

Senorita ana = new Senorita(sexo,color);

System.out.println("sexo heredado de la superclase Mujer: "+ana.getsexo());

System.out.println(" atributo edad de la subclase Senorita: "+ana.getedad ());

}
}

10
EJEMPLO DE POLIMORFISMO:

class Cantante{
private String nombre; Se realizara
public void Cantar() Polimorfismo del
{ método Cantar
System.out.println("Yo Canto Mucho La La La La");
}
} // fin Cantante

class Corista extends Cantante{

public void Cantar()

{
System.out.println("Yo Canto muy poco la la");
}
} //fin Corista

class Nino extends Cantante {

public void Cantar()
{
System.out.println("Yo Canto en el parque");
}

} //End Niño

public class Cantando{

// ejemplo de polimorfismo de Metodo Cantar

public static void main(String args[])

{
Cantante Canta = new Cantante();
Corista coro = new Corista();
Nino ninito = new Nino();
System.out.println("----Estamos usando polimorfismo del metodo cantar----");

Canta.Cantar(); // canta un cantante

En este ejemplo se realiza
coro.Cantar(); // canta un corista
polimorfismo del método
ninito.Cantar(); // canta un niño
Cantar, ”nótese que para
}
realizar el polimorfismo se
}
tuvo que realizar la
Herencia”

11
EJEMPLO DE CLASE ABSTRACTA:

import java.util.*; Se a declarado la Clase

Instrumento como clase abstracta,
abstract class Instrumento { cada uno de sus métodos como
public abstract void tocar(); abstractos.(sin codificación)
public abstract void afinar();
}

class Guitarra extends Instrumento {

public void tocar() {
System.out.println("Tocare la guitarra en el concierto"); Se han Heredados los
} métodos abstractos, y
public void afinar() se han implementado
{ (codificados)
System.out.println("Afinare la guitarra para que suene bien");
}
}

public class Musica2 {

public static void main(String[] args) {

//Generar una INSTANCIA de una la Clase Abstracta no es valido

//Instrumento nuevo = new Instrumento();
Guitarra orquesta = new Guitarra();

orquesta.tocar();
orquesta.afinar();
En este ejemplo no se ha generado una instancia de la
} clase abstracta porque no es valido hacerlo.
} Pero si se ha generado una instancia de la subclase
orquesta ya que ella heredo los métodos de la superclase
abstracta.

12
EJEMPLO DE SOBRECARGA:

import java.text.*;
public class Restar {

public static double resta(double a, double b) {

System.out.println("Se restan los numeros reales");
return a-b;
}

public static int resta(int a, int b) {

System.out.println("Se restan los números enteros");
return a-b;
}

public static void main(String[] args) {

double l = 4.5, j = 1.2;
int n = 7, m = 5;
System.out.println(resta(l,j));
System.out.println(resta(n,m));
}
}
En este ejemplo se sobrecarga el metodo resta ya que se
utiliza dos veces el método resta, pero cada ves que se
utiliza el método se le pasan distintos parámetros. En
este ejemplo no es necesario declarar un método con
distinto nombre para restar los números ya sea reales o
enteros. Ya que los métodos son similares solamente
cambia el tipo de parámetros que han de utilizar. nótese
que la sobrecarga se realiza en métodos que pertenecen a
la misma clase

13
 APLICACIÓN DE TODOS LOS CONCEPTOS APRENDIDOS

Superclase Persona es una clases abstracta

import javax.swing.*;
abstract class persona{ //clase abstracta no se puede instanciar

String nombre;
String sexo;
int edad;
// Contiene métodos Abstractos
abstract public float getpromedio ();

abstract public String getnombre();

abstract public String getsexo();

abstract public int getedad();

abstract public void caracteristicas();

}

14
 class Estudiante extends persona { //hereda de la superclase abstracta Persona métodos y
atributos
private int i, cant;
public Estudiante(String nom, String sex, int ed)
{
nombre=nom; //Se asigna valores a los atributos
sexo = sex;
edad= ed;
cant=5;
i=0;
} //implementación de los métodos abstractos
public String getnombre() {
return(nombre); }
public String getsexo(){
return(sexo); }
public int getedad(){ //sobrecarga de el metodo edad
return(edad);
}
public int getedad(int tiempo) //sobrecarga del metodo edad
{
eda=edad+tiempo;
return(eda);
}
public float getpromedio ()
{
float suma=0,prom,nota;
String not;
int k;
for (k=0;k<cant;k++)
{
not=JOptionPane.showInputDialog(null,"indique la nota ");
nota=Float.parseFloat(not);
suma=suma+nota;
}
prom=suma/cant;
return(prom);
}
public void caracteristicas() //se realiza polimorfismo de metodo Característica
{
System.out.println("Los estudiantes son personas
y tienen atributos como:notas ,etc"); }
}

15
class Profesor extends Estudiante //hereda de la subclase Estudiante

{
private int cod1,cod2,cod3;

public Profesor(String nom, String sex,int ed)

{
super(nom,sex,ed);
cod1=1010;
cod2=2020;
cod3=3030;
}

public void Identificar(int codigo)

{
if(codigo==cod1)
System.out.println("El codigo que introdusiste le pertenece
a:Ruben Mendoza, mat:Mantenimiento");

else
if(codigo==cod2)
System.out.println("El codigo que introdujo le pertenece
a: Yajaira Juares, mat:software educ.");

else
if(codigo==cod3)
System.out.println("El codigo que introdujo le pertenece
a:Diego Santimateo,mat:Programacion");

else
System.out.println("El codigo que introdujo no existe,
Vuelva a intentarlo");
}

public void caracteristicas() //se realiza polimorfismo de este metodo

{
System.out.println("Los profesores son personas y tienen
atributos como:codigos de profesor ,etc");
}
}

16
 Clase principal donde se
encuentra el metodo void
import java.text.*; main
import java.lang.String.*;
public class Colegio{
public static void main(String [] args) {
String mensaje,sex,color,nomb,ed,op,cod,timp;
int eda,opc,codi,ti;
do
{
Captur Captu = new Captur();
mensaje="Indique el nombre de la persona";
nomb=Captu.Captura(mensaje);
mensaje="Indique el sexo de la persona";
sex=Captu.Captura(mensaje);
mensaje="Indique la edad de la persona";
ed=Captu.Captura(mensaje);
eda=Integer.parseInt(ed);
//Instanciacion a las Clases
Estudiante Estudi= new Estudiante(nomb,sex,eda);
Profesor profe= new Profesor(nomb,sex,eda);
//Se Llaman a los metodos Heredados
System.out.println("----Tu nombre es: ----"+Estudi.getnombre());
System.out.println("----Tu sexo es: ----"+Estudi.getsexo());
System.out.println("----Tu edad es: ----"+Estudi.getedad());
System.out.println("----Su Promedio es: -----"+Estudi.getpromedio ());
mensaje="Indique cuantos años dura su carrera";
timp=Captu.Captura(mensaje);
ti=Integer.parseInt(timp);
System.out.println("----Cuando termines tu carrera tu edad
será:--- "+Estudi.getedad(ti));
mensaje="Indique el codigo del profesor que desea saber, su nombre y materia";
cod=Captu.Captura(mensaje);
codi=Integer.parseInt(cod);
profe.Identificar(codi);

mensaje="decea continuar si=1 no=0";

op=Captu.Captura(mensaje);
opc=Integer.parseInt(op);
}
while(opc= =1);
}
}

17
 Clase Para Capturar Datos

/*En esta clases se Utiliza un método que es para capturar datos*/

import javax.swing.*;
class Captur
{
public String Captura( String msg)
{
String datos;
datos=JOptionPane.showInputDialog(null,msg);
return datos;
}
}

18
 DESCRIPCIÓN DE LA APLICACIÓN EJECUTABLE

El dominio que elegí para realizar mi aplicación fue un Colegio, Un colegio contiene
profesores, estudiantes, etc.

En Esta Aplicación utilice una clase abstracta (abstract) la cual es la superclase

denominada Persona, la misma contiene métodos abstractos como lo son getpromedio,
getnombre, getedad, getsexo, características. Estos métodos los diseñe para luego
realizarles la debida implementación. Seguidamente elabore una subclase denominada
Estudiante esta clase hereda (extends) los métodos abstractos de la superclase abstracta
Persona.

En esta subclase se le realiza la implementación a los métodos abstractos heredados de la

superclase Persona, elabore la sobrecarga del método getedad de la siguiente manera:
primero utilizo el metodo getedad (sin parámetros) para retornar la edad original de la
persona, pero luego utilizo el metodo getedad le paso un argumento (tiempo que dura la
carrera que desea estudiar) y sumo este tiempo a la edad original y retorno otro valor de
esta manera el metodo es sobrecargado.

De igual manera elabore la subclase Profesor la cual hereda de la clase Estudiante Los
métodos y los atributos. Realice esta clase para elaborar el polimorfismo del método
Característica .Para realizar el Polimorfismo necesitaba heredar los métodos a los
cuales les iba a realizar polimorfismo en este caso el método Característica lo utilice
para realizar diversos mensajes.

Utilicé una clase para capturar (Captur) los datos necesarios para que funcionara mi
aplicación contiene un solo metodo que devuelve valores De tipo String. Y la clase
principal la que contiene el método void main, en esta clase creo las instancias de las
clases y realizo los llamados a lo diversos métodos.

19
 ESPECIFICACIONES UML

Profesor
Codigo
Persona
Nombre
Sexo Void Identificar()
Edad
abstract public String
getnombre()
Estudiante
abstract public float
getpromedio () Nombre
Colegio abstract public String Sexo
getsexo() edad
abstract public int getedad() Promedio
abstract public void
Void main() caracteristicas() public String
getnombre()
public float getpromedio
()
public String getsexo()
public int getedad()
Captur public void
caracteristicas()
String Captura()

20
 CONCLUSIÓN

Con la realización de este trabajo pude aclarar muchas cosas que no tenia claras como lo
era el uso de la herencia, del polimorfismo y clase abstracta. Ahora puedo comprender lo
importante que es el uso de la Herencia ya que permite realizar tantas cosas, que sin ella
habría que realizar un código mas extenso.

En cuanto a la Clase abstracta cambie totalmente mi manera de pensar, porque al

principio sentía que no tenia sentido utilizar una clase abstracta, pero cuando me ilustre
en el concepto pude comprender que es muy importante en el momento en que el
programador se encuentra en la fase de diseño, ya que se piensa en los métodos que se
necesitan , pero no como funcionarán. En fin creo que logre el objetivo previsto .

21