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 Fecha: 10 de diciembre

1

9-726-1139

Proyecto # 3 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________ Í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 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________

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 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________

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 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________

5

Proyecto # 3 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________

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 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________

7

Proyecto # 3 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________

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 ----------------------------------------------------------------------

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 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________ **********************************************************************

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 ------------------------------------------------------------------------------------------------------------------------------------

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 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________ 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. http://wwwdi.ujaen.es/~lgonzaga/informaticaaplicada/Tema7Herencia.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 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________ **********************************************************************

CLASE ABSTRACTA ---------------------------------------------------------------------------------------------------------Zator Systems. Tecnología de la información para el conocimiento. A. J. Millán [email protected] 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-demtodos-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 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________ 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-ysobrecarga-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 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________

13

Proyecto # 3 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________

14

Proyecto # 3 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________ 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 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________ 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 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________

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 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________

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 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________ 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 características de Padre y además añade otra característica que la identifica

class Padre{ private int cant; // variables de instancias 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; this.notas= new int [cant]; for (int i=0;i
19

Proyecto # 3 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________ { 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 Subclase if (not > 80 ){ nota = "B"; } else En este segmento de programa if (not > 70 ){ podemos ver la creación de nota = "C"; 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 mediante extends nota = "F"; class hijas extends Padre { return (not); private String nota; } public hijas (int nts[]){ public String literal() super(nts); //invoca al { constructor Padre return(nota); } } .También se puede apreciar }

el polimorfismo del método que calcula el promedio

20

Proyecto # 3 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________

21

Proyecto # 3 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________

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

Dominio

SuperClase

Subclases:

Otras Clases

22

Calcular notas literales: El dominio de esta aplicación esta basado en un Calcular notas literales de un estudiante, existe una clase 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 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. 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 desplegar en pantalla los mensajes necesarios del 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.

Proyecto # 3 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________

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 javax.swing.*; 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 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________ String k = notas");

JOptionPane.showInputDialog("Introduzca la cantidad de 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.*; import javax.swing.*; 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
24

Proyecto # 3 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________ //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
} 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 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________

DIAGRAMA DE LAS CLASES DEL PROGRAMA

NOTA LITERAL

Clase main

SuperClase o clase Padre

Clase auxiliar

CAPTURA DESPLIEGA

CLASE PADRE

SUBCLASE HIJAS

26

Subclase o clase hija

Proyecto # 3 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________

APLICACIÓN DE CONCEPTOS EN EL PROGRAMA DESARROLLADO

Concepto Jerarquia – Herencia

Clase en la que aplico Descripción Clase NotaLiteral Se aplica la herencia y Clase Padre jerarquia en la Superclase Clase hijas

Superclase

Padre

Subclases

Hijas

Polimorfismo

Calcula Promedio

27

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 La Superclase Padre es de la cual heredan sus atributos mediante la asignación de la palabra reservada extends. Ejemplo: Class hijas extends Padre. 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. 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

Proyecto # 3 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________ 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 .

Captura despliega

Encapsulacion

En esta clase se presenta 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 Padre Double calcula_promedio();

Class Hija extends Padre Double calcula_promedio();

String Literal();

28

Class Captura_despliega int [] Cant_notas(); void despliega(double por,String datos); void error();

Proyecto # 3 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________

29

Proyecto # 3 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________

30

Proyecto # 3 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________ Primera Prueba de Ejecución del Programa Cantidad de notas que el usuario desea introducir Primera nota introducida

Tercera nota introducida

Segunda nota introducida

Cuarta nota 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 introducida

31

Nota introducida, la cual excede la nota m 痊 ima

Mensaje de error por haber introducido una nota con un valor incorrecto

Proyecto # 3 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________

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 Jerarquía y Herencia Enocjahaziel Carrasco_______________________________________________________ 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