Proyecto 3

Proyecto # 3
Jerarquía y Herencia
Enocjahaziel Carrasco_______________________________________________________
Universidad de Panamá
Centro Regional Universitario de Veraguas
Facultad de Informática, Electrónica y Comunicaciones

Carrera: Licenciatura en Informática Educativa y Empresarial
Trabajo de programación IV
Tema
“Proyecto # 3”
“Jerarquía y Herencia”
Profesor:
Diego Santimateo G.
Integrante:
Enocjahaziel Carrasco 9-726-1139
Fecha:
10 de diciembre
1
Proyecto # 3
Índice
Introducción…………………………………………….……….……...3
Estructura de desarrollo………….……………………………….…. 4
Procedimiento….……………….…….…………………….…….…...5
Fuentes de información…………………….………………………...6
Glosario de términos…………………………..……………………..12
Ejemplificación de conceptos...…………………………………..….15
Aplicación Ejecutable……………………………………….………..19
Código fuente………….………………………………………………21
Diagrama de las clases del programa………………………………24
Aplicación de conceptos en el programa ejecutado……………….25
Diagrama UML…………………………………………………………26
Evidencia de Ejecución ………………………..………..…………...27
Reflexiones ……………………………..……………………………..31
2
Proyecto # 3
INTRODUCCIÓN.
Vigilando, laborando y meditando, todas las cosas prosperan.
Salustio
Después de estar familiarizado con la estructura de un programa Java y

de haber experimentado el enfoque de la Programación Orientada a
Objeto, así como el análisis de sistemas bajo la perspectiva de la
Orientación a Objetos, se nos presenta un trabajo de investigación
completo el cual da como resultado una visión mas amplia de los
conceptos y de la programación orientada a objetos
En este trabajo se presenta un análisis sobre términos utilizados en la

programación orientada a objetos como lo es la herencia, jerarquía,
polimorfismo, etc y fuentes de información de las cuales se extrajo
conceptos importante sobre el tema, también se presenta una web
grafia y definiciones de términos.
Este trabajo cuenta con un glosario, ejemplificación de conceptos,

segmentos de códigos de cada concepto.
Para finalizar se desarrolla una aplicación (ejecutable) debidamente

documentada, donde se hace uso del contenido de la investigación,
cuyo objetivo se basa en dar solución a un tema Calcular la nota literal
de un estudiante.
3
Proyecto # 3
Estructura de Desarrollo
Lo primero que realice en este proyecto fue el análisis de los conceptos

involucrados.
Esto fue algo difícil para mí por que no había tenido antes que hacer
una Web grafía sobre una pagina de Internet analizada.
Después de leer, analizar y comentar sobre la pagina visitada se realizo

el glosario de términos y su respectiva ejemplificación de cada concepto,
una vez terminada esta etapa se procedió a buscar y un código el cual
se aplicara cada termino, en mi caso utilice un código que el profesor
había puesto como laboratorio el cual se modifico para así lograr con la
definición de algunos conceptos investigados.
En la etapa final del proyecto se coloco el diagrama de clases,

aplicación de conceptos en el programa, Diagrama UML, la ejecución del
Programa y la evaluación individual de la experiencia
4
Proyecto # 3
5
Proyecto # 3
Procedimiento
Este laboratorio consiste en analizar los conceptos involucrados

con la Jerarquía en Java, para ello el o la estudiante debe tomar como
punto de partida de su investigación los siguientes temas: Jerarquía,
Interfaz, Herencia, Clase Abstracta, Super Clase, Polimorfismo y Sobrecarga.
En una primera fase se deben establecer por lo menos diez fuentes de

información y comentarlas, así como presentarlas en un formato
reconocido internacionalmente o estándar
Posteriormente se concretará un glosario de términos debidamente

definidos, destacando la interpretación que el o la estudiante concibe de
los mismos.
Seguidamente se procederá a ejemplificar cada concepto bajo un

dominio conocido o previamente experimentado. No olvide explicar su
ejemplo.
Finalmente se presentará una aplicación (ejecutable) debidamente

documentada, seleccionada por el o la estudiante donde se hace uso de
los conceptos analizados, para la solución de un problema científico o de
la realidad nacional o institucional.
Cada estudiante debe presentar una propuesta de su aplicación apoyada

en especificaciones UML.
6
Proyecto # 3
7
Proyecto # 3
JERARQUÍA
---------------------------------------------------------------------------------------------------------
La jerarquía de las clases. La herencia y el polimorfismo.

Curso de Lenguaje Java: Enero de 2000
Procedimientos Numéricos en Lenguaje Java: Diciembre de 2001
http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/here
ncia/herencia1.htm <con acceso 17/11/2008>
----------------------------------------------------------------------
En su primera parte trata sobre la jerarquía de las clases, sobre las

figuras planas en donde nos muestra características comunes como la
posición de la figura, de su centro, y el área de la figura aunque el
procedimiento para calcular dicha área sea completamente distinta.
En el documento nos presenta un interesante ejemplo acerca del juego
de ajedrez y la relación con la abstracción.
También presenta ejemplos los cuales cuentan con las clases rectángulo
y circulo en donde las clases derivadas heredan los miembros dato x e y
de la clase base, y definen la función área, entrando en términos como
enlaces dinámicos y polimorfismo.
-------------------------------------------------------------------------------------------------------------------------------
Introducción a Java. Ángel kuri. Enero 2005

http://cursos.itam.mx/akuri/2006/Algor%EDtmica/0Introduccion.
pdf. Con acceso el 20/11/2008
------------------------------------------------------------------------------------------------------------------------------
El documento PDF presentado en esta dirección no muestra una

introducción de las características básicas de Java, presenta en su
pagina 13 , La programación orientada a objetos , donde nos presenta
los objetos , clases, atributos, comportamiento y la manera de crear
métodos , en su pagina 31 nos introduce con el termino herencia y en su
siguiente pagina la jerarquía de las clases , donde presenta un pequeño
cuadro donde nos muestra la jerarquía de las clases con un ejemplo de
motores y como se heredan atributos.
8
Proyecto # 3
**********************************************************************
INTERFACES
------------------------------------------------------------------------------------------------------------
Tutorial de java technology .Turotial de java. Interface.By

Agustín Froufe .Ultima Actualización: lunes, 17 de Mayo de
1999 .
http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parte5/cap
5-12.html <con acceso 18/11/2008>
------------------------------------------------------------------------------------------------------------------------------------
Esta dirección nos muestra la relación entre herencia y un interfaz, en

donde nos dice que el aspecto más importante del uso de interfaces es
que múltiples objetos de clases diferentes pueden ser tratados como si
fuesen de un mismo tipo común, donde este tipo viene indicado por el
nombre del interfaz.
*************************************************************************
HERENCIA
--------------------------------------------------------------------------------------------------------
Wikipedia La enciclopedia Libre. Herencia (programación

orientada a objetos). Contenido disponible bajo los términos
de la Licencia de documentación libre de GNU. Esta página fue
modificada por última vez el 18:07, 12 nov 2008. Consulta 18
de noviembre 2008
http://es.wikipedia.org/wiki/Herencia_(programaci%C3%B3n_orie
ntada_a_objetos)
----------------------------------------------------------------------------------------------------------
Esta dirección es muy completa y explica con ejemplos reales y

situaciones en la cual podemos apreciar la definición de este concepto.
9
Proyecto # 3
También cuenta con códigos fáciles de interpretar, en este código se
declaran las clases mamíferos, gato y perro, haciendo que gato y perro
sean unos mamíferos (derivados de esta clase), y se ve como a través
de ellos se nombra al animal pero así también se accede a patas
dándole el valor por defecto para esa especie. Es ultima parte nos define
acerca de los tipos de herencia que existen como herencia simple y
herencia múltiple.
-------------------------------------------------------------------------------------------------------------------------------
Luís Gonzaga Pérez Gordon. Tema 7 -Herencia. Informática

aplicada. Documento de tipo PDF. <con acceso el 18/ 11/2008 >
http://wwwdi.ujaen.es/~lgonzaga/informaticaaplicada/Tema7-
Herencia.pdf
------------------------------------------------------------------------------------------------------------------------------
La dirección, nos facilita una diapositivas en las cuales tienen conceptos

de herencia, ventajas y situaciones en las cuales se aplica la herencia,
así como también ejemplos UML que explican el termino Super Clase los
cueles tienen segmentos de códigos que nos habla de las herencias y
de como la subclase hereda atributos de la superclases, nos presentan
en sus presentación final ejemplos con interfaces.
************************************************************************************
POLIMORFISMO
Wikipedia La enciclopedia Libre. Polimorfismo (programación

orientada a objetos). Contenido disponible bajo los términos
de la Licencia de documentación libre de GNU. Esta página fue
modificada por última vez el 17:30, 29 oct 2008. Consulta 19
de noviembre 2008.
http://es.wikipedia.org/wiki/Polimorfismo_(programaci%C3%B3n_
orientada_a_objetos)
----------------------------------------------------------------------
En esta dirección tenemos una definición de polimorfismo con una

perspectiva en cuanto a las clases y subclases, nos explica la
clasificación del polimorfismo .nos presenta un pequeño código que
presentan las clases Sumar y Restar implementan la interfaz pero el
método de la interfaz lo declaramos privado para evitar ser accedido
libremente y además tienen un método llamado Calcular que llama a la
clase Operación donde tenemos otro método con el mismo nombre. Es
esta clase última la que realiza el polimorfismo y debe fijarse como es a
través de una instancia de la interfaz que llama al método operar.
10
Proyecto # 3
**********************************************************************
CLASE ABSTRACTA
----------------------------------------------------------------------------------------------------------
Zator Systems. Tecnología de la información para el
conocimiento.
A. J. Millán ajm@zator.com
Versión 1.108.5 Última actualización:14-08-2008. Curso
c++. 4.11.8c Clases abstractas
http://www.zator.es/Cpp/E4_11_8c.htm con acceso el

19/11/2008
----------------------------------------------------------------------------------------------------------
En la dirección citada nos presenta una sinopsis de la abstracción donde

nos proyecta a ver que la abstracción es un recurso de la mente , los
lenguajes de programación permiten expresar la solución de un
problema de forma comprensible simultáneamente por la máquina y el
humano. Constituyen un puente entre la abstracción de la mente y una
serie de instrucciones ejecutables por un dispositivo electrónico. Por otro
lado nos muestra la clase abstracta y las reglas de su uso con sus
códigos de ejemplos.
**********************************************************************
SOBRECARGA
--------------------------------------------------------------------------------------------------------------
Toni Pizà 2005. Diario de un aprendiz. Ultima actualización:
mayo 2005. Palestina
< http://aprendiendojava.blogspot.com/2005/05/sobrecarga-de-
mtodos-y-de.html> accesado [19-11-2008]
------------------------------------------------------------------------------------------------------------------------------------------------------------------
La dirección citada nos proporciona información acerca de la sobrecarga

del constructor como la de los métodos, nos muestra un ejemplo sencillo
con datos de una empresa que tiene una clase clientes con su nombre,
11
Proyecto # 3
su edad y el nombre de la empresa como variables. En otro lado nos
presenta la cara de la sobrecarga de métodos y lo explica con un
ejemplo que utiliza para sumar dos (2) numero cualesquiera pero
teniendo en cuenta si son entero o con decimales.
---------------------------------------------------------------------------------------------------------------------------------------------------------------
Constructores y sobrecarga en java. Publicado por Santi

.11/04/07 .
http://codigomaldito.blogspot.com/2007/11/constructores-y-
sobrecarga-en-java.html con acceso el 20 / 11 / 20008
--------------------------------------------------------------------------------------------------------------------------------------------------------------
Esta dirección no muestra una definición de constructores y la manera

en puede haber sobrecarga, esta pagina nos explica por medios de
códigos de programas donde muestra de manera clara la sobrecarga
---------------------------------------------------------------------------------------------------------
SUPER CLASE
----------------------------------------------------------------------------------------------------------
miliuco. Sitio expuesto desde hace: 6 años y 10 días
Ultima modificación: 1 de noviembre de 2008
http://www.miliuco.net/java/super.htm con acceso el
20/11/2008
----------------------------------------------------------------------
En la dirección mencionada nos habla sobre la variable especial super

que refiere a la superclase de la clase actual. Nos presenta la manera en
que se debe utilizar Super . Nos explica que Super también permite
sobrescribir un método de la superclase añadiéndole nuevas
funcionalidades y cuenta con códigos fáciles de interpretar
**********************************************************************
12
Proyecto # 3
13
Proyecto # 3
14
Proyecto # 3
GLOSARIO:
Glosario de términos definidos destacando la interpretación del

estudiante concibe de los mismos.
1. Abstracción: La abstracción consiste en captar las características

esenciales de un objeto, así como su comportamiento.
2. Clase Abstracta: Una clase abstracta es una agrupación de

datos (variables o campos) y de funciones (métodos) que operan
sobre datos que permiten que otras clases deriven de ella,
proporcionándoles un marco o modelo que deben seguir y algunos
métodos de utilidad general.
3. Encapsulamiento: consiste en unir en la Clase las características

y comportamientos, esto es, las variables y métodos. Es tener todo
esto es una sola entidad.
4. Herencia: Es una propiedad que permite que los objetos sean

creados a partir de otros ya existentes, obteniendo características
(métodos y atributos) similares a los ya existentes.
5. Interfaz: proporcionan un mecanismo para abstraer los métodos a

un nivel superior, lo que permite simular la herencia múltiple de
otros lenguajes. Un interfaz podrá verse simplemente como una
forma, es como un molde, solamente permite declarar nombres de
métodos, listas de argumentos, tipos de retorno y adicionalmente
miembros datos.
6. Jerarquía: Entendemos por jerarquía un mecanismo que nos

permite relacionar una clase padre o superclase, con las demás
clases hijas o subclases, de forma jerárquica.
7. Polimorfismo: implementa con la sobrecarga de métodos,

permite a los programadores separar las cosas que cambian de las
que no cambian, y de esta manera hacer más fácil la reutilización
de los programas.
8. Sobrecarga: Permite sobrecargar operadores para utilizarlos en

clases propias. Creamos varios métodos con el mismo nombre que
actúen diferente según el tipo de los parámetros de entrada.
9. Subclases: heredan el estado y el comportamiento en forma de

las variables y los métodos de su superclase. La subclase puede
15
Proyecto # 3
utilizar los ítems heredados de su superclase tal y como son, o
puede modificarlos o sobrescribirlos.
10. Súper Clase: Una superclase es la clase Padre, de la cual se

derivan otras clases que automáticamente heredan todas sus
características y comportamientos.
11. This: Es una palabra reservada que permite especificar que la

variable que señala es de la misma clase en la que se usa.
también vale para sustituir a sus constructores, utilizándola como
método.
12. Super: La palabra reservada super sirve para indicar que una
variable o un método es de la superclase y que en ese momento
estamos accediendo a él.
13. Extends: Al obtener una clase de una clase base se utiliza la

palabra (Extends), nos indica que una clase es derivada de otra.
16
Proyecto # 3
Ejemplificación de concepto
En esta sección mostramos la ejemplificación de los conceptos

previamente definidos e investigados a lo largo del proyecto, para una
mejor comprensión y análisis del contenido.
Sobrecarga: En la sobrecarga de métodos, creamos varios métodos con el

mismo nombre que actúen diferente según el tipo de los parámetros de
entrada. Por ejemplo, queremos hacer un método que devuelva el
resultado de la suma de los dos parámetros de entrada, pero no
sabemos si será un entero o si tendrá decimales, así que tendremos que
hacer un método para el caso de los decimales, y otro con el mismo
nombre para el caso de los enteros.
class Calculadora {
int suma(int x, int y) {
return (x + y);
}
float suma(float x, float y) {

return (x + y);
}
}
class Servo {
public static void main(String[] args) {
int operacion1;
float operacion2;
Calculadora sumador = new Calculadora();

operacion1 = sumador. suma(2,3);
operacion2 = sumador. suma(0.23F, 12.53F);
System.out.println("La suma de los enteros 2 y 3 es " + operacion1);

System.out.println("Sumando 0.23 y 12.53, se consigue " + operacion2);
}
}
Como observamos se hizo una sobre carga en el método suma. EL

cual al momento del llamado el constructor tendrá la responsabilidad
de asignar el método según sea los parámetros de entrada.
17
Proyecto # 3
Un interfaz puede extender otros interfaces. Sin embargo, mientras que

una clase solamente puede extender otra clase, un interfaz puede
extender cualquier número de interfaces. En el ejemplo se muestra la
definición completa de un interfaz, declaración y cuerpo.
Codigo de interface.
public interface MiInterfaz extends InterfazA,InterfazB {
public final double PI = 3.14159;
public final int entero = 125;
void put( int dato );
int get();
}
Herencia: Como habíamos mencionado anteriormente la herencia es una

propiedad que permite que los objetos sean creados a partir de otros ya
existentes, obteniendo características (métodos y atributos) similares a
los ya existentes.
18
Proyecto # 3
En la figura se especifica que Auto y Camión heredan de Vehículo, es
decir, Auto posee las Características de Vehículo (Precio, VelMax, etc)
además posee algo particular que es Descapotable, en cambio Camión
también hereda las características de Vehiculo (Precio, VelMax, etc) pero
posee como particularidad propia Acoplado, Tara y Carga.
*************************************************************************
*************************************************************************
JERARQUIA
En el ejemplo podemos ver como
Padre la SuperClase E hijas se convierte en la subclase
Class Padre
SuperClase
SubClase o
clase hija
Class Hijas
import java.lang.String.*;
import javax.swing.*; De esta clase se crea
otra clase que reúne las
class Padre{
private int cant; // variables de instancias
características de Padre
private double numero; y además añade otra
private int notas[]; característica que la
private String datos;
public Padre (){ identifica
}
public Padre (int nts[]){
Captura_despliega obj = new Captura_despliega();
this.cant = nts.length;
this.notas= new int [cant];
for (int i=0;i<nts.length;i++)
//proceso para asignar cada nota al objeto nuevo.
{
notas[i] = nts[i];
System.out.println("\nNota :"+notas[i]);
}
}
/*--------------------------------------------*/
public double calcula_promedio(){ // método utilizado para calcular el promedio
int sum = this.notas[0];
for (int i=1;i<this.cant;i++)
19
Proyecto # 3
{
sum = sum + notas[i];
}
this.numero = this.cant * 100;
double ss= sum;
double prom = ((ss/numero)*100);
return(prom);
}
}
/*------------------------------------------*/
class hijas extends Padre {

/* ejemplo de uso de herencia con constructor en la clase Padre */
private String nota;
public hijas (int nts[]){
super(nts); // invoca al constructor Padre
}
public double calcula_promedio(){ // método para calcular la nota Literal

double not = super.calcula_promedio();
if (not > 90.0){
nota = "A";
}
Polimorfismo, Superclase,
else
if (not > 80 ){ Subclase
nota = "B";
}
else En este segmento de programa
if (not > 70 ){
nota = "C"; podemos ver la creación de
} la subclase “hijas” la cual
else es hereda los atributos de
if(not > 61) la clase padre la cual en
nota = "D";
este caso es “Padre”
else
nota = "F"; mediante extends
return (not); class hijas extends Padre {
} private String nota;
public String literal() public hijas (int nts[]){
{ super(nts); //invoca al
return(nota); constructor Padre
} }
} .También se puede apreciar
el polimorfismo del método
que calcula el promedio
20
Proyecto # 3
21
Proyecto # 3
APLICACIÓN EJECUTABLE.
A continuación presentamos una breve y precisa descripción del dominio

y las clases que constituyen la aplicación ejecutable creada con el fin de
aplicar y utilizar los conceptos previamente explicados e investigados
Descripción del Dominio y de las Clases Utilizadas
Calcular notas literales:

El dominio de esta aplicación esta basado en un
Calcular notas literales de un estudiante, existe una clase
Dominio llamada Padre que cuenta con métodos y una subclase
llamada hijas la cual es capaz de calcular las notas de
un estudiante. También realiza la operación de sacar un
porcentaje de las notas del estudiante y sacarlas en
forma literal es decir A, B, C, D o F.
Padre: Esta es la Superclase de la aplicación, constituye

SuperClase la clase padre de la cual las clases hijas heredan todos
sus atributos y métodos. Entre los métodos con que
cuenta están: calcula_promedio();
Hijas: Esta es una Subclases Hijas que heredan de la
SuperClase todos sus métodos y atributos abstractos y
no abstractos.
Subclases: Dentro de las subclases se hacen llamados a métodos no
abstractos de la Superclase Padre como lo es
Calcula_promedio(), accedemos a este método mediante
la palabra reservada super.
Aquí entran en función Clases como:
Captura_despliega: Es la encargada de capturar y
Otras desplegar en pantalla los mensajes necesarios del
Clases programa. En esta clase se puede apreciar la
encapsulación.
NotaLiteral: Es la clase que contiene el Main del
programa, la cual encapsula los mensajes de entrada y
salida; hace el llamado a la clase y subclases de padre.
22
Proyecto # 3
CÓDIGO FUENTE
Se presenta en esta sección el código fuente de la aplicación ejecutable,

el código esta debidamente documentado.
Main Class NotaLiteral

--------------------------------------------------------------------------------------------------------------
import javax.swing.*;
class NotaLiteral{
public static void main(String[] args) {
Captura_despliega obj = new Captura_despliega( )
;//crea un ob jet o de tipo Captur a_d espli ega
int[] not = obj.Cant_notas( );
// in voca al mé tod o Cant _nota s e l cual capt ur a la can tidad de notas y las notas del
es tudian te
hijas est= new hijas(not);// obj et os d e ti po hi ja s
double por = est.calcula_promedio( );
// In voca al m ét odo qu e so brecar ga al de la clas e Padre
String datos = est.literal( );
// In voca el mé todo ‘l it er al ( )' qu e s e e ncue ntr a en capsulad o en Captur a despli ega
obj.despliega(por,datos); // in voca al m ét od o encap sulad o e n
Capt ur a_despli ega
}
}
--------------------------------------------------------------------------------------------------------------
Class Captura_Despliega
import java.io.*;
class Captura_despliega {
public Captura_despliega(){ //Co ns tr uct or
}
public int [] Cant_notas(){

// mé tod o p ara cap tu ra r l a can ti dad d e nota s y la s not as d el e stud ia nte
23
Proyecto # 3
String k = JOptionPane.showInputDialog("Introduzca la cantidad de
notas");
int s= Integer.parseInt(k);
int [] not=new int[s];//Cr ea vec tor
for (int i=0 ;i<s;i++)

{
String cant = JOptionPane.showInputDialog(" Introduzca la nota");
int n = Integer.parseInt(cant);
if (n <=100 ) // if Para comprob ar qu e la no ta no s obr ep as e
la pu nt uac ió n m áx im a en e ste cas o 1 00
{
not[i] = n;
}
else
{
JOptionPane.showMessageDialog(null,"ERROR al introducir su
nota","Programa de herencia",JOptionPane.ERROR_MESSAGE );
// Me ns aj e a l us ua ri o par a q ue i nt roduzc a su not a n uev am en te
i--;
// ut il izad a par a q ue l a pos ic ió n de l vect or no au me nte. y se pue da capt ur ar l a not a
}
}
return(not);
}
public void despliega(double por,String datos){

// Mé todo ut il izad o par a de sp le ga r en pa nt al la el porce nt aj e de l as cal ific aci on es
capt ur ada s y des pl eg ar l as nota s l iter al es
System.out.println("******** --------- *********");
System.out.println("\n Porcentaje de las calificaciones: "+ por);
System.out.println("Nota literal: " + datos);
}
}
--------------------------------------------------------------------------------------------------------------
Class Padre
import java.lang.String.*;
class Padre{
private int cant; // vari abl es d e i ns tanc ia s
private double numero;
private int notas[];
private String datos;
public Padre (){
}
public Padre (int nts[]){
Captura_despliega obj = new Captura_despliega();
this.cant = nts.length; // a si gn a ca nt id ad de not as a l a vari ab le
can t
this.notas= new int [cant];
for (int i=0;i<nts.length;i++)
24
Proyecto # 3
//proce so pa ra as ig na r cada not a al ob jeto nu evo.
{
notas[i] = nts[i]; //a si gn a la s not as a l vect or d e
not as
System.out.println("\nNota :"+notas[i]);
}
}
/*--------------------------------------------*/
public double calcula_promedio(){ // mé tod o u ti liz ado pa ra cal cul ar e l
prome di o
int sum = this.notas[0];
for (int i=1;i<this.cant;i++)
{
sum = sum + notas[i];
}
this.numero = this.cant * 100;
double ss= sum;
double prom = ((ss/numero)*100);
return(prom);
}
} fin de la Superclase Padre
/*------------------------------------------*/
/*Clase Hija que hereda métodos de la Superclase Padre*/
class hijas extends Padre { // cre aci ón de S ubcl as e h ij a

/* E je mpl o de u so de he re nc ia co n co ns tr uct or en la cl as e pad re */
private String nota;
public hijas (int nts[]){
super(nts); // inv oca a l con st ruc tor Padr e
}
public double calcula_promedio(){ // mé todo par a ca lcu la r la no ta L it era l

double not = super.calcula_promedio();
if (not > 90.0){
nota = "A";
}
else
if (not > 80 ){
nota = "B";
}
else
if (not > 70 ){
nota = "C";
}
else
if(not > 61)
nota = "D";
else
nota = "F";
return (not);
}
public String literal() // mé tod o p ara r et orn ar l a not a l itera l
{
return(nota);
} // fin de mé todo
} // Fin de la subclase
25
Proyecto # 3
DIAGRAMA DE LAS CLASES DEL PROGRAMA
Clase
NOTA LITERAL main
SuperClase o
clase Padre Clase
auxiliar
CAPTURA
CLASE PADRE
DESPLIEGA
Subclase o
clase hija
SUBCLASE HIJAS
26
Proyecto # 3
APLICACIÓN DE CONCEPTOS EN EL PROGRAMA DESARROLLADO
Concepto Clase en la que aplico Descripción

Jerarquia – Herencia Clase NotaLiteral
Clase Padre Se aplica la herencia y
Clase hijas jerarquia en la Superclase
Padre, y las clase hijas, estas
heredan aquellos métodos que
tiene la clase Padre. En la
clase auxiliar Nota Literal
Hace el llamado a la Clase
Padre y esta a su vez contiene
a La subclase hija
Superclase Padre La Superclase Padre es de la
cual heredan sus atributos
mediante la asignación de la
palabra reservada extends.
Ejemplo: Class hijas
extends Padre.
Subclases Hijas Son las clases hijas las cuales
heredan métodos de la
SuperClase Padre, esta
subclase utiliza un método de
la Superclase por medio de
Super.
Polimorfismo Calcula Promedio El polimorfismo se presenta en

la clase hijas debido a que
presentan métodos con los
mismos nombres y tipo de
argumentos, objetos que
realizan una implementación
27
Proyecto # 3
específica, utilizando los
mismos nombres de métodos.
En este caso el polimorfismo
se presenta con el método
Calcular_promedio el cual lo
utiliza la Clase Padre y la
subclase hijas
.
Encapsulacion Captura En esta clase se presenta
despliega la encapsulacion ya que
todas las características,
comportamientos, variables
y métodos están en una
sola entidad.
DIAGRAMA UML DE LA APLICACIÓN
Class NotaLiteral
MAIN
Class
Class Padre Captura_despliega
Double calcula_promedio();
int [] Cant_notas();
void despliega(double
por,String datos);
void error();
Class Hija extends
Padre
Double calcula_promedio();
String Literal();
28
Proyecto # 3
29
Proyecto # 3
30
Proyecto # 3
Primera Prueba de Ejecución del Programa
Cantidad de
notas que el
usuario desea
introducir
Primera Segunda
nota nota
introducida introducida
Tercera nota Cuarta nota

introducida introducida
Prueba de ejecuci
donde muestra las notas
introducidas, porcentaje
de calificaci y la nota
literal.
Segunda Prueba de Ejecución
Cantidad de
notas que el
usuario desea
introducir
Primera nota Nota introducida,
introducida la cual excede la
nota m 痊 ima
Mensaje de error
por haber
introducido una
31 nota con un valor
incorrecto
Proyecto # 3
Mensaje que muestra para

que el usuario introduzca
la nota nuevamente
Muestra las
notas, porcentajes
y la nota literal
Tercera Prueba de Ejecución
32
Proyecto # 3
Reflexiones individuales.
¿Cuál fue la parte más difícil y por qué?
La parte más difícil fue la aplicación ejecutable del programa, ya que

como no quise copiar y pegar un programa de Internet, opte por la
opción de modificar un programa de los laboratorios para que contara
con las especificaciones de los conceptos buscados.
¿Qué nuevos conocimientos se lograron?

Se lograron nuevos conocimientos en cuanto a los conceptos buscados,
fuentes de información con Webgrafía, y la implementación de
subclases.
¿Qué conocimientos previos fueron esenciales?

Fue esencial el conocimiento del formato reconocido internacionalmente
o estándar para la realización de la Web-grafía así como el conocimiento
acerca de UML tanto de Miguel Avían como de Patricio Salinas Caro y
Nancy Histchfeld k. investigados anteriormente.
¿Qué importancia tiene para su formación profesional?

Poder dar buen uso de las fuentes de información, conceptos básicos de
la programación orientada a objetos, además de reconoces situaciones
en la cual podría aplicar, conocimientos adquiridos tanto en las
practicas como en teorías.
¿Qué utilidad tiene el trabajo realizado?

Tiene como utilidad mayor capacidad de plasmar ideas, experiencias de
una manera más eficaz en el entorno de la programación; utilizando
técnicas orientada a objetos, métodos orientado a objetos, en
situaciones que se pueden presentar en la vida real, siendo capaz de
implementarlo en la vida real.
33

Proyecto 3

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Proyecto 3

Uploaded by

Copyright:

Available Formats

Proyecto # 3

Facultad de Informática, Electrónica y Comunicaciones

Enocjahaziel Carrasco 9-726-1139

Diagrama de las clases del programa………………………………24

Aplicación de conceptos en el programa ejecutado……………….25

Evidencia de Ejecución ………………………..………..…………...27

Vigilando, laborando y meditando, todas las cosas prosperan.

Después de estar familiarizado con la estructura de un programa Java y

En este trabajo se presenta un análisis sobre términos utilizados en la

Este trabajo cuenta con un glosario, ejemplificación de conceptos,

Para finalizar se desarrolla una aplicación (ejecutable) debidamente

Lo primero que realice en este proyecto fue el análisis de los conceptos

Después de leer, analizar y comentar sobre la pagina visitada se realizo

En la etapa final del proyecto se coloco el diagrama de clases,

Este laboratorio consiste en analizar los conceptos involucrados

En una primera fase se deben establecer por lo menos diez fuentes de

Posteriormente se concretará un glosario de términos debidamente

Seguidamente se procederá a ejemplificar cada concepto bajo un

Finalmente se presentará una aplicación (ejecutable) debidamente

Cada estudiante debe presentar una propuesta de su aplicación apoyada

La jerarquía de las clases. La herencia y el polimorfismo.

En su primera parte trata sobre la jerarquía de las clases, sobre las

Introducción a Java. Ángel kuri. Enero 2005

El documento PDF presentado en esta dirección no muestra una

Tutorial de java technology .Turotial de java. Interface.By

Esta dirección nos muestra la relación entre herencia y un interfaz, en

Wikipedia La enciclopedia Libre. Herencia (programación

Esta dirección es muy completa y explica con ejemplos reales y

Luís Gonzaga Pérez Gordon. Tema 7 -Herencia. Informática

La dirección, nos facilita una diapositivas en las cuales tienen conceptos

Wikipedia La enciclopedia Libre. Polimorfismo (programación

En esta dirección tenemos una definición de polimorfismo con una

http://www.zator.es/Cpp/E4_11_8c.htm con acceso el

En la dirección citada nos presenta una sinopsis de la abstracción donde

La dirección citada nos proporciona información acerca de la sobrecarga

Constructores y sobrecarga en java. Publicado por Santi

Esta dirección no muestra una definición de constructores y la manera

En la dirección mencionada nos habla sobre la variable especial super

Glosario de términos definidos destacando la interpretación del

1. Abstracción: La abstracción consiste en captar las características

2. Clase Abstracta: Una clase abstracta es una agrupación de

3. Encapsulamiento: consiste en unir en la Clase las características

4. Herencia: Es una propiedad que permite que los objetos sean

5. Interfaz: proporcionan un mecanismo para abstraer los métodos a

6. Jerarquía: Entendemos por jerarquía un mecanismo que nos

7. Polimorfismo: implementa con la sobrecarga de métodos,

8. Sobrecarga: Permite sobrecargar operadores para utilizarlos en

9. Subclases: heredan el estado y el comportamiento en forma de

10. Súper Clase: Una superclase es la clase Padre, de la cual se

11. This: Es una palabra reservada que permite especificar que la

13. Extends: Al obtener una clase de una clase base se utiliza la

En esta sección mostramos la ejemplificación de los conceptos

Sobrecarga: En la sobrecarga de métodos, creamos varios métodos con el

float suma(float x, float y) {

Calculadora sumador = new Calculadora();

System.out.println("La suma de los enteros 2 y 3 es " + operacion1);

Como observamos se hizo una sobre carga en el método suma. EL

Un interfaz puede extender otros interfaces. Sin embargo, mientras que

Herencia: Como habíamos mencionado anteriormente la herencia es una

class hijas extends Padre {

public double calcula_promedio(){ // método para calcular la nota Literal

A continuación presentamos una breve y precisa descripción del dominio

Descripción del Dominio y de las Clases Utilizadas

Calcular notas literales: