04 PD DS Poo1

Programacin orientada a objetos I
Programa desarrollado
CARRERA: Ingeniera en Desarrollo de Software Cuatrimestre 04
Programa de la asignatura: Programacin Orientada a Objetos I
Clave: 160920414 / 150920414
Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software

ndice
I. INFORMACIN GENERAL DE LA ASIGNATURA ............................................. 7

a. Ficha de identificacin ............................................................................................................. 7 b. Descripcin ............................................................................................................................... 7 c. Fundamentacin de la asignatura ......................................................................................... 8 d. Propsito ................................................................................................................................... 9 e. Competencia(s) a desarrollar ................................................................................................. 9 f. Temario ....................................................................................................................................... 9 g. Metodologa de trabajo ......................................................................................................... 11 h. Evaluacin ............................................................................................................................... 12 i. Fuentes de consulta ................................................................................................................ 13
II. DESARROLLO DE CONTENIDOS POR UNIDAD ........................................... 15

a. Unidad 1. Introduccin a JAVA ............................................................................................ 15 Presentacin de la unidad......................................................................................................... 15 Propsitos de la unidad ............................................................................................................. 15 Competencia especfica ............................................................................................................ 15 Actividad 1. Presentacin .......................................................................................................... 15 1.1. Caractersticas de la Programacin Orientada a Objetos ............................................ 16 1.1.1. Abstraccin ....................................................................................................................... 16 1.1.2. Polimorfismo..................................................................................................................... 17 1.1.3. Encapsulacin .................................................................................................................. 17 1.1.4. Herencia ............................................................................................................................ 17 1.1.5. Programacin orientada a objetos vs estructurada ................................................... 18 Actividad 2. Diferencias entre Programacin estructurada y POO ..................................... 19 Actividad 3. Caractersticas de JAVA ...................................................................................... 20 1.2. Caractersticas del lenguaje JAVA ................................................................................... 20 1.2.1. Generalidades de JAVA ................................................................................................. 21

1.2.2. Mquina virtual de JAVA ................................................................................................ 26 1.2.3. Entorno de desarrollo y configuracin.......................................................................... 27 1.2.4. Tipos de datos soportados en JAVA ............................................................................ 30 Actividad 4. Tipos de datos ....................................................................................................... 32 1.2.5. Operadores aritmticos, lgicos y relacionales .......................................................... 33 Actividad 5. Operadores ............................................................................................................ 36 1.2.6. Conversin de tipos de datos ........................................................................................ 37 1.3. Organizacin de un programa .......................................................................................... 38 1.3.1. Estructura General .......................................................................................................... 39 1.3.2. Convenciones de la programacin ............................................................................... 42 1.3.3. Palabras reservadas ....................................................................................................... 43 1.3.4. Estructura de una clase .................................................................................................. 44 1.3.5. Declaracin de objetos y constructores ....................................................................... 45 Autoevaluacin ........................................................................................................................... 46 Evidencia de aprendizaje. Programa en JAVA ...................................................................... 47 Cierre de la unidad ..................................................................................................................... 47 Para saber ms........................................................................................................................... 48 Fuentes de consulta ................................................................................................................... 48
UNIDAD 2. MTODOS Y ESTRUCTURAS DE CONTROL ................................. 50

Presentacin de la unidad......................................................................................................... 50 Propsito ...................................................................................................................................... 50 Competencia especfica ............................................................................................................ 50 Consideraciones especficas de la unidad: actividades, requerimientos de asignatura, etc. ................................................................................................................................................ 50 2.1. Generalidades de los mtodos ......................................................................................... 51 2.1.1. Declaracin y mbito de variables ................................................................................ 51 2.1.2. Declaracin de constantes............................................................................................. 55 2.2. Mtodos que no devuelven valores ................................................................................. 56 2.2.1. Caractersticas ................................................................................................................. 56 2.2.2. Llamada de mtodos ...................................................................................................... 56 Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 3

2.3. Mtodos que devuelven valores ....................................................................................... 57 2.3.1. Recepcin de parmetros .............................................................................................. 58 2.3.2. Retorno de parmetros................................................................................................... 58 2.3.3. Paso de parmetros ........................................................................................................ 59 2.3.4. Llamada de mtodos ...................................................................................................... 59 Actividad 1. Tipos de variables y constantes ......................................................................... 60 Actividad 2. Deteccin de errores ............................................................................................ 60 Actividad 3. Sobre parmetros ................................................................................................. 61 2.4. Estructuras de control selectivas...................................................................................... 62 2.4.1. If - else............................................................................................................................... 62 2.4.2. If anidado .......................................................................................................................... 63 2.4.3. Switch - case .................................................................................................................... 64 Actividad 4. Programa de horscopo ...................................................................................... 66 2.5. Estructuras de control cclicas .......................................................................................... 67 2.5.1. While.................................................................................................................................. 67 2.5.2. Do - while .......................................................................................................................... 68 2.5.3. For...................................................................................................................................... 69 Actividad 5. Programa retorno de parmetros ....................................................................... 72 Autoevaluacin ........................................................................................................................... 72 Evidencia de aprendizaje. Programa de series numricas .................................................. 73 Cierre de la unidad ..................................................................................................................... 73 Para saber ms........................................................................................................................... 74 Fuentes de consulta ................................................................................................................... 74
UNIDAD 3. CARACTERSTICAS DE POO Y EXCEPCIONES ............................ 75

Presentacin de la unidad......................................................................................................... 75 Propsito ...................................................................................................................................... 75 Competencia especfica ............................................................................................................ 75 Consideraciones especficas de la unidad ............................................................................. 75 3.1. Herencia ............................................................................................................................... 75 3.1.1. Subclases y superclases ................................................................................................ 76 Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 4

3.1.2. Jerarqua de la herencia ................................................................................................. 78 3.1.3. Clases y mtodos abstractos ........................................................................................ 78 3.2. Polimorfismo ........................................................................................................................ 79 3.2.1. Clases y mtodos finales ............................................................................................... 80 3.2.2. Interfaces .......................................................................................................................... 80 3.2.3. Sobrecarga de mtodos ................................................................................................. 81 3.2.4. Sobrecarga de operadores ............................................................................................ 82 Actividad 1. Herencia y polimorfismo ...................................................................................... 82 Actividad 2. Cuadro sinptico ................................................................................................... 82 3.3. Excepciones ........................................................................................................................ 83 3.1.1. Sentencia Try-catch ........................................................................................................ 83 3.1.2. Tipos de errores............................................................................................................... 84 3.1.3. Jerarqua de las excepciones ........................................................................................ 84 Actividad 3. Manejo de excepciones ....................................................................................... 85 Autoevaluacin ........................................................................................................................... 86 Evidencia de aprendizaje. Implementacin de clases abstractas ...................................... 86 Para saber ms........................................................................................................................... 88 Fuentes de consulta ................................................................................................................... 88
UNIDAD 4. ARREGLOS ....................................................................................... 89

Presentacin de la unidad......................................................................................................... 89 Propsito ...................................................................................................................................... 89 Competencia especfica ............................................................................................................ 89 4.1. Arreglos unidimensionales ................................................................................................ 89 4.1.1. Declaracin....................................................................................................................... 90 Actividad 1. Arreglos .................................................................................................................. 92 4.1.2. Recorrido .......................................................................................................................... 92 4.1.3. Operaciones ..................................................................................................................... 94 Actividad 2. Operaciones con arreglos ................................................................................... 96 4.2 Arreglos multidimensionales .............................................................................................. 96 4.2.1. Declaracin....................................................................................................................... 97 Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 5

4.2.2. Recorrido .......................................................................................................................... 99 4.2.3. Operaciones ................................................................................................................... 100 Actividad 3. Inversin de arreglos .......................................................................................... 102 Autoevaluacin ......................................................................................................................... 102 Evidencia de aprendizaje. Men del curso ........................................................................... 102 Para saber ms......................................................................................................................... 103 Fuentes de consulta ................................................................................................................. 104

I. Informacin general de la asignatura a. Ficha de identificacin

Nombre de la Licenciatura o Ingeniera: Nombre del curso o asignatura Clave de asignatura: Seriacin: Cuatrimestre: Horas contempladas: Ingeniera en Desarrollo de Software Programacin Orientada a Objetos I 160920414 / 150920414 160920518 / 150920518 160920622 / 150920622 04 72
b. Descripcin
El ser humano siempre ha visto el mundo a travs de objetos, por ejemplo, al observar algo simple como un zapato, nuestra mente lo asimila como un objeto, el cual tiene caractersticas (atributos), como lo son: color, talla, tipo de suela, estilo, etctera; tambin tiene acciones que pueden ser aplicadas sobre l (mtodos) como: bolearlo, limpiarlo, abrocharlo, entre otros ms. Mientras nos imaginamos el objeto zapato, ste vara dependiendo de sus caractersticas y el escenario, es decir, un zapato puede ser una zapatilla, bota, tenis o huarache; sin embargo, contiene las mismas acciones ya mencionadas. Considerando esto, se puede ver el alcance y las ventajas de la programacin orientada a objetos (POO) para la portabilidad y reutilizacin de cdigo, evitando programar varias veces lo mismo. Tomando el ejemplo mencionado con anterioridad, solamente es necesario programar un mtodo bolear-zapato, en lugar de bolear-zapatilla, bolear-bota, bolear-tenis y bolear-huarache. El desarrollo de programas orientados a objetos implica la creacin de objetos del mundo real, y la construccin de programas basados en el modelo orientado a objetos. El lenguaje de programacin JAVA es un lenguaje basado en C, cuyo enfoque est dirigido a la POO, por ello ser el utilizado en este curso. Una de las ventajas de utilizar este lenguaje es que tambin encontramos su compilador de manera libre, como Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 7

Netbeans, Eclipse, etctera. El principal elemento de la programacin orientada a objetos es la reutilizacin de cdigo para poder optimizar el desarrollo de software basado en las tcnicas para la solucin de problemas. La asignatura de Programacin orientada a objetos I forma parte del 4 cuatrimestre de la Ingeniera en Desarrollo de software. Las materias previas son Fundamentos de programacin y Habilidades del pensamiento, las cuales sirven de base para POO I y sta, a su vez, servir para continuar con las materias de POO II, POO III, Programacin NET I, NET II y NET III, entre otras. La materia de POO I est conformada por cuatro unidades: 1. Introduccin a JAVA 2. Mtodos y estructuras de control 3. Caractersticas de programacin orientada a objetos y excepciones 4. Arreglos En la unidad 1 se delinear el concepto de la programacin orientada a objetos, describindose los elementos que la integran as como el lenguaje a implementar, JAVA, del cual se abordarn sus caractersticas. Asimismo, se determinar la estructura de un programa. En la unidad 2 se identificar la forma en que se codifican los mtodos y se ilustrarn las estructuras de control. A continuacin, en la unidad 3, se distinguirn las caractersticas de la programacin orientada a objetos, entre las que se encuentran: herencia y polimorfismo. Tambin se evocar el manejo de excepciones, errores, sentencias de error y jerarquas. Finalmente, la unidad 4 introducir el manejo de arreglos unidimensionales y multidimensionales: su declaracin, recorrido y operaciones.
c. Fundamentacin de la asignatura
Los fundamentos que justifican la asignatura son de carcter terico-prctico, dado que la estructura de las unidades est diseada de una manera donde se combina la teora y la prctica. En la unidad 1, se cubren los conceptos de la programacin orientada a objetos y su diferencia con la programacin estructurada, as como las caractersticas del lenguaje JAVA y la organizacin de un programa en JAVA, de modo tal que el estudiante comprenda primero los conceptos, despus identifique la sintaxis (secuencia correcta de los elementos de un lenguaje de programacin) que JAVA ofrece para implementar dichos conceptos y despus logre aplicarlos en un programa. La unidad 2 muestra de la misma manera que la anterior una combinacin de la teora y la prctica considerando las generalidades de los mtodos, los que devuelven valor y los que no devuelven valor, as como las estructuras de control selectivas y cclicas, donde se incluyen conceptos y ejemplificacin prctica de los temas que se abordan. En la unidad 3 se abarcan temas como la herencia, el polimorfismo y las excepciones se desarrolla igual que las anteriores Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 8

con una combinacin de teora y ejemplificacin prctica de todos los temas. Por ltimo la unidad 4 contiene temas de arreglos unidimensionales y bidimensionales donde se incluye los conceptos de estos temas, y se enfoca ms hacia la prctica de estos temas.
d. Propsito
Favorecer al logro del aprendizaje orientado a la generacin de aplicaciones de software. As mismo su importancia radica en establecer las bases de la programacin para que el alumno desarrolle habilidades para la implantacin de aplicaciones de software que satisfagan las necesidades de las empresas.
e. Competencia(s) a desarrollar
Competencia general: Construir programas modulares bajo el paradigma orientado a objetos para satisfacer necesidades en el procesamiento de informacin mediante su anlisis y su codificacin en lenguaje JAVA. Competencias especficas: Desarrollar un programa bsico para la solucin de problemas matemticos simples tomando en cuenta el entorno, caractersticas y especificaciones de los programas JAVA a travs de dicho lenguaje. Desarrollar programas modulares para solucionar problemas diversos, mediante la aplicacin de los diferentes tipos de variables, mtodos, y estructuras de control en lenguaje JAVA. Desarrollar programas modulares para solucionar problemas diversos, aplicando la herencia, el polimorfismo y el manejo de excepciones mediante la sintaxis que JAVA ofrece para su implementacin. Construir programas para el manejo de datos del mismo tipo (carcter, cadena, entero o decimal) a travs del uso de arreglos aplicados en problemas matemticos simples.
f. Temario
En este apartado se desglosar el contenido de la asignatura a detalle. Unidad 1. Introduccin a JAVA Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 9

1.1
1.2
1.3
Caractersticas de la programacin orientada a objetos 1.1.1 Abstraccin 1.1.2 Polimorfismo 1.1.3 Encapsulacin 1.1.4 Herencia 1.1.5 Programacin orientada a objetos vs estructurada. Caractersticas del lenguaje JAVA 1.2.1 Generalidades de JAVA 1.2.2 Mquina Virtual de JAVA 1.2.3 Entorno de desarrollo y configuracin 1.2.4 Tipos de datos soportados en JAVA 1.2.5 Operadores aritmticos, lgicos y relacionales 1.2.6 Conversiones de tipos de datos Organizacin de un programa 1.3.1 Estructura general de un programa 1.3.2 Convenciones de la programacin 1.3.3 Palabras reservadas 1.3.4 Estructura de una clase 1.3.5 Declaracin de objetos y constructores
Unidad 2. Mtodos y estructuras de control 2.1 Generalidades de los mtodos 2.1.1 Declaracin y mbito de variables 2.1.2 Declaracin de constantes 2.2 Mtodos que no devuelven valores 2.2.1 Caractersticas 2.2.2 Llamada de mtodos 2.3 Mtodos que devuelven valores 2.3.1 Recepcin de parmetros 2.3.2 Retorno de parmetros 2.3.3 Paso de parmetros 2.3.4 Llamada de mtodos 2.4 Estructuras de control selectivas 2.4.1 If else 2.4.2 If anidados 2.4.3 Switch - case 2.5 Estructuras de control cclicas 2.5.1 While 2.5.2 Do While 2.5.3 For Unidad 3. Caractersticas de POO y excepciones Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 10

3.1 Herencia 3.1.1 Subclases y superclases 3.1.2 Jerarqua de la herencia 3.1.3 Clases y mtodos abstractos 3.2 Polimorfismo 3.2.1 Clases y mtodos finales 3.2.2 Interfaces 3.2.3 Sobrecarga de mtodos 3.2.4 Sobrecarga de operadores 3.3 Excepciones 3.3.1 Sentencia Try catch 3.3.2 Tipos de errores 3.3.3 Jerarqua de las excepciones Unidad 4. Arreglos 4.1 Arreglos unidimensionales 4.1.1 Declaracin 4.1.2 Recorrido 4.1.3 Operaciones 4.2 Arreglos multidimensionales 4.2.1 Declaracin 4.2.2 Recorrido 4.2.3 Operaciones
g. Metodologa de trabajo
Para el desarrollo de la presente asignatura se trabajar mediante el Aprendizaje Basado en Resolucin de Problemas; ya que en esta materia se debe aprender a enfrentar problemas dados y ofrecer una solucin a estos, de modo que primero se plantea el problema, despus el alumno identificar los requerimientos de informacin para lograr solucionar el problema planteado. Tomando en cuenta que en esta materia se deben generar aplicaciones de software se ha planteado al menos un ejercicio por cada unidad temtica ya que es importante que, ante un problema dado se analice la informacin con la que se cuenta, y en base a esto se logre dar una solucin mediante software para resolver la problemtica planteada en el ejercicio, de manera que con las habilidades que se forjarn en cada una de las unidades se logre el aprendizaje orientado a la generacin de aplicaciones de software.
11

Tipo de actividades en el aula virtual: Foros, Wikis, Bases de Datos, Autoevaluaciones. Actividades de estudio independiente: lecturas, tareas, creacin y ejecucin de programas. En cuanto a la evaluacin de las actividades y evidencias, el facilitador es quien debe revisar los entregables realizados y retroalimentarlos de manera clara y concisa; informando sobre el avance que se haya logrado, pero tambin tomando en cuenta los errores que se cometan como parte del aprendizaje para que se eviten.
h. Evaluacin
En el marco del Programa ESAD, la evaluacin se conceptualiza como un proceso participativo, sistemtico y ordenado que inicia desde el momento en que el estudiante ingresa al aula virtual. Por lo que se le considera desde un enfoque integral y continuo. Por lo anterior, para aprobar la asignatura, se espera la participacin responsable y activa del estudiante as como una comunicacin estrecha con su facilitador para que pueda evaluar objetivamente su desempeo. Para lo cual es necesaria la recoleccin de evidencias que permitan apreciar el proceso de aprendizaje de contenidos: declarativos, procedimentales y actitudinales. En este contexto la evaluacin es parte del proceso de aprendizaje, en el que la retroalimentacin permanente es fundamental para promover el aprendizaje significativo y reconocer el esfuerzo. Es requisito indispensable la entrega oportuna de cada una de las tareas, actividades y evidencias as como la participacin en foros y dems actividades programadas en cada una de las unidades, y conforme a las indicaciones dadas. La calificacin se asignar de acuerdo con la rbrica establecida para cada actividad, por lo que es importante que el estudiante la revise antes realizarla. A continuacin presentamos el esquema general de evaluacin. ESQUEMA DE EVALUACIN Interacciones individuales y Evaluacin colaborativas continua Tareas Evidencias E-portafolio. 50% Autorreflexiones Examen CALIFICACIN
10% 30% 40% 10% 10% 100% 12

FINAL Cabe sealar que para aprobar la asignatura, se debe de obtener la calificacin mnima indicada por ESAD. Los trabajos que se tomarn en cuenta como evidencia del aprendizaje son: Unidad 1: Programa en JAVA. Dados dos nmeros por el usuario, reste y multiplique mostrando el resultado en pantalla. Unidad 2: Programa en JAVA. 6 Realizar un programa que solicite un nmero, si este es par, que calcule su factorial, si es impar, que muestre ese mismo nmero de elementos de la serie de Fibonacci, utilizando mtodos que devuelven valor y que no devuelven. Unidad 3: Programa en JAVA. Dada una serie de clases abstractas e interfaces desarrollar un programa que los implemente utilizando excepciones. Unidad 4: Programar una aplicacin que muestre en un men todos los programas vistos en el curso. Por otra parte la forma de evaluacin ser segn lo indicado a continuacin: o Excelente: 100 o Bien: 80 o Regular: 60 o Insuficiente: 50
i. Fuentes de consulta
Bibliografa bsica Devis, R. (1993). C++/OOP: un enfoque prctico. Madrid, Espaa: Editorial Paraninfo. Recuperado el 1 de marzo de 2011, de: http://www.a4devis.com/articulos/libros/Programaci%C3%B3n%20Orientada-aObjetos%20en%20C++.pdf Joyanes, L. y Fernndez, M. (2001) Java 2: manual de programacin. Espaa: McGrawHill Interamericana de Espaa SL. Zukowski. J. (1997) The Java AWT Reference (Java Series), version 1.2. O'Reilly & Associates. Recuperado el 1 de marzo de 2011, de: http://oreilly.com/openbook/javawt/book/index.html
13

Bibliografa complementaria Flanagan, D. (2005) Java in a NutShell. USA: O'Reilly & Associates. Joyanes, L. (2001) OLC - Programacin en C++. Serie Schaum, Captulo 1: Programacin orientada a objetos versus programacin estructurada: C++ y algoritmos. Espaa: McGrawHill Interamericana de Espaa SL. Recuperado el 1 de marzo del 2011, de: http://www.mcgraw-hill.es/bcv/guide/capitulo/8448146433.pdf
14

II. Desarrollo de contenidos por unidad a. Unidad 1. Introduccin a JAVA Presentacin de la unidad
En esta 1 unidad de la materia Programacin Orientada a Objetos I (POO I), se aprender el concepto de la programacin orientada a objetos y la descripcin de los elementos que la integran as como del lenguaje a implementar, el cual ser JAVA, sus caractersticas y la estructura de un programa.
Propsitos de la unidad
En esta unidad el estudiante lograr: Distinguir entre programacin orientada a objetos y programacin estructurada. Reconocer las caractersticas de la programacin orientada a objetos. Determinar las caractersticas y especificaciones de la programacin en JAVA. Identificar la organizacin de un programa en JAVA. Desarrollar programas modulares.
Competencia especfica
Desarrollar un programa bsico para la solucin de problemas matemticos simples tomando en cuenta el entorno, caractersticas y especificaciones de los programas JAVA a travs de dicho lenguaje.
Actividad 1. Presentacin
Antes de comenzar el estudio de la asignatura, te invitamos a participar en un foro de discusin general, creado para que comentes cualquier asunto relacionado con la asignatura; en l, conocers a tus compaeros de grupo y entre todos podrn apoyarse para resolver dudas, inquietudes, externar comentarios, etctera. Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 15

Para comenzar tu participacin, ingresa a la Actividad 1.Presentacin en el aula.
1.1. Caractersticas de la Programacin Orientada a Objetos

Hoy en da podemos entender que en la vida diaria estamos rodeados de objetos y que estos objetos coexisten con nosotros, pero Qu es un Objeto? Podemos describir y nombrar los objetos para entender cules son las diferencias entre ellos, por ejemplo si vas a un supermercado, encontramos carritos de super y canastillas de mercado, ambos son objetos con propiedades o atributos en comn, espacio para cargar o transportar artculos pero a la vez tienen diferencias, la canastilla de mercado necesitamos cargarla y al carrito de super no, es decir cada uno es para un fin especfico y prctico. De tal modo, podemos definir a un objeto como una entidad compleja con propiedades (datos, atributos) y comportamiento (funcionalidad, mtodos). Con todas stas caractersticas es conveniente afirmar que todo lo que nos rodea se puede representar y que cada uno de estos objetos posee una interfaz que especifica cmo stos pueden interactuar con otros, dichos objetos tienen instrucciones propias (Joyanes, 2001).
1.1.1. Abstraccin
De acuerdo a Joyanes, la abstraccin es:
La propiedad de los objetos que consiste en tener en cuenta slo los aspectos ms importantes desde un punto de vista determinado y no tener en cuenta los restantes aspectos que no son significativos. Durante el proceso de abstraccin es cuando se decide qu caractersticas y comportamiento debe tener el modelo. Un medio de reducir la complejidad es la abstraccin. Las caractersticas y los procesos se reducen a las propiedades esenciales, dejando de lado los dems detalles no sustanciales. De este modo, las caractersticas complejas se hacen ms manejables (Joyanes, 2001: 5).
La abstraccin como tal nos sirva para poder pasar del plano material al plano mental. Ahora bien, cmo se relaciona la abstraccin con la POO? Imaginemos que tenemos un grupo de tornillos y de dicho grupo un tornillo se podra manejar con un desarmador especfico, pero tambin con cualquier otro desarmador aunque no sea nuestro, lo mismo pasa en un sistema software, los mdulos son independientes, pero a la vez funcionan
16

como un gran modulo del software, es decir podemos partir un gran software para poder hacerlo en mdulos, esto har ms fcil la identificacin de sus caractersticas bsicas.
1.1.2. Polimorfismo
La propiedad de polimorfismo es aquella en que una operacin tiene el mismo nombre en diferentes clases, pero se ejecuta de diferentes formas en cada clase. (Joyanes, 2001: 6). Dicho de otro modo es la capacidad que tiene una clase para adaptarse a diferentes usos sin necesidad de modificarla. As, por ejemplo, la operacin copiar puede darse en diferentes clases: copiar un libro, copiar un archivo, copiar una actitud, copiar un comportamiento, copiar en un examen, etc. Siempre se ejecuta una operacin distinta pero con el mismo nombre copiar. Por tanto: El polimorfismo es la propiedad de una operacin de ser interpretada exclusivamente por el objeto al que corresponde.
1.1.3. Encapsulacin
Si bien externamente los objetos pueden parecer iguales, internamente pueden ser muy distintos. Por ejemplo, si sabes manejar un reproductor de DVD, puedes manejar cualquier otro reproductor como CD y BLUE RAY, esto es encapsular, los dos reproductores pueden ser parecidos por fuera, pero por dentro funcionan de diferente forma. Esta propiedad permite intercambiar objetos en una operacin; retomando el ejemplo de los reproductores puedes cambiar la carcasa por una ms moderna o llamativa sin que el funcionamiento interno se vea afectado.
1.1.4. Herencia
La herencia en el paradigma de la POO es un mecanismo que se utiliza para efectuar la reutilizacin del software, de modo tal que los programadores pueden crear clases nuevas a partir de clases ya existentes, tomndolas como base y creando una jerarqua de clases, de esta manera no se tiene que rehacer todo el cdigo de una clase.
17

Si se ve de manera ms sencilla, la herencia en programacin funciona de manera similar a la herencia familiar, por ejemplo, si un pap tiene un hijo que se parece mucho fsicamente a l, entonces ambos comparten ciertas caractersticas, podemos decir entonces que el pap le hered sus caractersticas fsicas al hijo. Las caractersticas de un objeto pueden ser heredadas del objeto que est en el nivel superior, por ejemplo novillo tiene orejas y cola y su pelo es negro como el de un toro normal pero su cornamenta es ms delgada y ms fina, el toro y el novillo son parecidos pero no son iguales. En programacin la herencia se aplica sobre las clases, y tenemos clases padre, de las cuales de despliegan las clases hijo, que heredar las caractersticas del padre y pueden tener otras caractersticas ms. Hasta este punto hemos visto solo los conceptos generales que dan cabida a la POO, ms adelante en el curso veremos cmo estos conceptos se implementan ya en la programacin.
1.1.5. Programacin orientada a objetos vs estructurada

Desde la concepcin de la programacin estructurada (y por su misma etimologa) se ha entendido de manera que se debe realizar de manera secuencial y haciendo el diseo como lo marcan los cnones: de arriba a abajo (Top-Down) o de abajo a arriba (BottomUp). De esta manera se comienza a pensar y escribir una secuencia de instrucciones que debern resolver el problema que se presenta y para el cual se escribe el programa deseado. Cuando la complejidad misma inherente al problema crece, por cualquiera que sea la razn, esta concepcin deja de ser til e inevitablemente se debe voltear la mirada a otro paradigma de programacin, que, no importando cun grande y complejo se torne la solucin del problema, sea capaz de manejarlo e implementarlo. Se est hablando de la Programacin Orientada a Objetos (POO). La POO tiene sin duda muchas de sus bases en la programacin estructurada, la principal diferencia entre estos dos paradigmas radica en que, en la programacin estructurada la atencin principal del programa (y del programador) est en la secuencia de las instrucciones, mientras que en la POO la atencin principal est en las partes (objetos) que la conforman, cmo interactan y las operaciones que se pueden hacer sobre los mencionados objetos. Para tener un panorama ms claro sobre lo explicado se sugiere al lector imaginar un archivo electrnico cualquiera. En trminos de la POO las acciones que se aplican sobre este objeto pueden ser imprimir, borrar, renombrar, escribir ms letras, entre otros. Aunque se piense que si se compara el cdigo generado para las mismas Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 18

acciones en programacin estructurada y POO sea igual, no lo es; la principal diferencia estriba en que para la POO estas operaciones (mtodos) conforman al objeto en s, son parte de l y en la programacin estructurada son funciones aisladas que no tienen vnculo alguno, ms que desde donde son llamadas. A modo de lista, se presentan los siguientes puntos como principales diferencias entre ambos paradigmas: La POO se considera la evolucin de la programacin estructurada en cuanto a la atencin de problemas complejos y cambiantes. La POO se basa en lenguajes que soportan descripcin y escritura de tipos de dato complejos (no slo primitivos) y las operaciones que se pueden efectuar sobre ellos: la clase. La POO incorpora niveles profundos de abstraccin que permiten utilizar (entender y aplicar) conceptos como el polimorfismo, la herencia, la sobrecarga, entre otros. Los creadores de la programacin estructurada encontraron solucin al problema presentado por sta (no dar el ancho ante la complejidad de los problemas a resolver) y fue el seguimiento de rigurosos mtodos de trabajo al utilizar la programacin estructurada, pero pocos fueron quienes aceptaron trabajar bajo tal presin. Sin embargo los problemas no son inherentes a la programacin estructurada, slo es mala aplicacin de sus conceptos a la resolucin de problemas, se listan a continuacin una serie de malas prcticas sobre la programacin estructurada: No se sigue completamente la forma en que trabaja el cerebro del ser humano, ya que ste capta la realidad en base a objetos y sus propiedades (atributos) y las cosas que puede hacer o que se hacen sobre l (mtodo). Dificultad para extender los programas existentes a las nuevas necesidades No se centra el modelo en el mantenimiento, se centra en la generacin de soluciones repetitivas para los mismos problemas. Las entidades funcionales no se sincronizan o lo hacen de manera difcil y tortuosa. Muchos lenguajes de programacin que se dicen orientados a objetos aun aceptan gran parte del paradigma de la programacin estructurada, dando pie a hacer una programacin mezclada y llevando lo peor de ambos mundos, se recomienda evitar esto.
Actividad 2. Diferencias entre Programacin estructurada y POO

Durante esta actividad reflexionars acerca de las diferencias existentes entre anlisis, programacin estructurada y programacin orientada a objetos tomando en cuenta los temas vistos y los comentarios de los compaeros(as) del grupo. Realiza lo siguiente: Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 19

1. Previo a tu ingreso al foro, identifica las diferencias entre anlisis, programacin estructurada y programacin orientada a objetos. 2. Ingresa al foro correspondiente a esta actividad y genera una nueva entrada en la que comentes las diferencias identificadas. 3. Contribuye con algn comentario a por lo menos dos compaeros(as) sobre su discernimiento del tema. 4. Con base en las aportaciones de tus compaeros(as), reelabora las diferencias entre, la programacin estructurada y de la programacin Orientada a Objetos y publcalas como conclusin del foro.
Actividad 3. Caractersticas de JAVA

Esta actividad tiene como finalidad que a partir de un ejercicio colaborativo se identifiquen las caractersticas de JAVA. Para iniciar, realiza lo siguiente: 1. Investiga respecto a las caractersticas y aplicaciones de JAVA. 2. Ingresa a la wiki con el nombre de esta actividad e integra tu participacin respecto a las caractersticas de JAVA. *Recuerda incluir las fuentes de consulta utilizadas. 3. Revisa las aportaciones de tus compaeros y contribuye en la elaboracin de las conclusiones del tema.
1.2. Caractersticas del lenguaje JAVA

Hasta el momento en que se escribe el presente documento hay varias versiones que describen el origen de Java como proyecto y como lenguaje de programacin que van desde situar sus orgenes entre finales de la dcada de los ochentas y 1990 (Zukowski, 1997) hasta mediados de la dcada de los noventas. De manera general se describe como un lenguaje de programacin que fue pensado para desarrollar software que se utilizar dentro de la electrnica de consumo (refrigeradores, lavadoras, entre otros) desarrollado por el Green Team de Sun Microsystems liderado por Bill Joy, y aunque la idea original de usarlo en electrnicos fracas, fue rescatado tiempo despus para ser Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 20

usado como lenguaje de propsito general y esta idea le dio la principal caracterstica que lo hizo popular y lo sigue manteniendo en el gusto generalizado; su capacidad multiplataforma. Adems con APIs que dan soporte a acceso a base de datos, objetos remotos y modelos de componentes de objetos, internacionalizacin, impresin y reporteo, encriptacin, procesamiento de seales digitales y muchas otras tecnologas y capacidades lo posicionan tomando gran parte de la tajada sobre los lenguajes de programacin ms utilizados.
1.2.1. Generalidades de JAVA

En una de las primeras publicaciones que hacen referencia a Java (Zukowski, 1997), Sun lo describe como un sencillo, orientado a objetos, distribuido, interpretado, robusto, seguro, de arquitectura neutral, portable, de alto rendimiento, multihilo, y dinmico lenguaje. Sus creadores reconocen que estas palabras pueden llegar a ser pretenciosas, pero el hecho es que, en su totalidad, se describe acertadamente el lenguaje. Para tener una mejor comprensin de la descripcin hecha sobre Java, se revisar a las caractersticas del lenguaje detrs de cada palabra. Sencillo. Java es un lenguaje simple. La mayora de los lenguajes de programacin orientados a objetos no son ni cercanamente sencillos ni fciles de utilizar o comprender, pero Java es un poco ms fcil que C++, que se consideraba como el lenguaje de programacin ms popular hasta la implementacin de Java. Java ha puesto simplicidad en la programacin en comparacin con C++, incorporando caractersticas medulares de C++ y eliminando algunas de stas que hacen de C++ un lenguaje difcil y complicado. Haciendo referencia a la facilidad de Java y su sencillez, se dice que es simple porque consta slo de tres tipos de datos primitivos: nmeros, boolean y arrays. Todo en Java en una clase. Por ejemplo, las cadenas son objetos verdaderos y no arrays de caracteres. Otros conceptos que hacen la programacin en C++ ms complicada son los punteros y la herencia mltiple. Java elimina los punteros y reemplaza la herencia mltiple en C++ con una estructura nica denominada interfaz (Joyanes y Fernndez, 2001). La utilizacin de asignacin de memoria y recoleccin de basura automticas son otro aspecto que abona a la sencillez de Java sobre otros lenguajes, por ejemplo con el ya citado C++, donde el programador debe realizar estas tareas de forma manual, con los posibles errores que esto puede conllevar. Otra facilidad que proporciona Java es la elegancia de su sintaxis que hacen ms fcil la lectura (comprensin) y escritura de programas. Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 21

Orientado a Objetos. La programacin orientada a objetos permite de una manera muy sencilla modelar el mundo real o los problemas que en l se presenten y necesiten ser resueltos mediante programas, cualquier cosa del mundo real puede ser modelada como un objeto. Un libro es un objeto, un automvil es un objeto e incluso un prstamo o una tarjeta de crdito es un objeto. Un programa en Java se denomina orientado a objetos debido a que la programacin en Java se centra en la creacin, manipulacin y construccin de objetos (Joyanes y Fernndez, 2001). Java es un lenguaje de programacin orientado a objetos. Lo que significa que el trabajo real sobre la construccin de los programas se centra en un gran porcentaje (por no decir la totalidad) en los datos de la aplicacin y los mtodos que manipulan estos datos, en lugar de pensar estrictamente en trminos de los procedimientos. Si se est acostumbrado a utilizar la programacin basada en procedimientos (por ejemplo con el lenguaje C o BASIC), es posible que sea necesario cambiar la forma de disear los programas o aplicaciones cuando se utiliza Java. Una vez que se experimente lo poderoso que resulta este paradigma (orientado a objetos), pronto se ajustar a l. Cuando se trabaja con el paradigma orientado a objetos, una clase es una coleccin de datos y tiene adems mtodos que operan sobre esos datos. En conjunto, los datos y mtodos describen el estado y el comportamiento de un objeto. Java cuenta con un amplio conjunto de clases organizadas en paquetes, que se pueden utilizar al programar. Proporciona paquetes de clases para la interfaz grfica de usuario (java.awt), clases que se encargan de la entrada y salida (java.io), funcionalidad de soporte de red (java.net), entre muchos otros paquetes. Desde la concepcin inicial del diseo de Java se pens en hacer de este un lenguaje totalmente orientado a objetos desde la base, a diferencia de otros lenguajes que fueron adoptando los lineamientos de este paradigma en sus caractersticas, como por ejemplo C++. La mayora de los elementos disponibles en Java con objetos, con excepcin de los tipos primitivos y los tipos booleanos. Las cadenas o arrays son en realidad objetos en java. Una clase es la unidad bsica de compilacin y ejecucin en Java, todos los programas de Java con clases. Interpretado. Java es un lenguaje interpretado y necesita un intrprete para ejecutar programas. El compilador de Java genera bytecode para la Mquina Virtual de Java (JVM), en lugar de compilar al cdigo nativo de la mquina donde se ejecutar. El bytecode es independiente de la plataforma y se puede hacer uso de l en cualquier mquina (no necesariamente una computadora) que tenga un intrprete de Java.
22

En un entorno donde el lenguaje de programacin es interpretado, la fase estndar de enlace casi se vera desvanecida. Si java cuenta con esta fase como un todo, es slo porque el proceso de cargar clases nuevas en el ambiente de ejecucin se hace precisamente en esta fase, que es un proceso incremental y mucho ms ligero que se produce en tiempo de ejecucin. Contrastando con el ciclo ms lento y complicado de compilar-enlazar-ejecutar de lenguajes como C o C++. Los programas Java no necesitan ser recompilados en una mquina destino. Se compilan en un lenguaje ensamblador para una mquina imaginaria, denominada mquina virtual (Joyanes y Fernndez, 2001). Arquitectura Neutral y Portable. Debido a que el lenguaje Java se compila en un formato de arquitectura propia o mejor dicho neutra llamada bytecode, un programa en Java puede ejecutarse en cualquier sistema, siempre y cuando ste tenga una implementacin de la JVM y esta es la caracterstica tal vez ms notable que tenga Java. Se pueden, por ejemplo, ejecutar applets desde cualquier navegador de cualquier sistema operativo que cuente con una JVM y ms all todava, hacer sistemas autnomos que se ejecuten directamente sobre el sistema operativo. Esto es particularmente importante cuando se trabajar con aplicaciones distribuidas por internet o cualquier otro medio de distribucin donde los usuarios no pueden (deben) tener un cierto sistema operativo funcionando en la computadora donde se ejecutar dicha aplicacin. En las aplicaciones que se desarrollan hoy en da, muy probablemente se necesite tener la misma versin ejecutndose en un ambiente de trabajo con UNIX, Windows o Mac. Y ms an, con las diferentes versiones de procesadores y dispositivos (celulares, celulares inteligentes, consolas de video juegos, entre muchos otros) soportados por estos sistemas, las posibilidades se pueden volver interminables y la dificultad para mantener una versin de la aplicacin para cada uno de ellos crece de igual manera, interminable. La misma definicin de bytecode hace que Java sea multiplataforma y no tenga la necesidad de complicados temas al portar la aplicacin entre dispositivos como tipos de datos y su longitud, caractersticas y capacidades aritmticas; caso contrario, por ejemplo, del lenguaje C donde un tipo int puede ser de 16, 32 64 bits dependiendo de la plataforma de compilacin y ejecucin. Los programadores necesitan hacer un solo esfuerzo por terminar sus asignaciones, esto se puede lograr apegndose al slogan que hizo tan famoso Sun: Write Once, Run Anywhere (Escribe una vez, ejecuta donde sea). Dinmico y Distribuido. Java es un lenguaje dinmico. Cualquier clase construida en Java puede cargarse en cualquier momento dentro del ejecutor en cualquier momento. As, si es cargada dinmicamente puede instanciarse de igual manera. Las clases en Java con representadas por la palabra reservada class se puede obtener informacin en cualquier momento sobre ellas mediante el run-time.
23

En cualquier instante de la ejecucin Java puede ampliar sus capacidades mediante el enlace de clases que est ubicadas en la mquina residente, en servidores remotos o cualquier sitio de la red (intranet/internet). Caso contrario de lenguajes como C++ que hacen esto al momento de la compilacin, despus ya no se puede. Se puede extender libremente mtodos y atributos de una clase sin afectar la ejecucin corriente, las capacidades descritas se encuentran dentro del API Reflections. Robusto. Java fue diseado para ser un lenguaje de programacin que genere aplicaciones robustas. Java no elimina la necesidad del aseguramiento de calidad en el software; de hecho es muy posible y probable tener errores al programar en Java. No elimina tampoco la mayora de los errores que se comenten al utilizar cualquier lenguaje de programacin. Sin embargo al ser fuertemente tipado se asegura que cada variable o mtodo que se utilice corresponda en realidad a lo que el programador quiso utilizar y no que se escapen errores en conversin de tipos de dato, por ejemplo. Java requiere declaracin explicita de mtodos, cosa que no se permite en otros lenguajes, como en C. Java ha sido pensado en la fiabilidad, eliminando la mayora (o todas) las posibles partes de otros lenguajes de programacin propensas a errores, por ejemplo elimina los punteros y soporta el manejo de excepciones en tiempo de ejecucin para proporcionar robustez a la programacin. Java utiliza recoleccin de basura en tiempo de ejecucin en vez de liberacin explcita de memoria. En lenguajes como C++ es necesario borrar o liberar memoria una vez que el programa ha terminado (Joyanes y Fernndez, 2001). Seguro. Uno de los aspectos ms sobresalientes de Java es el de ser un lenguaje seguro, lo que es especialmente interesante debido a la naturaleza de la distribucin de aplicaciones en Java. Sin un aseguramiento el usuario no estar tranquilo de bajar y ejecutar cdigo en su computadora desde internet o cualquier otra fuente. Java fue diseado con la seguridad como punto principal y tiene disponibles muchas capas que gestionan la seguridad de la aplicacin que se escribe, bloqueando al programador si intenta distribuir cdigo malicioso escrito en lenguaje Java. Los programadores de Java no tienen permitido cierto tipo de acciones que se consideran altamente vulnerables o que el tpico caso de ataque contra un usuario comn, por ejemplo el acceso a memoria, desbordamiento de arreglos entre muchos otros. Otra capa de seguridad dentro de Java es el modelo sandbox que hace una ejecucin controlada de cualquier bytecode que llega a la JVM, por ejemplo si se lograr evadir la regla del cdigo no malicioso al momento de compilar, este modelo en su ejecucin controlada evitara que las repercusiones lleguen al mundo real. Por otro lado, otra posible solucin al aspecto de seguridad en Java es que se aade una firma digital al cdigo de Java, el origen del software puede establecerse con esta firma y Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 24

utilizando criptografa se oculta esta firma para que sea inaccesible e inmodificable por cualquier persona. Si hay confianza en una persona especfica de alguna organizacin, entonces el cdigo puede ser firmado digitalmente por dicha persona, dndonos la seguridad que el resultado que recibimos sea de quien debe ser y no haya introduccin de cdigo por terceras personas ajenas a l. Por supuesto la seguridad no puede entenderse ni manejar como una cosa que es totalmente blanca o totalmente negra, deben descubrirse los matices que pueda presentar y verificar todas las posibles vertientes que puedan tomar los matices, as nos aseguraremos que todo est controlado. Ningn programa puede dar al 100% la garanta de la ausencia de errores, tampoco un ambiente de compilacin o interpretacin puede dar esta garanta. Java no se centra en la correccin de seguridad, se basa en la anticipacin de los posibles errores que se puedan presentar. Alto Rendimiento. Java es un lenguaje interpretado, por eso no ser igual de veloz en la ejecucin como un lenguaje compilado como C. En versiones tempranas de Java est an decenas de veces ms abajo que la velocidad de ejecucin que proporciona C. Sin embargo con el pasar del tiempo este aspecto ha ido mejorando sobre la base del compilador JIT (just in time) que permite programas en Java de plataforma independiente se ejecuten casi tan rpido como los lenguajes convencionales compilados. Multihilo. Es fcil imaginar cmo funciona una aplicacin que hace mltiples cosas a la vez, por ejemplo en un navegador web, donde, se hace la descarga al mismo tiempo del texto, imgenes, videos y dems componentes de la pgina que visitamos, pero esta descarga se hace por separado, donde una funcin especfica se hace cargo de descargar las imgenes, otra el texto y as con cada uno de los compontes. Obviamente lo hacen al mismo tiempo, por esto se dice que es multihilo. Java es un lenguaje multihilo ya que soporta la ejecucin de mltiples tareas al mismo tiempo y cada uno de esos hilos puede soportar la ejecucin de una tarea especfica diferente. Un beneficio importante de esta caracterstica multihilo es el aporte que da a las aplicaciones basadas precisamente en esto, ya que como se mencion, incrementa el rendimiento de la aplicacin, sobre todo en aplicaciones basadas en interfaces grficas de usuario. Aunado a lo anterior y haciendo referencia a la facilidad de Java, programar multihilo en Java es muy fcil, ya que si se ha tratado trabajar con hilos en C o C++ se notar la enorme dificultad que esto representa. La clase Thread da el soporte, la facilidad y los mtodos para iniciar y terminar la ejecucin y hacer uso de los hilos, que a su vez se encuentra contenida en el nombre de espacio java.lang. La sintaxis del lenguaje Java de igual manera tiene soporte directo sobre la palabra reservada synchronized la cual hace extremadamente fcil para marcar secciones de cdigo o mtodos completos que necesitan ser ejecutados de uno en uno o dicho de mejor manera sincronizados.
25

1.2.2. Mquina virtual de JAVA

Qu es la JVM? Una Mquina Virtual de Java (JVM), es un software de proceso nativo, es decir, est desarrollada para una plataforma especfica que es capaz de interpretar y ejecutar un programa o aplicacin escrito en un cdigo binario (el ya mencionado bytecode) que se genera a partir del compilador de Java. En otras palabras, la JVM es la piedra angular del lenguaje de programacin Java. Es el componente que hace que Java tenga su particular y muy mencionada caracterstica multiplataforma, generar un cdigo compilado tan compacto y la capacidad del lenguaje de proteger a sus usuarios de cdigo malicioso. La JVM es una mquina de computacin de tipo abstracto. Emulando a una mquina de componentes reales, tiene un conjunto de instrucciones y utiliza diversas reas de memoria asignada para ella. La implementacin del primer prototipo de la JVM, hecho por Sun Microsystems, emulando todo su conjunto de instrucciones fue hecho sobre un hardware muy especfico, lo que hoy se podra conocer como los modernos Personal Digital Assistant (PDA). Las versiones actuales de la JVM estn disponibles para muchas (casi todas) las plataformas de computacin ms populares. Debe entenderse sin embargo que, la JVM no asume una tecnologa especfica o particular, esto es lo que la vuelve multiplataforma. Adems no es de por s interpretada, y que slo pueda funcionar de esta manera, de hecho es capaz de generar cdigo nativo de la plataforma especfica e incluso aceptar como parmetro de entrada, en lugar del bytecode, cdigo objeto compilado, por ejemplo funciones nativas de C. De igual manera puede implementarse en sistemas embebidos o directamente en el procesador. Cmo funciona la JVM? La JVM no sabe nada del lenguaje de programacin Java, no es de su inters, porque un compilador ya se encarg antes de ese proceso, slo le interesa un formato especfico de archivo, el formato de archivo de clase o entendido de otra manera, el bytecode ms una tabla de smbolos e informacin complementaria. Haciendo una apologa sobre la base de la seguridad la JVM impone formatos fuertes y limitaciones estructurales en el bytecode (por ejemplo los apuntadores a memoria, que ya se han mencionado en apartados anteriores). Sin embargo, cualquier lenguaje formal, con la funcionalidad que se pueda expresar en trminos de un archivo de bytecode vlido, puede ser organizado, interpretado y ejecutado por la JVM. Atrados por la gran Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 26

caracterstica multiplataforma que imprime la JVM al lenguaje Java, los programadores de otros lenguajes de programacin han recurrido a ella como vehculo de entrega (ejecucin) de estos lenguajes, lo que nos da a entender que su capacidad multiplataforma puede extender la implementacin de casi cualquier lenguaje que cumpla con sus reglas para ser multiplataforma. La funcionalidad completa, a manera de esquema se presenta en la siguiente figura:
Figura 1.1. Funcionalidad de la Mquina Virtual de JAVA (Zukowski, 1997).
1.2.3. Entorno de desarrollo y configuracin

Cuando se est inmerso dentro del mundo de desarrollo de software en Java, hay varias opciones sobre la manera en que se pueden generar aplicaciones. Por ejemplo podemos utilizar un editor de texto cualquiera (notepad) para poder capturar el cdigo fuente y guardarlo en el disco duro con el formato y la extensin correctos, para despus en una segunda parte, compilar dicho cdigo fuente y que nos arroje el bytecode a travs de la lnea de comandos haciendo una invocacin al compilador de Java. Obviamente se deber tener configurado en la estacin de trabajo la manera en que sta reconozca qu estamos haciendo y de dnde lo estamos llamando. Para cualquier (o casi cualquier) lenguaje de programacin, afortunadamente incluido Java, hay una serie de herramientas que facilitan enormemente el poder producir aplicaciones completas y slo requiriendo el esfuerzo del programador en las partes importantes del sistema, dejando a estas herramientas la preocupacin de las cosas Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 27

menos importantes. Para ejemplificar lo anterior se deber entender de la siguiente manera: Quien desarrolla slo deber preocuparse por los datos que involucren a su aplicacin, la manera de cmo obtenerlos, procesarlo y tal vez almacenarlos, preocuparse por entender las reglas del negocio al cual pretende generarle dicha aplicacin, cmo y en qu parte afectan estas reglas para su aplicacin y sus datos, la mejor manera de explotar el conocimiento que genere su aplicacin y no estar preocupado por configurar variables de entorno, preocupado por configurar conexiones a bases de datos ni aspectos especficos o variables complejas de los servidores de aplicaciones web, entre muchas otras cosas inherentes al sistema, no a la aplicacin. Las herramientas antes mencionadas, cuando se trabajan en conjunto como una sola unidad operativa, se le conoce como Entorno Integrado de Desarrollo (EID) o IDE por sus siglas en ingls (Integrated Development Environment), que podemos entenderlo como un programa de tipo informtico que conjunta al mismo tiempo varias herramientas tiles para la programacin de aplicaciones. El IDE puede estar enfocado a un lenguaje especfico o soportar una coleccin de ellos, como es usual en los IDEs modernos; por ejemplo el IDE ms popular de Microsoft es el Visual Studio en su versin 2010 (al momento de escribir este documento) y tiene soporte nativo para una variedad muy amplia de lenguajes soportados, e inclusive que se pueden mezclar. Cuando transportamos este concepto del IDE a Java, existen de igual manera varios de donde se puede hacer una eleccin, por ejemplo: Eclipse Borland JBuilder Sun Java Studio Creator NetBeans IBM WebSphere Studio Site Developer for Java Dreamweaver WebLogic Workshop Oracle JDeveloper IntelliJ Idea JCreator Nota: Todas las marcas o nombres de productos son propiedad de sus respectivos dueos y slo se usan a manera de ilustrar el ejemplo expuesto. Componentes del IDE Los elementos bsicos de un IDE, pero no limitado a ellos, son:
28

Un editor de texto, que es el programa o parte del IDE que nos permitir crear, abrir o modificar el archivo contenedor del cdigo fuente del lenguaje con el que estemos trabajando. Puede proporcionarnos muchas ventajas sobre un editor de texto separado del IDE, ya que por lo general cuentan con un resaltado de sintaxis sobre las partes que conforman el cdigo fuente de la aplicacin que se est construyendo. Un compilador, que es el programa o parte del IDE que nos permitir traducir el cdigo fuente escrito dentro del editor a lenguaje mquina (bytecode en el caso de Java). De tal manera que el programador pueda disear y programar una aplicacin utilizando palabras, frases o conceptos muy cercanos al lenguaje que utiliza normalmente, y el compilador se encargar de traducir estas sentencias en instrucciones comprensibles por el procesador de la computadora. Un intrprete, que es el programa o parte del IDE que nos permitir hacer la interpretacin del cdigo compilado (como en el caso de Java), en donde se toma como entrada el bytecode y el resultado es la ejecucin de las instrucciones de lenguaje mquina o cdigo objeto contenidas en esta estructura de clases. El compilador e intrprete pueden trabajar en conjunto como se explica en este apartado o ser procesos independientes para la ejecucin de un programa. Un depurador, que es el programa o parte del IDE que nos permitir probar y localizar errores dentro del cdigo de la aplicacin (mayormente de tipo lgico o de omisin) haciendo una traza de la ejecucin completa del cdigo y sealando dnde ser un posible error del cdigo o vulnerabilidad no considerada. Un constructor de interfaces grficas, que es la parte del IDE que nos facilita una serie de componentes nativos del lenguaje con el que trabajamos (swing en Java) para poder ofrecer al usuario un ambiente amigable de tipo visual, en pocas palabras nos permite crear interfaces grficas de usuario y complementarlas con el cdigo fuente de nuestra aplicacin. Opcionalmente la posibilidad de trabajar conectado a un servidor de control de versiones, que nos permitir llevar un control preciso de cada versin de cada archivo que comprenda nuestra aplicacin, particularmente til cuando se trabaja con aplicaciones de tipo empresarial que conllevan, inclusive, miles de archivos de cdigo fuente y al estar trabajando en grupo se vuelve indispensable esta funcionalidad que ofrece el IDE.
Configuracin del IDE Cuando se hace la instalacin de un IDE la configuracin que trae por defecto es la habitual y ser suficiente para poder comenzar a trabajar sobre l, la personalizacin que se haga de las distintas herramientas con las que cuenta depender del gusto de cada programador. Las posibles configuraciones que se hacen sobre el IDE van desde cosas tan simples como el tipo de letra y su tamao para mostrar el cdigo fuente, hasta
29

opciones muy avanzadas donde consumimos servicios web de determinado sitio de internet. Otra posible opcin de configuracin interesante sobre cada proyecto que se maneja en el IDE es de qu parte toma las clases base (independientes a las que proporciona Java) y cmo ser la salida de la aplicacin (jar, jar compimido, entre otros).
1.2.4. Tipos de datos soportados en JAVA

Tipo de dato Nmeros enteros Byte Short Int Tamao en bits 8-bit complemento a2 16-bit complemento a 2 32-bit complemento a 2 64-bit complemento a 2 Rango de valores -128 a 127 -32,768 a 32,767 Descripcin Entero de un byte Entero corto
Long Nmeros reales Float Doubl Otros tipos Char Booleano String
-2,147,483,648 a Entero 2,147,483,647 9,223,372,036,854,775,808L Entero largo a 9,223,372,036,854,775,807L +/- 3.4E+38F +/- 1.8E+308 Coma flotante con precisin simple Coma flotante con precisin doble Un solo carcter Un valor booleano Cadena de caracteres.
32-bit IEEE 754 64-bit IEEE 754
16-bit Carcter true o false Variable
Conjunto de caracteres Unicode ISO Verdadero o falo Conjunto de caracteres
La manera de identificar qu tipo de dato utilizar es analizar qu datos almacenar esa variable para definir su tipo de datos en base al rango de valores y descripcin dados en la tabla anterior. Para utilizar un dato debemos colocar al inicio el tipo de dato que queremos, seguido el nombre que tendr ese dato y un punto y coma si no se quiere dar un valor inicial, pero si se va a dar un valor colocamos una asignacin con un igual y el valor. Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 30

Ejemplo de utilizacin public class DataTypes { public static void main(String[] args) { int x; // un dato declarado pero sin valor inicial.
boolean isReal=true; // Los nombres son sensibles a // maysculas y minsculas, // deben empezar por una letra y // pueden contener nmeros,_,$ byte a = 121; // Deben ser inferiores a 126 short b = -10000; // Deben ser inferiores a 25000 int c = 100000; // Deben ser inferiores a 2100 mill. long d = 999999999999L; // Deben poner L al final float e = 234.99F; // Deben ser < 3E38; F al final double f = 55E100; char charValue= '4'; // char '4' no es el entero 4 //Las cadenas (strings) son objetos, no primitivos. //Ejemplo: String institucion = esad; } }
31

Actividad 4. Tipos de datos

Durante esta actividad identificars la aplicacin de los diferentes tipos de datos soportados por JAVA, en relacin con diferentes datos programables. 1. En un archivo de texto, copia la Tabla 1 y analiza los datos que incluye. 2. Identifica el tipo de datos que se requieren para programar como variable cada dato brindado. 3. Guarda la actividad con el nombre POO_U1_A3_XXYZ, sustituye las XX por las dos primeras letras del primer nombre, la Y por la inicial del apellido paterno y la Z por la inicial del apellido materno. 4. Enva el archivo a tu Facilitador(a) mediante la seccin Tareas para recibir retroalimentacin. Tabla 1 Datos de una casa Tipo Datos de un auto Tipo Datos de una factura Tipo Datos de un zapato Tipo Datos de una computa dora Tipo #_pisos #_cuartos #_ventanas #_baos Fondo
#_puertas
#_cilindros
#_hp
colorCarroceria
#_placas
#_folio
total
nombreCliente
nombreEmpresa
Iva
punto
material
Tacn
color
#_estilo
Marca
procesador
Memoria
pantalla
discoDuro
32

1.2.5. Operadores aritmticos, lgicos y relacionales

En el entorno Java, la palabra operador se le llama a un smbolo especfico que realiza una operacin determinada entre dos o ms valores, se puede entender con el procedimiento habitual que utilizamos para sumar, por ejemplo: 3+5=8 El operador de suma (representado por el smbolo +) est actuando sobre el 3 y el 5 para producir el 8. Como se puede ver, la evaluacin de los operadores y sus operandos siempre devuelve un valor, pues es la parte que define a las operaciones. Pueden tener notacin prefija o posfija, que se defina en la posicin que se coloquen los operadores respecto a sus operandos, as en la notacin prefija los operadores irn a la izquierda del operando (++a) y en la notacin posfija los operadores irn a la derecha de los operandos (a++). Existen varios tipos de operadores que se puede utilizar de distinta manera y arrojando resultados diferentes para la realizacin de operaciones, se listan a continuacin. Operadores aritmticos Operadores Significado ++ Incremento -Decremento + Unario + (smbolo positivo) Unario (smbolo negativo) * Multiplicacin / Divisin % Resto (mdulo) + Suma Resta Utilizacin de operadores aritmticos public class opAritmeticos { public static void main(String[] args) { int j, k, m; int d= 123; j= d--; // j vale 122 y d vale 123 System.out.println("j= " + j); Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 33 Asociatividad Derecha a izquierda Derecha a izquierda Derecha a izquierda Derecha a izquierda Izquierda a derecha Izquierda a derecha Izquierda a derecha Izquierda a derecha Izquierda a derecha

k= ++d; // k vale 124 y d vale 124 System.out.println("k= " + k); m= --d; // m vale 123 y d vale 123 System.out.println("m= " + m); m= k % j; // operador Resto para los tipos int // k=124 y j=122, por tanto, m= 2 System.out.println("m= " + m); j= 5; k= 3; m= j/k; // Divisin entera: m= 1 System.out.println("m= " + m); System.exit(0); } } Operadores lgicos Operador == > < && != >= <= || Utilizacin de operadores lgicos Descripcin Igual (comparacin de igualdad) Mayor que Menor que Conjuncin lgica (and) Distinto Mayor o igual que Menor o igual que Disyuncin lgica (or)
double c= 0.0, b= 3.0; if (c != 0.0 && b/c > 5.0){ System.out.println(se cumple la condicin solicitada); } Operadores de asignacin Se deber en primer trmino, hacer la distincin entre la accin de asignacin y el operador de comparacin (igualdad), aunque aparentemente al inicio pueda resultar confuso por el parecido entre ambos, lo que distingue uno de otro es precisamente el concepto que cada uno de ellos representa y la forma de presentarse, as pues: El operador = no es lo mismo que el operador == El operador bsico al utilizar la asignacin es =, que se utiliza para asignar un valor a otro. Como sigue: Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 34

int contador = 0; Iniciando la variable contador con un valor de 0. Adems de las facilidades ya descritas que nos proporciona el lenguaje Java, proporciona una forma abreviada de representar este tipo de operadores, con la finalidad de agilizar la escritura para los programadores. Se describen en la siguiente tabla: Operador += -= *= /= %= &= Operadores de bit Dan la posibilidad de manipular los bits de los datos, especialmente el desplazamiento. Operador >> << >>> Uso a >> b a << b a >>> b Operacin Desplaza los bits de a a la derecha b veces Desplaza los bits de a a la izquierda b veces Desplaza los bits de a a la derecha b veces (omitiendo el signo) Uso a += b a -= b a *= b a /= b a %= b a &= b Equivalente a a=a+b a=ab a=a*b a=a/b a=a%b a=a&b
La funcin especfica de este tipo de operadores es desplazar los bits del operando ubicado a la izquierda de la expresin el nmero de veces que indique el operador de la derecha. La direccin del operador indica hacia donde corrern los bits. La siguiente sentencia nos da a entender bien el concepto que se trata de implementar, al desplazar los bits del entero 25 a la derecha de su posicin: 25 >> 2 El nmero entero 25 est representado por el nmero 11001 en notacin binaria, al aplicarle el operador de desplazamiento el nmero 11001 ahora se convertir en 110 o el nmero entero 6. El lector debe notar que los bits que se desplazan a la derecha se pierden al efectuar esta operacin.
Precedencia de operadores Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 35

Java asigna (como se hace en las operaciones matemticas normales) una importancia muy alta a la precedencia de los operadores. En la siguiente tabla se lista esta precedencia y entre ms alta sea su posicin, ms importancia tendr: Operadores Operadores posfijos Operadores unario Creacin o conversin Multiplicacin Suma Desplazamiento Comparacin Igualdad AND a nivel de bit OR a nivel de bit XOR a nivel de bit AND lgico OR lgico Condicional Asignacin Representacin [], (), a++, a-++a, --a, +a, -a, ~, ! new(tipo) a *, /, % +, << == ==, != & ^ | && || ?: =, +=, -=, *=, /=, &=, ^=, |=, <<===
Actividad 5. Operadores
Durante esta actividad realizars un ejercicio donde recuperes lo que has aprendido acerca de los operadores soportados por JAVA. Realiza lo siguiente: 1. En un archivo de texto, copia las operaciones dadas en la Tabla 2. 2. Completa los datos que se solicitan en las columnas vacas. Para ello, identifica los operadores encontrados en cada operacin, su tipo de operador y el resultado de dicha operacin. 3. Guarda la actividad con el nombre POO_U1_A4_XXYZ, sustituye las XX por las dos primeras letras del primer nombre, la Y por la inicial del apellido paterno y la Z por la inicial del apellido materno. 4. Enva el archivo a tu Facilitador(a) para recibir retroalimentacin. Tabla 2 Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 36

# 1 2 3 4 5
Operacin (3 + (2 *3) -12) / 3 P: Verdadero Q: Falso PyQ 10> 5 >6 (((200 +305)/56)*30)<12 P: 3+9<10 Q:30 -64 > - 40 PoQ
Operadores encontrados
Tipo de operadores
Resultado
1.2.6. Conversin de tipos de datos

La conversin de tipos de datos (conocida tambin como casting) es pasar un objeto de un tipo en otro. Se puede ejemplificar de manera clara pensando en que si tienes un pequeo programa que tiene dos nmeros enteros, el resultado de la divisin se almacena tambin en un entero, y quieres dividirlos, el resultado se truncar a un entero tambin, pues solo ests tomando en cuenta la capacidad de almacenamiento de los enteros. El cdigo y resultado sera como se muestra a continuacin:
public class EjamploCast { public static void main(String[] args) { int di=33; int dv=5; int c=di/dv; System.out.print(c+ "\n"); } }
Como vemos, el resultado se trunc hasta el valor entero.
37

Pero si en el resultado es importante tomar en cuenta tambin los decimales para tener un resultado ms preciso debemos convertir el entero a flotante, eso se realiza de la siguiente manera. float c= (float) di/dv; Colocando el tipo de dato al que se convertir entre parntesis, ahora nuestro resultado mostrar los decimales que necesitamos.
En este caso el resultado si tiene los decimales que necesitamos. En un ejemplo ms amplio si se tienen3 clases A, B y C que se pueden almacenar en un arreglo de la siguiente manera: Object [] array = new Object[3]; array[0] = new A(); array[1] = new B(); array[2] = new C(); Si ahora se quiere usar estos objetos, se tendr que hacer un cambio entre resultados que los tienes como array[i], que son Object, y no puedes llamar a mtodos especficos de las clases A, B y C. La forma de recuperar las clases originales es con un cast, que al igual que el ejemplo anterior debes colocar el tipo al que quieres convertir entre parnesis antes del dato que se convertir, entonces se pone el tipo A delante, entre parntesis. ((A)array[0]).metodoDeA(); Obviamente no puedes convertir cualquier tipo a cualquier tipo. Si intentas convertir array[0] a B, te dar error, salvo que A herede de B. Pero estos casos ms complejos los trataremos ms adelante.
1.3. Organizacin de un programa

Java guarda una enorme semejanza con C/C++ por lo que no es difcil poder entender ni interpretar su cdigo cuando se est familiarizado con estos lenguajes. De igual manera como Java sigue el paradigma de la Programacin Orientada a Objetos (POO) en cdigo del lenguaje se construye a partir de la escritura de clases.
38

Durante esta unidad se sugiere que se realicen todos los ejemplos en el entorno de desarrollo para que lo tengas instalado y funcional desde esta primera unidad, ya que se estar utilizando a lo largo de toda la materia, adems se sugiere que escribas, compiles y ejecutes los ejemplos de programas que se desarrollaron en esta unidad, para que se comprenda mejor lo visto.
1.3.1. Estructura General

La estructura general se describe a continuacin: Todo parte de una clase. Partiendo desde la concepcin ms simple de un programa en Java, este se puede escribir a partir de una sola clase y conforme la complejidad de la aplicacin vaya en aumento, muy probablemente (de hecho lo es) el nmero de clases va a ir en aumento, se podra entender como una correlacin directa. Por definicin cada clase necesita un punto de entrada por donde comenzar la ejecucin del programa, y la clase escrita debe contenerlo como el programa, rutina o mtodo principal: main() y dentro de este mtodo contiene las llamadas a todas las subrutinas o dems partes de la clase o incluso de la aplicacin en general. Una estructura simple pero funcional de un programa en Java sera como sigue: public class inicio{ public static void main(String[] args){ Primer_sentencia; Sentecia_siguiente; Otra_sentencia; // Sentencia_final; } //cierre del mtodo main } // cierre de la clase Al hacer la implementacin del ejemplo anterior a algo un poco ms real y palpable se sugiere como primer acercamiento un programa sencillo escrito en lenguaje Java que muestre en pantalla un mensaje de bienvenida a la programacin en Java. /** * La clase bienvenida construye un programa que * muestra un mensaje en pantalla */ public class bienvenida { public static void main(String[] args) { System.out.println("Hola, "); System.out.println("bienvenido (a)"); Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 39

System.out.println("a la programacin en Java"); } } Para comprender mejor lo que hace el programa y las partes que lo conforman se explicar. Bienvenida es el nombre de la clase principal y por tanto, del archivo que contiene el cdigo fuente (por convencin de Java, el archivo donde se guarda el cdigo fuente deber tener el mismo nombre de la clase principal). Como ya se ha explicado antes, todos los programas en Java tienen un mtodo principal de entrada conocido como main que a su vez contiene (encierra) un conjunto de sentencias que significan las instrucciones que deber ejecutar el programa, este conjunto de instrucciones o bloque de instrucciones en Java se indican con la utilizacin de llaves { }. En el programa contenido en la clase bienvenida el bloque se compone slo de tres instrucciones de impresin a pantalla. Utilizacin de comentarios. Desde el surgimiento de los lenguajes de programacin, junto con ellos, de igual manera naci la necesidad de hacer anotaciones sobre lo que hace tal instruccin, un mtodo completo o inclusive el programa entero. Esta necesidad se resolvi con la introduccin del soporte de comentarios (notas) dentro del mismo cdigo fuente que se pueden emplear de distintas formas, por ejemplo recordar para qu se us una variable especfica, para documentar los valores de retorno de un mtodo, entre muchos otros. Los comentarios que se utilizan en Java son del mismo estilo a los empleados en C/C++, as el compilador al comenzar a hacer su trabajo ignora por completo lo que est entre estos comentarios ya que no forman parte del cdigo del programa, slo son lneas de carcter informativo para el programador humano. Hay comentarios de una lnea y de varias lneas, por ejemplo: // Este es un comentario escrito en una sola lnea y para hacer comentarios breves y concisos. Como se puede observar el comentario comienza con un par de caracteres del tipo / y ntese que no se deja espacio alguna entre ellos, despus de esto se puede comenzar a escribir el cuerpo del comentario de una sola lnea. Cuando hay la necesidad de hacer observaciones muy amplias y que una lnea no nos d el espacio suficiente se sugiere utilizar comentarios de varias lneas, por ejemplo; /* Este es un comentario muy amplio y se puede hacer con la utilizacin de varias lneas sin perder la continuidad de la idea e indicndole al compilador que ignore por completo todas las lneas que lo comprenden. */ De igual forma que en los comentarios de una sola lnea, los comentarios multilnea comienzan con el par de caracteres /* y terminan con el par de caracteres */.
40

Adems en Java existe un tercer tipo de comentario que se le conoce como comentario de documentacin y este tipo la funcin que tienes es que le indica al programa generador de documentacin que lo incluya a l e ignore de los dems, por ejemplo: /** Comentario de documentacin del programa */ El lector debe notar que la forma de comenzar el comentario es ligeramente diferente al comentario multilnea, ya que ahora se incluye un asterisco ms, para quedar como /**. La forma de terminarlo es la misma. Como sugerencia sobre los comentarios se debe hacer notar que, la necesidad de escribir comentarios es para la aclaracin de ciertas partes del cdigo que no estn muy claras, por tanto si se exagera en el nmero de comentarios se entender que el cdigo no es claro y se deber considerar la necesidad de reescribirlo para hacerlo comprensible. Identificadores Se entender al identificador como aquella palabra o nombre que el programador le asigna a sus propias variables, mtodos e inclusive nombres de clases y tiene un mbito de aplicacin e injerencia slo dentro del cdigo fuente, escrito por el programador humano porque una vez que pasa por el proceso de compilacin, el compilador genera sus propios identificadores ms acorde y ms ptimos para su propia interpretacin dentro del bytecode. Como regla general del lenguaje Java se debe definir un identificador antes de ser utilizado. Siguiendo las reglas que Java establece para la creacin de identificadores se deber apegar a lo siguiente: Un identificador comienza por una letra o utilizando el carcter de guin bajo (_) e inclusive utilizando el smbolo de pesos ($) aunque esto ltimo no se recomienda ya que, como se explic, el compilador lo utiliza de forma muy frecuente para formar sus propios identificadores. Se pueden utilizar a continuacin nmeros (0 al 9). Pero no dejar espacios en blanco, signo de interrogacin (?) o smbolo de porcentaje (%). Un identificador puede contener la longitud que el programador asigne arbitrariamente o considere necesario para dejar perfectamente claro el propsito del identificador y qu tipo de dato alojar. En Java, al ser sensible al contexto, se distinguen los caracteres en mayscula y minscula. As promedio, Promedio y PROMEDIO sern locaciones de memoria completamente diferentes. No se puede repetir el mismo identificador para dos variables o cualquier otra parte del cdigo (nombres de mtodos o clases por ejemplo) ya que como se ha mencionado, los identificadores hacen precisamente eso, identifican de manera nica a cada parte del cdigo. Aunque la escritura de identificadores no est normalizada en Java, se puede apegar a las siguientes recomendaciones:
41

Identificadores autoexplicativos, para guiar al usuario (de cualquier tipo) a entender la utilizacin de dicho identificador sin la necesidad de utilizar comentarios. Por ejemplo para alojar el resultado del promedio de n nmeros enteros se sugiere utilizar el identificador resultadoPromedio o resAvg. Si el identificador est compuesto por dos o ms palabras, stas se agrupan, la primera de ellas se escribe totalmente en minscula y la primera letra de las subsecuentes se escribe con mayscula, por ejemplo: resultadoPromedioCalificaciones o longitudMedida. Como se mencion se puede utilizar el smbolo de guin bajo (_) pero por convencin slo se emplea al nombrar constantes, ya que estas (igual por convencin) debern escribirse en letra mayscula y dificulta la lectura y separacin de la misma, por ejemplo: VALOR_GENERAL_ANUAL.
1.3.2. Convenciones de la programacin

Paquetes (Packages): El nombre de los paquetes deben ser sustantivos escritos con minsculas. package shipping.object Clases (Classes): Los nombres de las clases deben ser sustantivos, mezclando palabras, con la primera letra de cada palabra en mayscula (capitalizada). class AccountBook Interfaces (Interfaces): El nombre de la interfaz debe ser capitalizado como los nombres de las clases. interface Account Mtodos (Methods): Los mtodos deben ser nombrados con verbos, mezclando palabras, con la primera letra en minscula. Dentro del nombre del mtodo, la primera letra de cada palabra capitalizada. balanceAccount() Variables (Variables): Todas las variables deben ser combinaciones de palabras, con la primera letra en minscula. Las palabras son separadas por las letras capitales. Moderar el uso de los guiones bajos, y no usar el signo de dlares ($) porque tiene un significado especial dentro de las clases. currentCustomer Las variables deben tener significados transparentes para exponer explcitamente su uso al lector casual. Evitar usar simples caracteres (i, j, k) como variables excepto para casos temporales como ciclos. Constantes (Constants): Las constantes deben nombrarse totalmente en maysculas, separando las palabras con guiones bajos. Las constantes tipo objeto pueden usar una mezcla de letras en maysculas y minsculas. HEAD_COUNT MAXIMUN_SIZE. Estructuras de Control (Control Structures): Usar Llaves ({ }) alrededor de las sentencias, aun cuando sean sentencias sencillas, son parte de una estructura de control, tales como un if-else o un ciclo for (estas estructuras se explicarn a fondo en la siguiente unidad). 42

if ( condicin ){ Sentencia1; } else { Sentencia2; } Espaciado (Spacing): Colocar una sentencia por lnea, y usar de dos a cuatros lneas vacas entre sentencias para hacer el cdigo legible. El nmero de espacios puede depender mucho del estndar que se use. Comentarios (Comments): Utilizar comentarios para explicar los segmentos de cdigo que no son obvios. Utilizar // para comentar una sola lnea; para comentar extensiones ms grandes de informacin encerrar entre los smbolos delimitadores /* */. Utilizar los smbolos /** */ para documentar los comentarios para proveer una entrada al javadoc y generar un HTML con el cdigo. //Un comentario de una sola lnea /*Comentarios que pueden abarcas ms de una lnea*/ /**Un cometario para propsitos de documentacin *@see otra clase para ms informacin */ Nota: la etiqueta @see es especial para javadoc para darle un efecto de tambin ver a un link que referencia una clase o un mtodo.
1.3.3. Palabras reservadas

Se entiende como palabra reservada a un tipo especial de identificadores que slo puede emplear el lenguaje Java, es decir su uso es exclusivo del lenguaje y el programador no puede hacer uso de ellas para nombrar mtodos, clases, variables o cualquier otra parte del cdigo fuente, se presentan estas palabras reservadas en la siguiente tabla: Abstract Boolean Break Byte Case Catch Char Class const* Do Doubl Else Extends False Final Finally Float For implements import instanceof Int interface long native New Null protected Public Rest return Short Static strictftp Super switch Throw Throws Transient True Try Void Volatile While
43

continue Default
goto* If
package private
synchronized This
Aunque la definicin del lenguaje Java toma en cuenta todas estas palabras, en su implementacin no se toman en cuenta todas, las que estn marcadas con un asterisco an no tienen utilizacin. Tambin existen palabras reservadas de empleo especfico para nombres de mtodos y stas son: Clone Notify Equals notifyAll finalize toString getClass Wait hashCode
1.3.4. Estructura de una clase

Apegndose estrictamente a los lineamientos que genera la documentacin de Java, una clase deber contener las siguientes partes: Package: Es el apartado que contendr la definicin de directorios o jerarqua de acceso a donde estar alojada la clase. Import: Sentencia necesaria para poder invocar todos las paquetes necesarios (contenidos en otros packages) para que nuestra aplicacin funcione. Por ejemplo, al tratar de utilizar una conexin hacia una base de datos, necesitaremos importar los paquetes que me proporcionan la funcionalidad necesaria. Algunos paquetes de Java se importan automticamente, no es necesario hacer un import explcito, como la librera java.lang Class: Definicin del nombre de clase. Se determina el nombre identificador que contendr la clase. Variables de mbito de clase: Se determinan las variables que se usarn en la clase para guardar datos y hacer operaciones. Constructor de la clase: El constructor es un tipo especial de mtodo, que se invoca automticamente al hacer una instancia del objeto. Sirve para inicializar los objetos, las variables o cualquier configuracin inicial que necesite la clase para funcionar. Se puede sobrecargar. Mtodos: Bloques de cdigo que contienen las instrucciones y declaraciones que ejecutar el programa. Ejemplo package javaapplication1; import javax.swing.*; Uso Paquete import si se requiere
44

public class JavaApplication1 { public JavaApplication1(){} public static void main(String[] args) { //instrucciones } }
declaracin de la clase constructor declaracin del mtodo cuerpo del mtodo cierre del mtodo cierre de la clase
1.3.5. Declaracin de objetos y constructores

El elemento bsico de la programacin en Java es la clase. Una clase define mtodos (comportamiento) y atributos (forma) de un objeto. Esto significa que se mapea la clase hacia un objeto. Allan Kay (citado en Zukowski, 1997) describi las 5 principales caractersticas de Smalltalk, uno de los primeros lenguajes orientados a objetos y uno de los lenguajes en los cuales est basado Java: Todo es un objeto: Considere un objeto una variable especial, no solamente guarda datos, sino tambin se pueden hacer solicitudes a este objeto en s. En teora, cualquier elemento en el problema espacial (real) (edificios, servicios, automviles, u otra entidad) puede ser representado como un objeto en un programa. Un programa es un conjunto de objetos, envindose mensajes entre s: para realizar una solicitud a un objeto es necesario enviarle un mensaje. Concretamente se puede pensar que un mensaje es una solicitud para llamar una funcin que pertenece a cierto objeto. Cada objeto tiene su memoria, conformada por otros objetos: en otras palabras, es posible generar un tipo de objeto nuevo agrupando objetos existentes. De esta manera se pueden armar estructuras complejas en un programa, escondidas detrs de la simplicidad de objetos. Todo objeto tiene su tipo: en este sentido tipo se refiere a clase, donde cada objeto es una instancia de una clase en cuestin. La caracterstica ms importante de una clase es el tipo de mensajes que pueden ser enviados a ella. Todo objeto de un mismo tipo puede recibir los mismos mensajes: esto implica que si un objeto es del tipo crculo, un objeto del tipo figura ser capaz de recibir mensajes de crculo, puesto que un crculo es una Figura. Este concepto forma parte medular de todo lenguaje orientado a objetos y ser explorado en una seccin especfica de este curso. (Zulowski, 1997: 1) Nombre de la clase de la cual se instanciar el objeto 45
empleado

objetoE = New empleado() =new empleado();
Nombre del objeto Asignacin Palabra new para hacer la separacin de la memoria. Invocacin al constructor Cierre de la instanciacin
Quedando la instruccin como sigue: empleado objetoE=new empleado(); Constructores Un constructor es un mtodo especial en Java empleado para inicializar valores en instancias de objetos, a travs de este tipo de mtodos es posible generar diversos tipos de instancias para la clase en cuestin; la principal caracterstica de este tipo de mtodos es que llevan el mismo nombre de la clase. Si la clase se llama empleado su declaracin sera: public class empleado { } El constructor debera quedar como sigue public empleado(){} Y se usan para poder crear instancias de la clase (objetos).
Autoevaluacin
Para reforzar los conocimientos relacionados con los temas que se abordaron en esta primera unidad del curso, es necesario que resuelvas la autoevaluacin de la unidad. Recuerda que es muy importante leer cuidadosamente los planteamientos indicados y elegir la opcin adecuada para cada uno. Ingresa al aula para realizar la actividad.
46

Evidencia de aprendizaje. Programa en JAVA

Como parte de la evaluacin, desarrollars un programa bsico para la solucin de operaciones matemticas simples en el que aplicars los componentes de JAVA, que durante la unidad has revisado. Realiza lo siguiente: 1. En NetBeans crea un nuevo proyecto, y dentro de la clase Main crea un programa, donde se definan dos nmeros, se resten y se multipliquen, para despus mostrar el resultado en la pantalla. 2. Consulta la Escala de evaluacin que se encuentra en la seccin Material de apoyo, para conocer los criterios con que ser evaluado tu trabajo. 3. Guarda la evidencia con el nombre POO_U1_A5_XXYZ. Sustituye las XX por las dos primeras letras del primer nombre, la Y por la inicial del apellido paterno y la Z por la inicial del apellido materno. 4. Enva la carpeta del proyecto a tu Facilitador(a) mediante la herramienta Portafolio de evidencias para recibir retroalimentacin. *Recuerda que puedes volver a enviar tu archivo tomando en cuenta las observaciones de tu Facilitador(a).
Autorreflexiones
Adems de enviar tu trabajo de la Evidencia de aprendizaje, es importante que ingreses al foro Preguntas de Autorreflexin y consultes las preguntas que tu Facilitador(a) presente, a partir de ellas, debes elaborar tu Autorreflexin en un archivo de texto llamado POO_U1_ATR_XXYZ. Posteriormente enva tu archivo mediante la herramienta Autorreflexiones.
Cierre de la unidad
Has concluido la primera unidad del curso. A lo largo de sta te has introducido a la programacin orientada a objetos y sus principales caractersticas como abstraccin, polimorfismo, encapsulacin y herencia; tambin has estudiado la diferencia entre la orientacin a objetos y la programacin estructurada. Posteriormente te involucraste en las caractersticas del lenguaje JAVA, sus tipos de datos soportados, tipos de operadores
47

y conversin de tipos de datos. Estos temas han servido para que vayas conociendo el ambiente de desarrollo de programas computacionales. Al final de la unidad tambin vimos la estructura de un programa, palabras reservadas, estructura de una clase, declaracin de objetos y constructores, cuyo propsito fue proporcionarte un panorama general de programar. Es aconsejable que revises nuevamente la unidad en caso de que los temas que se acaban de mencionar no te sean familiares o no los recuerdes, de no ser este tu caso, ya ests preparado(a) para seguir con la unidad dos, en donde continuars con la revisin de los mtodos y las estructuras de control. Todo ello con el fin de obtener el conocimiento necesario para comenzar a realizar pequeos programas computacionales al final de la cuarta y ltima unidad del curso de Programacin Orientada a Objetos I.
Para saber ms
Es importante que instales un IDE en tu computadora personal para que pases todos los ejemplos de cdigo y veas cmo funcionan, de esta manera podrs analizar el funcionamiento de los cdigos presentados. *Nota: se recomienda que instales NetBeans 7.0, como IDE, por su facilidad de uso, este puede ser descargado gratuitamente de la siguiente liga: http://netbeans.org/downloads/
Fuentes de consulta
Bibliografa bsica Devis, R. (1993). C++/OOP: un enfoque prctico. Madrid, Espaa: Editorial Paraninfo. Recuperado el 1 de marzo de 2011, de: http://www.a4devis.com/articulos/libros/Programaci%C3%B3n%20Orientada-aObjetos%20en%20C++.pdf Joyanes, L. (2001). OLC - Programacin en C++. Serie Schaum, Captulo 1: Programacin orientada a objetos versus programacin estructurada: C++ y 48

algoritmos. Espaa: McGrawHill Interamericana de Espaa SL. Recuperado el 1 de marzo del 2011, de: http://www.mcgraw-hill.es/bcv/guide/capitulo/8448146433.pdf Joyanes, L. y Fernndez, M. (2001). Java 2: manual de programacin. Espaa: McGrawHill Interamericana de Espaa SL. Zukowski. J. (1997). The Java AWT Reference (Java Series), version 1.2. O'Reilly & Associates. Recuperado el 1 de marzo de 2011, de: http://oreilly.com/openbook/javawt/book/index.html
Bibliografa complementaria Flanagan, D. (2005). Java in a NutShell. USA: O'Reilly & Associates.
49

Unidad 2. Mtodos y estructuras de control Presentacin de la unidad

En la unidad anterior se vieron temas introductorios para la programacin OO, cuyos temas fungieron como iniciacin para comprender el uso y aplicacin de la programacin. En esta unidad de POO I, aprenders el concepto de los mtodos y su utilizacin para crear programas modulares, as como el manejo de las estructuras de control selectivas y cclicas. Todo esto se utilizar para que realices programas ms completos y complejos en la siguiente unidad sobre la aplicacin de las caractersticas de POO y las excepciones.
Propsito
En esta unidad logrars: o Describir las generalidades de los mtodos. o Distinguir los mtodos que devuelven valores contra los que no devuelven. o Manejar las estructuras de control selectivas y cclicas.
Desarrollar programas modulares para solucionar problemas diversos, mediante la aplicacin de los diferentes tipos de variables, mtodos, y estructuras de control en lenguaje JAVA.
Consideraciones especficas de la unidad: actividades, requerimientos de asignatura, etc.

Es muy importante que captures todos los programas de ejemplo, para que analices su sintaxis y puedas comprender mejor los temas vistos.
50

2.1. Generalidades de los mtodos

Cuando se est trabajando en el lenguaje de programacin Java, la clase es el elemento bsico que lo conforma, pero a su vez la clase est conformada por varios sub-bloques de cdigo que la conforman. Estos sub-bloques se llaman mtodos y agrupan de manera ms o menos ordenada a los algoritmos que conforman el cuerpo de nuestro programa o aplicacin. Los mtodos (todos) tienen cierta estructura que los distinguen de las dems elementos del lenguaje Java, la estructura clsica de un mtodo es la siguiente: tipo_devuelto nombre_mtodo([parmetros]){ sentencia1; sentencia2; sentenciaN; } Ntese que el elemento [parmetros] est delimitado por corchetes, lo que quiere decir que es un elemento opcional. Cuando los parmetros se manejan como lista de ellos, o sea ms de uno, se separa esta lista con una coma entre cada uno. Adems de lo anterior, podremos entender a los mtodos como: Un bloque de cdigo que tiene un nombre, Capaces de recibir parmetros o argumentos (opcionalmente, como ya se dijo), Contienen sentencias que le permiten realizar la tarea para la cual fue creado y Devuelven un valor de algn Tipo (recordar el tema de tipo de datos) conocido.
2.1.1. Declaracin y mbito de variables

Haciendo referencia al apartado de tipos de datos, se hablar ahora del concepto de variable que se entender como una locacin de memoria reservada para alojar un dato que cambiar respecto al tiempo/espacio donde se ejecute la aplicacin. Tienen asociado un identificador y un tipo de dato que le da nombre (identificador) y qu guardaremos en ella (tipo de dato); lo que es aplicable a Java y cualquier otro lenguaje de programacin. En Java, cuando se va a hacer uso de una variable primero se debe declarar, es decir, indicarle al compilador que hemos reservado esa locacin de memoria para poder alojar un dato de inters para nuestra aplicacin, de no ser as y aunque pongamos un identificador a la variable, Java nos indicar que no est definida. En funcin a los datos que almacenan las variables se clasifican en:
51

Variables primitivas: sirven para almacenar datos numricos, valores lgicos o caracteres. Variables referenciadas: asociadas a un objeto o son la instancia de una clase.
Para profundizar un poco ms en el concepto de variable se dir que una variable no es nada ms que un contenedor de bits que representan un valor. Se entender de la siguiente manera: Cuando se habla de variables primitivas, los bits que forman esta variable slo representan un nmero que coincide con el valor asignado a la misma variable y como se indic, puede quedarse conteniendo ese valor o puede cambiar a lo largo de la ejecucin del programa. Por ejemplo, relacionando lo expuesto ahora con el tema de tipos de dato se tiene que hay variables de tipo byte (con una longitud de 8 bits en memoria) y puede almacenar nmeros enteros con signo entre -128 y 127 (cuando no se utiliza el signo el valor puede ser hasta 255), de tipo int (con una longitud de 32 bits en memoria) para almacenar nmeros enteros con signo entre -2,147,483,648 al 2,147,483,647, de tipo float con sus respectivos lmites hasta abarcar todos los tipos de dato. Visto de manera grfica pudiera quedar como sigue: byte z = 5; // declaracin de variable de tipo byte vlida en java
Cuando se habla de variables referenciadas o asociadas a un objeto, los bits representan un identificador que permite acceder al valor de la variable, es decir nos da una referencia al objeto, pero no es el objeto a la variable en s. Visto de manera grfica, pudiera quedar como sigue:
52

Integer z=new Integer(100); //declaracin de una variable de tipo objeto Integer, vlido en Java.
Se muestra a continuacin algunos ejemplos de declaraciones de variables referentes a Java, para los tipos de variables primitivas y las variables referenciadas o asociadas a un objeto: int a; // declaracin de una variable 'a' de tipo entero //su valor inicial (por definicin) es 0. int b = 10; // declaracin de una variable 'b' de tipo entero // con valor inicial establecido a 10. Nombre_Clase referencia; // declaracin de una variable con identificador 'referencia' // donde su tipo de dato ser 'Nombre_Clase' o dicho de otra manera // aqu es donde se crea el contenedor. Nombre_Clase referencia2; // mismo caso que la variable anterior, // pero el identificador ahora es 'referencia2'. referencia = new Nombre_Clase; // En este tipo de variables la declaracin no es suficiente se deber crear // un nuevo objeto de la clase 'Nombre_Clase', y es asignado a la variable // 'referencia'. En el paso anterior se dijo que se crea el contenedor, // en este paso se le asigna un valor (referencia al objeto) al contenedor. referencia2 = referencia; Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 53

// Ahora tambin 'referencia2' tiene el mismo // objeto a su cargo que 'referencia' Ahora que se ha aclarado un poco la idea de qu es una variable, sus componentes principales y el modo en que se hace una declaracin de la misma, debemos considerar las distintas partes del programa donde la utilizaremos. Es lo que se conoce como mbito de la variable. Este concepto, es uno de los ms importantes que debemos conocer cuando estamos trabajando y manipulando variables. Se llama mbito de una variable al lugar donde sta est disponible. Por lo general cuando declaramos una variable, slo estar disponible en el bloque de cdigo (encerrado entre llaves) donde se ha declarado, que puede ser desde el mbito de la clase completa, el mbito slo de un mtodo o incluso dentro del mbito de los elementos que conforman un mtodo, por ejemplo una sentencia if, una sentencia while, una sentencia for y entre todos los tipos disponibles que tenga Java. Por ejemplo: public class AmbitoVariables{ public static void main(String[] args){ if (true) { int a=10; //Decalaracin de la variable dentro del bloque que corresponde // a la sentencia if (dentro del mbito del if). } System.out.println(a); // Acceso a la variable fuera del mbito donde //fue declarada (fuera del bloque if, delimitado //por llaves). } }
Al compilar esta pequea clase de ejemplo, se notar que el compilador de Java lanza un mensaje de error que indicar que la variable a la que se hace referencia (variable con identificador a) no ha sido encontrada, en otras palabras, su declaracin no est dentro del mbito en donde se pretende usar. El mensaje de error del compilador de Java tendr un aspecto como se muestra en las siguientes imgenes.
54

Figura 1
Figura 2
Se puede notar claramente que en la primer imagen (Figura 1) el IDE nos est indicando algn tipo de error en la lnea 21, sealando la variable con identificador a como la posible causa. En la segunda imagen (Figura 2) nos da los detalles completos de la causa del error, el programador deber entender que no se puede encontrar el smbolo (variable) especificado. Hay ms normas de mbito respecto a las variables miembro de una clase, donde intervienen los modificadores de acceso public o private. Cuando una variable es declarada con el modificador public se accede directamente a ellas a travs de nombre_clase.nombre_variable y en el caso de que una variable sea declarada con el modificador private slo se podr acceder a ella mediante los mtodos de la clase que lo permitan.
2.1.2. Declaracin de constantes

Desde la concepcin de la definicin del lenguaje Java, no fueron consideradas las constantes en su trmino ms estricto, entendidas como un valor que no puede ser alterado durante la ejecucin de un programa y corresponde a una longitud fija en la memoria de la computadora donde se ejecuta el programa. Sin embargo, para hacer frente a esta pequea inconveniencia del lenguaje, una declaracin de variable como static final se puede considerar una constante muy efectiva. El modificador static permite el acceso a una variable miembro de una determinada clase sin haber cargado una instancia de sta donde ser utilizada. El modificador final provoca que la variable (su contenido) no pueda ser cambiada.
55

La siguiente declaracin define la constante llamada PI cuyo valor est definido por el nmero (3.1415927). static final float PI = 3.1415927; //Constante que representa el nmero PI Como ya se dijo, si se intenta modificar el valor contenido en la variable identificada como PI, se dar un error de compilacin.
2.2. Mtodos que no devuelven valores

Una vez que ya se conoci las generalidades sobre los mtodos, se deber conocer que existen dos tipos cuando se habla de ellos: Mtodos que retornan valores. Mtodos que no retornan valores. En este apartado se analizarn los mtodos que no regresan valores.
2.2.1. Caractersticas
El hecho de que un mtodo regrese valores o no es opcional. Cuando un mtodo no retorna valores, se deber modificar la definicin de sus parmetros y quedar como sigue: void nombre_mtodo([parmetros]){ sentencia1; sentencia2; sentenciaN; } En donde se deber utilizar la palabra reservada void que le indica al compilador y al mtodo que su valor de retorno ser vacio. Dentro del cuerpo de sus sentencias se omite la sentencia return por no regresar valor alguno a donde fue llamado. Los parmetros de igual manera son opcionales, aunque los parntesis van por obligacin.
2.2.2. Llamada de mtodos

Cuando decimos que llamamos un mtodo, estamos haciendo uso de las sentencias que lo conforman. De igual manera se dice que se invoca al mtodo.
56

Los mtodos se invocan (llaman) por el nombre definido en su declaracin y se deber pasar la lista de argumentos entre parntesis. Por ejemplo, se definir un mtodo que imprima a pantalla un mensaje para el usuario. public void saludo_usuario(){ String cadena_Saludo = Hola usuario, feliz viaje en Java; System.out.println(cadena_Saludo); System.out.println(Mensaje impreso desde un mtodo); } Cuando ya se ha definido el mtodo y sus sentencias son las necesarias y adecuadas, ahora si se hace una invocacin a l, o mejor dicho, se invocan las sentencias que conforman el cuerpo del mtodo. Se hace de la siguiente manera: public static void main(String[] args){ saludo_usuario(); } La salida ser la siguiente: Hola usuario, feliz viaje en Java Mensaje impreso desde un mtodo
2.3. Mtodos que devuelven valores

Por definicin del lenguaje Java, todos los mtodos deberan regresar valores, excepto en los casos explicados en el apartado anterior. Cuando los mtodos declarados en Java regresan valores, quiere decir que se espera recibir alguna respuesta o resultado de alguna operacin realizada por las sentencias que conforman su cuerpo. Para que un mtodo pueda regresar valores, deben estar involucrados varios factores que le ayuden o alimenten para poder realizar dichas operaciones. Estos elementos bsicos son: Parmetros de entrada, que son las entradas propias del mtodo que le ayudarn a saber sobre qu se realizarn las operaciones indicadas en las sentencias que lo conforman, aunque este apartado se puede considerar opcional. Parmetros de retorno, que es la respuesta que nos regresar una vez que haya ejecutado el cuerpo de sus sentencias. En los apartados siguientes se explicar con ms detalle los elementos mencionados y algunos otros que son necesarios para los mtodos que regresan valores.
57

2.3.1. Recepcin de parmetros

Los parmetros de un mtodo se pueden entender como los valores que ste recibe desde la parte del cdigo donde es invocado. Los parmetros pueden ser de tipos primitivos (int, double, float, entre otros) u objetos. Como ya se ha visto, en la declaracin del mtodo se escribe qu parmetros recibir dentro de los parntesis separando cada uno de ellos por una coma, indicando el tipo de cada uno de ellos y el identificador, se entender tambin que no hay lmites en el nmero de parmetros que se envan al mtodo. Se presenta un ejemplo: public int obtener_potencia(int base, int potencia){ } Este mtodo recibe dos parmetros de tipo entero, cuyos identificadores son base y potencia.
2.3.2. Retorno de parmetros

Cuando el mtodo de nuestro inters ya ha recibido (o consigue) los elementos necesarios para poder realizar sus funciones, retornar el resultado de aplicar esas funciones sobre los parmetros recibidos. Se deber indicar en la declaracin del mtodo qu tipo de dato retornar e indicarle en el cuerpo de sus sentencias la palabra reservada return y aqu le indicaremos qu regresar. Se ilustra un ejemplo a continuacin: public int obtener_potencia(int base, int potencia){ int resultado = Math.pow(base, potencia); return resultado; } Las partes del cdigo que estn resaltadas indican el retorno de parmetros del resultado de obtener la potencia de los parmetros recibidos (base y potencia). El lector deber notar que el tipo de dato declarado en la definicin del mtodo es el mismo que el utilizado en la variable de retorno (resultado), si fuera de otra manera, el compilador lanzar un error de tipos incompatibles.
58

2.3.3. Paso de parmetros

Cuando se invoque (llame) el parmetro que se quiera utilizar, deberemos pasarle los parmetros indicados (necesarios) en su declaracin. Los parmetros se escriben a continuacin del nombre del mtodo que se quisiera utilizar, de igual manera entre parntesis pero al hacer la invocacin no se indica el tipo de dato de los parmetros, aunque las variables que enviemos forzosamente debern coincidir con el tipo que pretendemos utilizar. Por ejemplo, se completar el llamado del mtodo presentado en el punto anterior. public static void main(String[] args){ int b = 3; //representando a la base int p = 2; //representando a la potencia obtener_potencia(b,p); } Como informacin al lector se debe aclarar que se omiten muchas partes de los mtodos, slo son ejemplos ilustrativos de cada uno de los puntos. Tambin como punto importantsimo, recordando los tipos de variables, se dir que en Java los parmetros de tipo primitivo (int, long, double, ) siempre se pasan por valor. Las variables de tipo objeto y arrays se pasan por referencia (referencia a su direccin de memoria de alojamiento).
2.3.4. Llamada de mtodos

Para complementar todos los elementos de los mtodos que regresan valores, se indicar cul es la forma correcta de llamar a los mtodos, pasando los parmetros correctos y recibiendo de manera adecuada los valores de retorno. Como ya se mencion, al invocar un mtodo simplemente se deber escribir el nombre del mtodo que interesa utilizar, seguido de los parmetros que necesita el mtodo (fueron indicados en su declaracin). Como ejemplo, se terminar de desarrollar el cdigo del mtodo de la obtencin de potencias. public static void main(String[] args){ int b = 3; //representando a la base int p = 2; //representando a la potencia int r_potencia // variable que recibir el resultado desde el mtodo r_potencia = obtener_potencia(b,p); Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 59

System.out.println(El resultado es: +r_potencia); } Donde: r_potencia ser el valor de recepcin del parmetro devuelto por el mtodo. De igual manera deber coincidir el tipo de dato de la variable de recepcin, con el tipo de dato indicado en el mtodo. En este caso el mtodo indica que regresar un int, entonces el tipo de la variable deber ser tambin int. La llamada al mtodo obtener_potencia ser la conjuncin de todos los puntos explicados, necesitar un lugar donde depositar su valor de retorno (explicado en el punto anterior) y pasar los parmetros necesarios despus del nombre del mtodo, sin olvidar que todos los tipos de las variables deben coincidir (las variables que se pasan como parmetros, la variable que se retorna desde el mtodo y la variable donde se recibe este valor de retorno). Se representa en esta lnea: r_potencia = obtener_potencia(b,p);
Actividad 1. Tipos de variables y constantes

Este foro de discusin tiene la finalidad de que des tu punto de vista sobre el uso de variables y constantes, adems de que intercambies ideas con tus compaeros sobre en qu casos se utilizaran cada uno de esos usos. 1. Identifica las diferencias entre variables y constantes.
2. Ingresa al foro y genera una nueva entrada.
Actividad 2. Deteccin de errores

Con el fin de distinguir la declaracin de mtodos en JAVA, revisa los siguientes mtodos declarados incorrectamente, identifica los errores planteados y corrgelos. 1. En un archivo de texto, copia los datos dados.
2. Marca en rojo las lneas que contengan error. 3. Copia los mtodos nuevamente y corrgelos.
60

4. Guarda la actividad con el nombre POO1_U2_A2_XXYZ. Sustituye las XX por las dos primeras letras del primer nombre, la Y por la inicial del apellido paterno y la Z por la inicial del apellido materno. 5. Enva el archivo a tu Facilitador(a) para recibir retroalimentacin.
MTODO INCORRECTO public void suma(int a int b){ int c=a+b; return b; } public void area(int a, int b) int c=a*b return c; } public void divide(float a, float b){ int c=a/b; return b; } public void resta(int a, int a){ imt c=a-b; System.out.println(d); } public int areaCirculo(float r){ int b= 3.1416 * (r*r); return; }
Actividad 3. Sobre parmetros

Con el fin de distinguir los qu son los parmetros debers elaborar una definicin propia de parmetros.
1. En un archivo de texto, escribe tu propia definicin de parmetro, cules tipos
de parmetros existen, y cmo se deben utilizar dentro de un programa.
61

2. Guarda la actividad con el nombre POO1_U2_A3_XXYZ. Sustituye las XX por las dos primeras letras del primer nombre, la Y por la inicial del apellido paterno y la Z por la inicial del apellido materno. 3. Enva el archivo a tu Facilitador(a) para recibir retroalimentacin.
2.4. Estructuras de control selectivas

Las estructuras alternativas son construcciones que permiten alterar el flujo secuencial de un programa, de forma que en funcin de una condicin o el valor de una expresin, el mismo pueda ser desviado en una u otra alternativa de cdigo (Garca, J., Rodrguez, J., Mingo, I., Imaz, A., Brazlez, A., Larzabal, A. et al,. 2000).
2.4.1. If - else
La estructura de seleccin simple o if es aquella secuencia de un programa que se ve afectada por una condicin, si la condicin es cumplida la secuencia del programa entrar en el bloque de instrucciones de dicha estructura, de lo contrario la secuencia del programa se saltar ese bloque de cdigo y entrar al bloque de instrucciones del else dado que la condicin se cumpli. Esta estructura de control se conforma como sigue: // Instrucciones previas a la condicin if( condicin) { Instrucciones a ejecutarse solo si la condicin se cumpli. } else{ Instrucciones a ejecutarse si la condicin NO se cumpli. } // Instrucciones a ejecutarse despus de la condicin Las llaves se utilizan para agrupar las instrucciones que se han de ejecutar, si solo quieres que se ejecute una instruccin puedes omitirlas. Es importante mencionar que las instrucciones previas y posteriores al bloque if-else se ejecutan de manera normal, se cumpla o no la condicin, por lo que solo se altera la secuencia del programa en ese bloque. A continuacin se muestra un ejemplo donde dada una calificacin, se decide si la calificacin es aprobatoria o no y esto lo indica en un mensaje. Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 62

package ejemplos; /** * @author ESAD */ public class estructuraIF { public static void main(String[] args) { int calificacion=80; if(calificacion> 70){ System.out.print("Aprobado"); } else{ System.out.print("Reprobado"); } System.out.print("esto se imprimir se cumpla o no la condicin"); } }
Define el paquete donde se encuentra Indica el nombre del autor Declara la clase llamada estructuraIF Se declara el mtodo main Declaro la variable calificacin Establezco la condicin de If Se muestra a pantalla el resultado Palabra reservada else Se enva el mensaje a pantalla. Se manda una impresin que se ejecutar despus de la estructura selectiva if else.
2.4.2. If anidado
Esta estructura es un agrandamiento de la estructura anterior, ya que se pueden evaluar diferentes condiciones ligadas. Por ejemplo, en el tema anterior solo queramos que se mostrara Aprobado o Reprobado segn su calificacin, pero ahora se quiere dar mayor reconocimiento a los puntos obtenidos se realizara de la siguiente manera: package ejemplos; /** * @author ESAD */ public class estructuraIF { public static void main(String[] args) { int calificacion=90; if(calificacion> 90 && calificacion <= 100){ System.out.print("Excelente"); } Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 63

else if(calificacion >80 && calificacion <= 90){ System.out.print("Muy Bien"); } else if(calificacion >70 && calificacion <= 80){ System.out.print("Bien"); } else if(calificacion < 70){ System.out.print("Muy mal"); } } } En este ejemplo evaluamos que si su calificacin est entre 90 y 100 se mostrar una mensaje diciendo Muy Bien, si no tienes una calificacin entre 90 y 100; pero si est entre 80 y 90 te mostrar un mensaje diciendo Bien, y si no cumpli ninguna de las anteriores y la calificacin es menor de 70 mostrar un mensaje diciendo Muy mal. Entonces como pudiste observar se pueden colocar condiciones mltiples como en este ejemplo, donde no solo evalu una calificacin, sino un rango de calificaciones, para ello se auxili de los operadores lgicos y relacionales que se vieron en la unidad anterior.
2.4.3. Switch - case

La estructura selectiva switch case tambin es conocida como estructura de decisin mltiple, en esta estructura se puede evaluar una misma expresin con, como su nombre lo indica, mltiples opciones, pero en este caso no son condiciones, el switch evala si una variable tiene un valor en especfico, se muestra la estructura a continuacin: // Instrucciones previas a la condicin switch(expresion) { case valor: instrucciones a ejecutarse; break; case valor: instrucciones a ejecutarse; break; default: instrucciones; } // Instrucciones a ejecutarse despus de la condicin
64

Una sentencia case es una opcin de los diferentes valores que puede tomar la expresin que se evala, por cada valor permitido que la expresin pueda tomar representara una sentencia case. Las caractersticas ms relevantes de switch son las siguientes (Gosling, J., Holmes, D. & Arnold, K., 2001): 1. Cada sentencia case se corresponde con un nico valor. No se pueden establecer rangos o condiciones sino que se deben comparar con valores concretos. 2. Los valores no comprendidos en ninguna sentencia case se pueden gestionar en default, que es opcional. 3. En la ausencia de break, cuando se ejecuta una sentencia case se ejecutan tambin todas las case que van a continuacin, hasta que se llega a un break o hasta que termina el switch. Se muestra un ejemplo a continuacin: package ejemplos; import javax.swing.JOptionPane; /** * @author ESAD */ public class ejemploSwitch { public static void main(String[] args) { int mes= Integer.parseInt(JOptionPane.showInputDialog("Cul es el nmero del mes")); switch(mes){ case 1: System.out.print("Enero"); break; case 2: System.out.print("Febrero"); break; case 3: System.out.print("Marzo"); break; case 4: System.out.print("Abril"); break; case 5: System.out.print("Mayo"); break; case 6: System.out.print("Junio"); Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 65

break; case 7: System.out.print("Julio"); break; case 8: System.out.print("Agosto"); break; case 9: System.out.print("Septiembre"); break; case 10: System.out.print("Octubre"); break; case 11: System.out.print("Noviembre"); break; case 12: System.out.print("Diciembre"); break; default:System.out.print("Mes no vlido"); } } } Este ejemplo muestra que al inicio del programa se crea una variable llamada mes, la cual almacena el nmero del mes indicado por el usuario, y muestra en la pantalla el nombre del mes correspondiente, para identificar el nombre de mes utilizamos la sentencia switch que para este ejemplo tiene 12 casos que son el nmero de meses que existen, al encontrar el valor correspondiente mostrar el nombre del mes, y en caso de que el usuario ingrese un nmero no valido como 20, el programa mostrar un mensaje diciendo Mes no vlido. Entonces si requieres usar un programa donde las comparaciones sean muy especficas puedes usar un switch, y en el caso de evaluar rangos, utiliza un if.
Actividad 4. Programa de horscopo

En NetBeans crea un programa que solicite al usuario el da y nmero de mes de su nacimiento (en 2 variables diferentes) y muestra cul es su signo zodiacal. 1. Entra a la wiki, y coloca ah el programa realizado.
2. Revisar los mensajes de tu Facilitador(a), pues en caso de que el programa requiera modificaciones tu Facilitador(a) te lo har saber. 3. Realiza las modificaciones requeridas.
66

4. En caso de ser necesario, retroalimenta a tus compaeros para que modifiquen su programa.
2.5. Estructuras de control cclicas

Las estructuras de control cclicas son bloques de instrucciones que se repiten un nmero de veces mientras se cumpla una condicin o hasta que se cumpla una condicin (Garca, J., Rodrguez, J., Mingo, I., Imaz, A., Brazlez, A., Larzabal, A. et al., 2000). Como regla general puede decirse que se utilizar: Ciclo for cuando se conozca de antemano el nmero exacto de veces que ha de repetirse un determinado bloque de instrucciones. Ciclo do-while cuando no se conoce exactamente el nmero de veces que se ejecutar el ciclo pero se sabe que por lo menos se ha de ejecutar una. Ciclo while-do cuando es posible que no deba ejecutarse ninguna vez. Estas reglas son generales y algunos programadores se sienten ms cmodos utilizando principalmente una de ellas. Con mayor o menor esfuerzo, puede utilizarse cualquiera de ellas indistintamente.
2.5.1. While
El ciclo while tiene como caracterstica que primero evala la condicin y solo si se cumple realiza las instrucciones, as es que si la condicin no es cumplida desde un inicio el control del programa no entrar en el bloque de instrucciones que se encuentran dentro del ciclo. Su declaracin es como se muestra a continuacin: while (condicion){ Bloque de Instrucciones a repetir } La condicin que se d, deber ser evaluada verdadera para que el control del programa ingrese al bloque de instrucciones y deber llegar en algn punto a que esa misma condicin se evale falsa y salga del bloque repetitivo. Si planteas mal la condicin y sta nunca se evala como falsa, el programa se repetir infinitamente, lo que provocar un problema en la ejecucin. Veamos el siguiente ejemplo. package ejemplos; Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 67

import javax.swing.JOptionPane; /** * @author ESAD */ public class ejemploWhile { public static void main(String[] args) { int n= Integer.parseInt(JOptionPane.showInputDialog("Ingresa el 9")); while(n != 9){ n= Integer.parseInt(JOptionPane.showInputDialog("Ingresa el 9")); } } } En este ejemplo se pide al usuario ingresar el nmero 9, y el ciclo seguir mientras no ingresen el 9, en el momento en que la condicin se deja de cumplir (precisamente al ingresar el 9) el ciclo terminar y el programa tambin.
2.5.2. Do - while
Este ciclo permite la ejecucin del bloque repetitivo al menos una vez, se cumpla o no la condicin, pues ejecuta primero el bloque do y al finalizarlo evala la condicin, si sta se cumple regresa a ejecutar nuevamente el bloque do, de lo contrario termina la ejecucin. do{ Bloque de instrucciones a repetir } While(condicion); Veamos el siguiente ejemplo: package ejemplos; import javax.swing.JOptionPane; /** * @author ESAD */ public class ejemploDoWhile { public static void main(String[] args) { int n; do{ n= Integer.parseInt(JOptionPane.showInputDialog("Ingresa el 9")); } while(n != 9); Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 68

} } Como podemos observar el ciclo while es muy parecido al do-while, pero recordemos que el while si desde un principio no se cumple la condicin no entra al ciclo, y el do-while primero entra y despus evala. Te pido compares los dos ejemplos, y veas que en el ciclo do-while la peticin del nmero la hacemos dentro del bloque que conforma el do, pues tenemos la certeza de que entrar a ejecutar esta porcin del programa, al menos una vez. Mientras que en el ciclo while la peticin se hace fuera del bloque de instrucciones que lo conforman, pues la evaluacin se realiza antes de entrar al ciclo.
2.5.3. For
Este ciclo es especialmente til cuando de antemano conoces el nmero de veces que quieres que se ejecute el mismo bloque de instrucciones, su declaracin es como sigue: for(inicio ; condicin; incremento){ Bloque de instrucciones repetitivas } Inicio: se debe colocar un valor numrico donde comenzar el conteo de ejecuciones. Condicin: se coloca la condicin a evaluar en cada iteracin del ciclo para que se siga ejecutando el nmero de veces que se cumpla esta condicin, pues el momento que la condicin se evale como falsa el ciclo dejar de repetirse. Incremento: esta instruccin se evala como si fuese la ltima del bloque de instrucciones e indica el incremento o decremento de la variable numrica de inicio para reevaluar la condicin en cada iteracin. Veamos el ejemplo: package ejemplos; import javax.swing.JOptionPane; /** * @author ESAD */ public class ejemploFor { public static void main(String[] args) { int n= Integer.parseInt(JOptionPane.showInputDialog("Cuntos nmeros quieres ver")); for(int i=1; i<=n; i=i+1){ System.out.print(i); } Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 69

} } Este ejemplo pide al usuario un nmero, y muestra ese mismo nmero de elementos, veamos, el inicio empieza en 1, la condicin para seguir es que la variable i sea menor o igual que el nmero dado por el usuario, y el incrementos ser de uno en uno, de esta manera pues la salida del programa al ingresar un 5 sera como se muestra a continuacin.
Otro punto importante respecto al ciclo for es que se puede anidar, esto se refiere a que puedo utilizar un ciclo dentro de otro, a manera de explicacin observa el siguiente cdigo y su salida. package ejemplos; import javax.swing.JOptionPane; /** * @author ESAD */ public class forAnidado { public static void main(String[] args) { int n= Integer.parseInt(JOptionPane.showInputDialog("Cuantos temas son")); int m= Integer.parseInt(JOptionPane.showInputDialog("Cuantos subtemas contiene cada tema")); for(int i=1; i<=n; i=i+1){ for(int j=1; j<=m; j=j+1){ System.out.print(i+","+j); System.out.print("\n"); } } } } Como se puede ver tenemos un ciclo dentro de otro, su manera de funcionar es que entra al primero, despus al segundo y hasta que el segundo termine sus repeticiones, el primero volver a incrementar su valor y volver a entrar al segundo tomando sus valores iniciales. Veamos la salida, en este ejemplo se indic que los temas eran 3 y subtemas 2, Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 70

entonces se coloca el primer tema y sus respectivos subtemas 1,1 y 1,2, ya que termina ese tema se sigue con el 2,1 y 2,2.
Nota: Si se quisieran anidar ms de 2 ciclos for es posible realizarlo, tomando en cuenta que siempre el ciclo que se encuentre ms adentro ser el que se realice primero. Tambin se puede que el ciclo en lugar de ir de manera ascendente se realice de manera descendente, para esto se debe tomar en cuenta que el inicio sea el ltimo elemento, la condicin de paro el 0 y su incremento sea restar 1. Veamos el siguiente ejemplo, que es el mismo que el ejemplo del for, pero ahora con un recorrido inverso.
package ejemplos; import javax.swing.JOptionPane; /** * @author ESAD */ public class ejemploFor2 { public static void main(String[] args) { int n= Integer.parseInt(JOptionPane.showInputDialog("Cuntos nmeros quieres ver")); for(int i=n; i>0; i=i-1){ System.out.print(i); System.out.print("\n"); } } }
71

Al realizar los cambios comentados podemos observar que la salida nos muestra los 5 nmeros pero de manera descendente.
Actividad 5. Programa retorno de parmetros

Con el fin de distinguir los mtodos en JAVA y sus tipos, identifica los mtodos que devuelven valor y los que no devuelven valor, de modo tal que se cree un programa con 3 mtodos de cada tipo. 1. En NetBeans crea un nuevo proyecto.
2. Dentro de la clase Main elabora un programa con 6 mtodos, donde se definan dos nmeros que sume, reste y multiplique nmeros enteros y estos mtodos regresen el resultado. 3. Adems, disea mtodos para calcular el rea de un cuadrado, rea de un crculo y rea de un tringulo y que estos mtodos no devuelvan valor. 4. Guarda la actividad con el nombre POO1_U2_A5_XXYZ. Sustituye las XX por las dos primeras letras del primer nombre, la Y por la inicial del apellido paterno y la Z por la inicial del apellido materno. 5. Enva la carpeta del proyecto a travs de la seccin de Base de Datos. 6. Revisa y comenta los trabajos de tus compaeros.
Autoevaluacin
Para reforzar los conocimientos relacionados con los temas que se abordaron en esta segunda unidad del curso, es necesario que resuelvas la autoevaluacin de la unidad.
72

Recuerda que es muy importante leer cuidadosamente los planteamientos indicados y elegir la opcin adecuada para cada uno.
Evidencia de aprendizaje. Programa de series numricas

Como parte de la evaluacin de esta unidad, realiza una aplicacin cuyo propsito es que identifiques los componentes de un programa y puedas emplearlos. El programa solicitar un nmero al usuario; si el nmero es par, que calcule su factorial; si el nmero es impar, que muestre el mismo nmero de elementos de la serie de Fibonacci, utilizando mtodos que devuelven valor y que no devuelven. 1. En NetBeans crea un nuevo proyecto.
2. Dentro de la clase Main elabora un programa donde se definan dos mtodos uno que calcule el factorial y otro que realice la secuencia de Fibonacci, para despus mostrar el resultado en la pantalla. La llamada a estos mtodos estar dada por la solicitud de un nmero al usuario, si este es par que calcule su factorial, si es impar, que muestre es mismo nmero de elementos de la serie de Fibonacci, utilizando mtodos que devuelven valor y que no devuelven. 3. Guarda la evidencia con el nombre POO1_U2_EA_XXYZ. Sustituye las XX por las dos primeras letras del primer nombre, la Y por la inicial del apellido paterno y la Z por la inicial del apellido materno. 4. Enva la carpeta del proyecto a tu Facilitador(a) para recibir retroalimentacin.
Cierre de la unidad
Has concluido la unidad 2 del curso. A lo largo de sta has visto lo que es una variable, su mbito y declaracin, as como las generalidades de los mtodos, sus caractersticas, llamadas y tipos de parmetros que se manejan. Posteriormente te involucraste conociendo las estructuras de control selectivas, como lo son el If-else, If anidado y switch-case. Al final de la unidad tambin se vieron las estructuras de control cclicas while, do-while y for, cuyo propsito ha sido que obtengas conocimientos sobre estructuras de control y logres aplicarlas en la resolucin de problemas y creacin de programas para dichas soluciones.
73

Es aconsejable que revises nuevamente la unidad en caso de que los temas que se acaban de mencionar no te sean familiares o no los recuerdes, de no ser este tu caso, ya ests preparado(a) para seguir con la unidad 3, en donde continuars con la revisin de herencia, polimorfismo y excepciones en un programa JAVA. Todo ello con el fin de obtener el conocimiento necesario para comenzar a realizar pequeos programas computacionales al final de la cuarta y ltima unidad del curso de Programacin Orientada a Objetos I.
Para saber ms
Consulta la pgina oficial del lenguaje JAVA http://www.java.com/es/, donde podrs encontrar manuales de referencia sobre los mtodos, variables, estructuras de control selectivas y de repeticin.
Fuentes de consulta
Garca, J., Rodrguez, J., Mingo, I., Imaz, A., Brazlez, A., Larzabal, A. et al. (2000) Aprenda JAVA como si estuviera en primero. Espaa: Escuela Superior de Ingenieros, TECNUM. Recuperado el 1 de Marzo del 2011, de http://www.tecnun.es/asignaturas/Informat1/AyudaInf/aprendainf/Java/Java2.pdf Gosling, J., Holmes, D. & Arnold, K. (2001) El lenguaje de programacin Java TM. Madrid: Addison-Wesley. Recuperado el 1 de marzo del 2011, de http://icesecurity.org/programacion/JAVA/Libro_Java-SP.pdf
74

Unidad 3. Caractersticas de POO y Excepciones Presentacin de la unidad

En esta tercera unidad de Programacin orientada a objetos I (POO I), aprenders el concepto de herencia y polimorfismo, as como el manejo de excepciones y la sintaxis JAVA para su aplicacin.
Propsito
En esta unidad logrars: 1. Reconocer el concepto y uso de la herencia. 2. Reconocer el concepto y uso del polimorfismo. 3. Identificar el uso de las excepciones. 4. Identificar la sintaxis que JAVA ofrece para la implementacin de estos temas.
Desarrollar programas modulares para para solucionar problemas diversos, aplicando la herencia, el polimorfismo y el manejo de excepciones mediante la sintaxis que JAVA ofrece para su implementacin.
Consideraciones especficas de la unidad

Es muy importante que captures todos los programas de ejemplo, para que analices su sintaxis y puedas comprender mejor los temas vistos.
3.1. Herencia
En la definicin del lenguaje Java se pens en una de sus caractersticas ms sobresalientes: la herencia. Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 75

La herencia es una propiedad del lenguaje que nos permite definir objetos en base a otros ya existentes y as poder aadirles nuevas caractersticas (extenderlos). La nueva clase es llamada subclase o clase extendida y la clase que hereda sus mtodos y atributos se llama superclase.
3.1.1. Subclases y superclases

En el lenguaje Java existen dos categoras en las cuales puede agruparse las clases: superclase, que es la clase existente y subclase, que es la clase derivada de la primera. Otro trmino usado comnmente para la superclase es clase padre y la subclase tambin se le conoce como clase hija. Para entender mejor la clase derivada se dir que es aquella que aade variables de instancia y mtodos a partir de los heredados (obtenidos) desde la clase padre. En la siguiente figura se ejemplifica el modo en que se heredan sus mtodos y atributos entre las clases. La clase padre es Persona y sus subclases son Estudiante y Profesor, debe notarse de igual manera que la clase Profesor a su vez funge con dos roles distintos: es subclase de la superclase Persona y es superclase de las subclases Asignatura y Base.
Figura 3.1. Ejemplo de herencia En un ejemplo ms sobre la herencia de la superclase hacia la subclase debe imaginarse que se cuenta con la clase circulo que es perfecta para hacer algunas operaciones y abstracciones matemticas y por supuesto nos servir para ms de un propsito y ms de una aplicacin donde se utilice un crculo y las operaciones bsicas inherentes a l. Para algunas otras aplicaciones tal vez se precise manipular la clase crculo (con sus mtodos y atributos bsicos) de otra manera y se necesite imprimirlo a pantalla. Para no modificar por completo la clase crculo, que ya es usada por cientos de aplicativos ms y resultaran seriamente perjudicados, se crear una subclase de la clase padre circulo, se llamar Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 76

Dibujacirculo que tendr la misma funcionalidad que su clase padre, ms un mtodo aadido: imprimeCirculo. Una manera de hacerlo es como sigue:
La solucin descrita funciona, sin embargo no es una solucin ptima y siendo un poco ms exigentes carece de elegancia. El problema que se presenta en esta solucin es el doble trabajo que involucra escribir los mtodos presentados y que no tienen injerencia en el dibujado del crculo. Otra manera de poder resolver el problema es heredando (extendiendo) desde la clase crculo a la subclase Dibujacirculo, como ya se haba explicado. Se presenta a continuacin:
Debers notar que se obvia la declaracin de dos clases: Color y DrawWindow, se toma slo como ejemplo ilustrativo. La palabra reservada extends le indica al compilador de Java que Dibujacirculo es una subclase de circulo, lo que significa que sta heredar por completo sus mtodos y atributos con los modificadores de acceso que se le indicaron en la clase padre.
77

3.1.2. Jerarqua de la herencia

En el lenguaje Java cada clase que se escribe es una superclase por definicin. Si no se escribe especficamente la palabra reservada extends, la superclase ser la clase Object, que por muchas razones es un tipo especial de clase, se listan a continuacin: 1. Desde la definicin de Java, es la nica clase que no tiene superclases. 2. Los mtodos definidos en la clase Object pueden ser invocados desde cualquier clase Java. Por lo descrito anteriormente, todas las clases en java pueden ser superclases, se deber marcar una jerarqua de clases en Java donde su raz deber ser la clase Object, se presenta una imagen de su posible representacin con nuestro ejemplo citado de la clase crculo.
Figura 3.2 Ejemplo de la jerarqua de la herencia en la clase circulo
3.1.3. Clases y mtodos abstractos

Con la salida a la luz del paradigma de programacin orientado a objetos, de igual manera surgieron muchos problemas inherentes a la comprensin sobre la forma de representar cosas y ms an conceptos en forma de un objeto en lenguaje de programacin Java. Por lo descrito, muchas ocasiones se desea representar conceptos abstractos en forma de una clase que pueda ser manejada por Java, pero por la misma definicin de su abstraccin no se pueden instanciar a partir de ellas un nuevo objeto. Consideremos por Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 78

ejemplo, la comida en el mundo real. Se puede tener una instancia (un ejemplar) de comida? No, aunque s se pueden tener instancias de manzanas, chocolates o cualquier otro alimento. La comida representa el concepto abstracto de cosas que se pueden comer y no tiene sentido que tenga instancias ya que no es un objeto concreto, slo una abstraccin de un concepto ms amplio. Otro ejemplo puede ser la clase abstracta FiguraTresDimensiones; de ella se pueden definir clases concretas, tales como Esfera, Cilindro, Cono. Bajo la definicin anterior no se puede comprender la utilidad de tener una clase abstracta de manera pronta, sin embargo su utilidad se ve definida cuando sirven para heredar a otras subclases caractersticas generales del concepto abstracto que representan, pero de ellas no se puede instanciar objetos con el operador new. Las clases a partir de las cuales se pueden crear instancias se denominan clases concretas (Niemeyer & Peck, 1997). Una clase abstracta es una clase que contiene los nombres de los comportamientos sin las implementaciones que ejecutan esos comportamientos. Los objetos no se pueden instanciar de una clase abstracta. Cuando se hace la definicin (declaracin) de una clase abstracta deber ser antecedida por el modificador abstract. Este tipo de clases puede contener mtodos abstractos, que como se podr imaginar son slo la declaracin de los mismos, pero sin la implementacin de las instrucciones que se esperara para cumplir el propsito para los cuales fueron escritos. La implementacin de dichos mtodos se hace en las subclases. Para que un mtodo pueda declararse como abstracto debe cumplir con dos condiciones bsicas: 1. No ser mtodo privado. 2. No ser mtodo esttico.
3.2. Polimorfismo
Esta capacidad, el polimorfismo, permite hacer diferentes implementaciones de los mismos mtodos abstractos. Es decir, se pueden realizar diferentes implementaciones de un mismo mtodo, para poder adaptarlo a las necesidades propias de cada clase.
79

3.2.1. Clases y mtodos finales

Las clases se declaran como finales cuando se pretende que no se pueda derivar de sta. Es decir si se crea una clase y se quiere que no se creen clases hijas de sta (que hereden), entonces la clase deber ser declarada como final, para indicar que no se pueden crear otras clases a partir de ella y que terminan con una cadena de herencia. Esto se declara de la siguiente manera: final class ClaseFinal { //aqu va el cuerpo de la clase } Que como se muestra solo hace falta aadir la palabra final al inicio de la declaracin de la clase. Por su parte los mtodos finales son aquellos que no pueden ser redefinidos, es decir que en ellos no se podr aplicar ni herencia ni polimorfismo. Su declaracin al igual que la clase final solo consta de anteponer la palabra reservada final a la declaracin de mtodo en cuestin. final public void metodoFinal(){ //...aqu va el cuerpo del mtodo } Entonces se usar la palabra final en las clases y mtodos que ya no se puedan heredar, ni redefinir, es decir, aquellos que no deban ser modificados en ninguna otra clase.
3.2.2. Interfaces
Cuando se define o se pretende utilizar en Java una interface, en realidad se est describiendo un comportamiento. De manera ms general las interfases lucen un tanto parecidas a una clase abstracta, slo las diferencian el mtodo de declaracin: 1. En una clase abstracta se utiliza la palabra reservada abstract. 2. En una interface se utiliza la palabra reservada interface. Tratando de entender la definicin general de interfase, se dir que es un sistema que hace de puente para unir entidades no relacionadas entre s. Cuando se sigue el proceso Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 80

normal de compilacin, el compilador pone cada interface identificada en un archivo de bytecode por separado como si fuera una clase normal, adems como en las clases abstractas, slo tiene la definicin de mtodos pero no la implementacin de ellos. En esencia una interfase podra identificarse como lo mismo que una clase abstracta. El gran diferenciador entre ellas y lo que justifica la existencia de las interfaces es porque pueden emular el comportamiento de la herencia mltiple, que no lo soportan las clases abstractas. Una interfase se puede considerar una clase abstracta de hecho, y en ella se toma en cuenta lo siguiente (Flanagan, 1997): 1. 2. 3. Todos los miembros son pblicos. Todos los mtodos son abstractos. Todos los campos son static y final.
Una interfase consta de dos elementos bsicos: 1. 2. La declaracin que es donde se colocan los diversos atributos acerca de la interface como el nombre o si se extiende de otra interfase, y El cuerpo que contiene la declaracin de los mtodos y las constantes que conforman la propia interfase.
3.2.3. Sobrecarga de mtodos

Como se dijo en la definicin de polimorfismo, cuando se sobrecarga un mtodo se parte del concepto de la clase abstracta. Imaginemos que tenemos la clase abstracta identificada como fruta y dentro de esta clase est declarado el mtodo pelarFruta. De esta clase abstracta se hereda este mtodo (y otros tantos que conciernen a todas las frutas) hacia las subclases manzana y naranja; al tratar de utilizar el mtodo pelarFruta deber sobrecargarse porque la accin de pelar la fruta se hace de manera distinta entre una manzana y una naranja, que son las clases a donde se hered este mtodo. As pues en cada clase donde se herede el mtodo puede implementarse de manera diferente el mtodo, se dice que se sobrecargan sus funciones pues son diferentes para cada una de las subclases.
81

3.2.4. Sobrecarga de operadores

La sobrecarga de los operadores permite redefinir las funciones que se le asignan por definicin a un operador, por ejemplo el operador + (ms) y el operador . (punto), se pueden utilizar para realizar otras funciones que las regulares. Como ejemplo prctico y conocido, el operador + en el mundo Java sirve para dos cosas, al estar sobrecargado: 1. 2. Para realizar la operacin de suma, cuando se acompaa de datos numricos. Para realizar la operacin de unin, cuando uno de sus operando es una dato de tipo String.
El compilador decide qu uso se le dar en base a los operando de los cuales est acompaado.
Actividad 1. Herencia y polimorfismo

Esta actividad tiene como finalidad que reflexiones sobre el concepto y uso de la herencia y el polimorfismo. 1. Identifica el concepto de herencia y polimorfismo. 2. Ingresa al foro y genera una nueva entrada.
Actividad 2. Cuadro sinptico

El propsito de esta actividad es que identifiques los conceptos de herencia y polimorfismo, as como su aplicacin en JAVA.
1. En un archivo de texto, realiza el cuadro sinptico de herencia y polimorfismo, as como su aplicacin en JAVA. Usa tu imaginacin, puedes agregar imgenes y colores tantos como sea necesario.
82

2. Guarda la actividad con el nombre POO_U3_A2_XXYZ. Sustituye las XX por las dos primeras letras del primer nombre, la Y por la inicial del apellido paterno y la Z por la inicial del apellido materno.
3. Enva el archivo a tu Facilitador(a) para recibir retroalimentacin.
3.3. Excepciones
Cuando un programa Java viola las restricciones semnticas del lenguaje (se produce un error), la mquina virtual Java comunica este hecho al programa mediante una excepcin. Por tanto la manera ms simple de decirlo es que una excepcin es un error que ha ocurrido en un programa en ejecucin. Muchas clases de errores pueden provocar una excepcin, desde un desbordamiento de memoria o un disco duro estropeado, un intento de dividir por cero o intentar acceder a un arreglo fuera de sus lmites. Cuando esto ocurre, la mquina virtual Java crea un objeto de la clase exception, se notifica el hecho al sistema de ejecucin y se dice que se ha lanzado una excepcin.
3.1.1. Sentencia Try-catch

La manera de controlar las excepciones es mediante una sentencia llamada try catch, que si lo traducimos a espaol sera algo como intenta atrapa, y realmente esto es lo que hace la sentencia, pues dentro del try se coloca el cdigo vulnerable a errores, para que el programa lo intente, y en caso de que ocurra un error lo atrape en la sentencia catch. Veamos el siguiente ejemplo:
83

Como se dijo anteriormente en el cdigo podemos ver que el bloque de sentencias que pudiera tener un error se coloca dentro del try{}, y en el catch(){} se coloca el tipo de error y su nombre dado, que por lo general siempre es e, entonces una vez que atrapa e error lo imprime a pantalla para que el usuario conozca el error, todo esto sin provocar un cierre inesperado del cdigo.
3.1.2. Tipos de errores

Esencialmente cuando se refiere a los tipos de errores en el lenguaje Java se clasifican dentro de dos tipos bsicos: 1. Aquellas generadas por el lenguaje Java. stas se generan cuando hay errores de ejecucin, como al tratar de acceder a mtodos de una referencia no asignada a un objeto, divisin por cero, etc. 2. Aquellas no generadas por el lenguaje, sino incluidas por el programador, como al tratar de leer un archivo o tratar de hacer conexin a una base de datos especfica.
3.1.3. Jerarqua de las excepciones

En el momento en que es lanzada una excepcin, la mquina virtual Java recorre la pila de llamadas de mtodos en busca de alguno que sea capaz de tratar la clase de excepcin lanzada. Para ello, comienza examinando el mtodo donde se ha producido la excepcin; si este mtodo no es capaz de tratarla, examina el mtodo desde el que se realiz la llamada al mtodo donde se produjo la excepcin y as sucesivamente hasta Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 84

llegar al ltimo de ellos. En caso de que ninguno de los mtodos de la pila sea capaz de tratar la excepcin, la mquina virtual Java muestra un mensaje de error y el programa termina. Por ejemplo si tengo un metodo1 que dentro hace una llamada al metodo2, y el metodo2 manda llamar al metodo3, y el metodo3 llama al metodo4, lo que pasa si ocurre un error en el metodo1, es que se busca un manejo de excepciones en el metodo1, pero si no se encuentra se va al metodo2 para ver si en este mtodo si se realiza el manejo de la excepcin, pero si ah tampoco se hizo nada, se va al metodo3 en bsqueda del manejo de la excepcin, por ltimo si tampoco en el metodo3 se hizo nada, se va al metodo4 a buscar el manejo de la excepcin, a esto se refiere el texto de arriba sobre , a ir buscando en las llamadas hasta encontrar donde se pueda manejar la excepcin, pero si en ninguno de los mtodos se realiz, entonces inevitablemente la excepcin har que el sistema falle.
Actividad 3. Manejo de excepciones

Con el fin de tener claro el tema de excepciones en JAVA, realiza un ensayo con las siguientes caractersticas:
1. Elabora un ensayo donde plasmes tu percepcin sobre el uso y utilidad que brindan las excepciones para un programador. No olvides incluir las fuentes que consultes. 2. Enva el archivo a travs de la seccin Base de datos.
85

Autoevaluacin
Para reforzar los conocimientos relacionados con los temas que se abordaron en esta primera unidad del curso, es necesario que resuelvas la autoevaluacin de la unidad. Recuerda que es muy importante leer cuidadosamente los planteamientos indicados y elegir la opcin adecuada para cada uno. Ingresa al aula para realizar la actividad.
Evidencia de aprendizaje. Implementacin de clases abstractas

Como parte de la evaluacin de esta unidad, realiza un programa cuyo propsito es organizar los conceptos abordados a lo largo de la unidad. 1. En NetBeans crea un nuevo proyecto, dentro de ste crea las clases abstractas e interfaces proporcionadas y elabora sus respectivas clases de implementacin. 2. Consulta la Escala de evaluacin. 3. Guardar la evidencia con el nombre POO1_U3_EA_XXYZ. Sustituye las XX por las dos primeras letras del primer nombre, la Y por la inicial del apellido paterno y la Z por la inicial del apellido materno. 4. Enva la carpeta del proyecto a tu Facilitador(a) para recibir retroalimentacin. * Recuerda que puedes volver a enviar tu archivo tomando en cuenta las observaciones de tu Facilitador(a).
86

Autorreflexiones
Adems de enviar tu trabajo de la Evidencia de aprendizaje, es importante que ingreses al foro Preguntas de Autorreflexin y consultes las preguntas que tu Facilitador(a) Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 87

presente, a partir de ellas, debes elaborar tu Autorreflexin en un archivo de texto llamado POO_U3_ATR_XXYZ. Posteriormente enva tu archivo mediante la herramienta Autorreflexiones.
Para saber ms
Consulta la pgina oficial del lenguaje JAVA, donde podrs encontrar manuales de referencia sobre el manejo de la herencia, el polimorfismo y las excepciones. Java: http://www.java.com/es/
Fuentes de consulta
Flanagan, D. (1997) Java in a NutShell, The Java Reference Library, versin 1.2. Mxico: O'Reilly & Associates. Joyanes, L. & Fernndez, M. (2001) Java 2: manual de programacin. Mxico: McGrawHill. Niemeyer, P. & Peck, J. (1997) Exploring Java, The Java Reference Library, versin 1.2. Mxico: O'Reilly & Associates.
88

Unidad 4. Arreglos Presentacin de la unidad

En esta unidad de la materia Programacin orientada a objetos I (POOI), aprenders el concepto arreglos, as como su manejo y recorrido. En esta unidad de la materia de Programacin orientada a objetos I (POOI), aprenders una de las estructuras de datos ms importante y bsica, que son los arreglos, conocers su concepto, as como su declaracin, manipulacin y recorrido. De esta manera aprenders a manejar varios datos unidos como un todo. Esto te servir para el manejo de informacin obtenida de una base de datos, as como la estructuracin de datos en tablas, que son temas que tratars en POO2. En esta Unidad es necesario que t, como estudiante, captures todos los programas de ejemplo, para que analices su sintaxis y as comprendas mejor los temas vistos.
Propsito
En esta unidad logrars: o Distinguir los arreglos unidimensionales y multidimensionales o Manejar las operaciones bsicas con arreglos
Construir programas para el manejo de datos del mismo tipo (carcter, cadena, entero o decimal) a travs de arreglos aplicados en problemas matemticos simples.
4.1. Arreglos unidimensionales

Un arreglo es una estructura de datos que contiene una serie de variables a las que se accede a travs de los ndices calculados.
89

Las variables contenidas en un arreglo, tambin llamados los elementos del arreglo, son todos del mismo tipo, y este tipo se llama el tipo de elemento del arreglo. Un arreglo tiene un rango que determina el nmero de ndices asociados a cada elemento del arreglo. El rango de un arreglo tambin se conoce como las dimensiones del arreglo. Un arreglo con un rango de 1 se denomina arreglo unidimensional. Un arreglo con un rango mayor que 1 se llama un arreglo multidimensional. Los arreglos multidimensionales con un tamao especfico se refieren a menudo como arreglos de dos dimensiones, los arreglos de tres dimensiones, y as sucesivamente. Cada dimensin de un arreglo tiene una longitud asociada que es un nmero entero mayor o igual a cero. Las longitudes de las dimensiones no son parte del tipo del arreglo, sino que se establecen cuando una instancia del tipo arreglo se crea en tiempo de ejecucin. La longitud de una dimensin determina el rango de validez de los ndices de esa dimensin: Por una dimensin de longitud N, los ndices pueden variar de 0 a N-1. El nmero total de elementos de un arreglo es el producto de las longitudes de cada dimensin del arreglo. Si una o ms de las dimensiones de un arreglo tienen una longitud de cero, se dice que el arreglo est vaco. El tipo de elemento de un arreglo puede ser cualquier tipo de dato, incluyendo l mismo (Hejlsberg, 2011: 626), es decir, en lugar de cada posicin contenga un dato, puede contener un arreglo completo.
4.1.1. Declaracin
En Java hay que declarar un array antes de poder utilizarlo. Y en la declaracin es necesario incluir el nombre del array y el tipo datos que se van a almacenar en l (Froufe, 2009: 35). La sintaxis general para declarar e instanciar un array es:
Adems, como ya se mencion, se pueden usar en Java arrays de cualquier tipo de dato soportado, incluso los definidos por el usuario:
90

Haciendo referencia al tema presentado antes Declaracin y mbito de variables (Unidad 2, subtema 2.1.1.) se debe saber que la declaracin de los arrays en Java se hace mediante una variable referenciada, es decir no se guarda el valor del contenido del array, lo que se guarda es una referencia de la locacin de memoria donde estn alojados dichos datos. Con lo que se acaba de ver, fcilmente se puede deducir que los arrays son objetos. Esto se puede ver en el siguiente prrafo: La memoria necesaria para almacenar los datos que componen el array se buscar en memoria dinmica a la hora de instanciar y crear realmente el array (Froufe, 2009: 35). Igual que con cualquier variable utilizada, en el lenguaje Java necesitan ser inicializadas a un valor. Bajo esta premisa, cuando se declara (crea) un array en Java se inicializa automticamente, dependiendo de estos tres casos: false cuando el tipo de dato es boolean. null para un array de objetos de tipo Object. el equivalente a 0 (vacio para String) para cualquier otro tipo de dato.
Cuando se hace la declaracin de un array en Java se consideran dos posibles opciones: Declararlo vaco o Declarar colocando valores.
91

Una vez que se ha instanciado un array, se puede acceder a los elementos de ste utilizando un ndice, de forma similar a la que se accede en otros lenguajes de programacin. Los ndices de un array siempre empiezan por 0 (cero) (Froufe, 2009: 35).
Actividad 1. Arreglos
El propsito de esta actividad es quereflexiones sobre las diferencias existentes entre los diversos tipos de arreglos revisados en la asignatura. 3. Elabora un cuadro sinptico en el que identifiques los diferentes tipos de arreglos y sus diferencias. 4. Ingresa al foro y genera una nueva entrada. 5. Contribuye con algn comentario a por lo menos dos compaeros(as) sobre su discernimiento del tema. 4. Elabora las diferencias entre los diversos tipos de arreglos, esto ser como conclusin del foro; hazlo basndote en las aportaciones de los compaeros(as).
4.1.2. Recorrido
Los elementos contenidos en los arrays estn controlados por la posicin que ocupen dentro del array. As, en el ejemplo anterior se tena una declaracin de un array de tipo String que contendra 4 elementos, refirindose a los nombres propios de 4 personas:
Si, por alguna necesidad especial de la situacin, se quisiera imprimir a pantalla el contenido del array nombres indicando la posicin de cada nombre, bastara con hacer lo siguiente:
92

Donde se indica al arreglo que se quiere imprimir el valor que est en la posicin i-sima, esta instruccin se le indica al lenguaje Java cuando se pone el nombre del arreglo con el cual se quiere trabajar, seguido de la posicin que se desea recuperar (para impresin, operaciones, clculos, entre otros) encerrado entre corchetes([]). La salida de estas instrucciones escritas en lenguaje Java, al compilar y ejecutar el programa (se obvian las partes faltantes de la clase por cuestiones didcticas) sera la siguiente:
Imagina la cantidad de lneas necesarias para imprimir el nombre de todos los alumnos que pertenecen a una universidad cuya matrcula es un total de 5,000 alumnos. Como se podr deducir fcilmente se necesitaran 5,000 lneas como las anteriores. Para solucionar la cuestin anterior de forma un tanto ms sencilla se utilizan ciclos, que como ya se sabe, facilitan la ejecucin de operaciones secuenciales y repetitivas pero necesarias, como en el caso de los arrays. Adems que los ciclos son controlados por ndices (su comienzo y su fin) y sta es la misma forma de acceder a los elementos de un array, como ya se haba explicado. A continuacin se presenta la misma impresin del contenido del array nombres, pero utilizando un ciclo for:
93

Y la salida ser:
Segn las nuevas instrucciones, se introdujeron algunas variaciones para poder hacer el recorrido funcional y se explica a continuacin: Cuando se declara un arreglo se indica el total de elementos que contendr dentro de l (lmite del arreglo); este mismo lmite es el total de repeticiones que deber ejecutar el ciclo for, indicado con i<4 (ya que si se indica un nmero mayor, Java lanzar una excepcin indicando que se intenta acceder a una locacin de memoria no reservada o inexistente). De igual manera el inicio del array debe comenzar por el nmero 0 (cero) y esto se indica en el ciclo for al hacer la declaracin i=0 que indica que desde esa posicin comenzar a iterar. Finalmente se le indica al arreglo que se quiere hacer el recorrido de sus elementos de uno en uno (aunque podra ser diferente, de dos en dos por ejemplo) para poder obtener el contenido total del array, en el ciclo for se le indica con la instruccin i++. As, a la hora de colocar la lnea de impresin System.out.println(nombres[i]+ est en la posicin +i); hacemos referencia al elemento i-simo indicado entre corchetes, pero en lugar de indicarle un nmero fijo, se le indica la posicin que se desea imprimir con la variable i que a voluntad del programador iniciar, terminar y se ir incrementando segn lo explicado de las partes que conforman al ciclo for.
4.1.3. Operaciones
Al referirse a operaciones con arrays no es en el sentido clsico de operaciones aritmticas sobre ellos (aunque se pueden hacer y se ejemplificar) sino a cmo se Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 94

obtienen sus elementos, haciendo un profundo nfasis en la importancia que tienen los ndices para ello. Imagina que tenemos 2 arreglos unidimensionales, como sigue:
y se quiere hacer una suma y multiplicacin punto a punto (posicin a posicin) de cada uno de sus elementos, y almacenarlos en un tercer array para cada operacin sugerida, luego imprimir el resultado de la acumulacin de las operaciones. Se ejemplifica con la siguiente porcin de cdigo:
Ntese la importancia de los ndices para poder acceder a los elementos de los arrays y de la misma manera para almacenar resultados. Se puede utilizar un mismo contador para n arrays, siempre y cuando stos sean del mismo tamao, como en el ejemplo anterior, donde se sum y multiplic en un mismo Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 95

ciclo. Solo en las impresiones, dado que se buscaba que el resultado se viera de manera independiente, se utilizaron ms ciclos for, tantos como nmeros de resultados se quiera mostrar.
Actividad 2. Operaciones con arreglos

Esta actividad tiene como finalidad que identifiques la declaracin y recorrido de arreglos unidimensionales en Java.
6.
En NetBeans crea un nuevo proyecto.
7. Dentro de la clase Main crea un mtodo, donde se solicite al usuario un nmero para determinar el tamao de un arreglo, seguido a esto, se solicite al usuario ingrese elementos para llenar el arreglo, y por ltimo se muestre ese mismo arreglo en una salida pero con cada elemento elevado al cubo. La llamada a esto mtodo estar dada en el mtodo main. 8. Guarda la actividad con el nombre POO_U4_A2_XXYZ.Sustituye las XX por las dos primeras letras de tu primer nombre, la Y por la inicial de tu apellido paterno y la Z por la inicial de tu apellido materno. 9. Revisa y comenta los proyectos de al menos dos compaeros(as).
10. Enva el archivo a tu Facilitador(a)para recibir retroalimentacin.
4.2 Arreglos multidimensionales

Los arreglos vistos en la seccin anterior solo son de una dimensin, es decir solo se manejaban a manera de rengln (o fila). En cambio los multidimensionales se manejan a manera de tabla, donde se tendrn filas y columnas, por lo que este tipo de arreglos ofrece un mejor manejo de datos cuando stos deben manejar dimensiones, como la informacin mostrada en hojas de clculo o tablas de bases de datos.
96

4.2.1. Declaracin
Los arreglos multidimensionales tienen ms de una dimensin. En Java, las dimensiones se manejan por medio de corchetes (muy parecido a los arrays unidimensionales), dentro de los cuales se escribe cada dimensin (cantidad de datos que guardar). Cada dimensin ir dentro de un corchete. La sintaxis general para declarar e instanciar un array es:
Adems, como ya se mencion, se pueden usar en Java arrays de cualquier tipo de dato soportado, incluso los definidos por el usuario:
Ahora bien, la declaracin de los arrays en Java se hace mediante una variable referenciada, es decir, no se guarda el valor del contenido del array, lo que se guarda es una referencia de la locacin de memoria donde estn alojados dichos datos. Con lo que se acaba de ver, fcilmente se puede deducir que los arrays son objetos. Cuando se hace la declaracin de un array en Java se consideran dos posibles opciones: Declararlo vaco o Declarar colocando valores. Declararlo vaco.
97

La estructura general, si pudiera observarse la reserva de memoria que hace Java sobre la memoria principal de la computadora, sera como sigue:
Declarar colocando valores
Observa que la estructura que se muestra, coincide perfectamente con las dimensiones declaradas en el arreglo intnumeros[][] = new int[3][3]; donde el nmero contenido en el primer corchete corresponde al nmero de filas que contendr el array, por ende, el nmero contenido en el segundo corchete corresponde al nmero de columnas que contendr el array, de esta manera se analizar una estructura diferente, como la que sigue:
Quedara as:
98

Declararlo con valores iniciales es un poco diferente, como la declaracin para arrays unidimensionales, pues se debe especificar explcitamente el contenido de cada dimensin del array.
4.2.2. Recorrido
El recorrido de los elementos de un array multidimensional es de la misma manera que en un arreglo unidimensional, slo agregando un corchete por cada dimensin que se aada, considerando lo siguiente: Se puede acceder a los valores de los elementos de un arreglo bidimensional a travs del nombre del arreglo y dos subndices. Los subndices deben escribirse entre corchetes y representan la posicin del elemento en el arreglo. As, es posible referirse a un elemento Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 99

del arreglo escribiendo el nombre del arreglo y los subndices del elemento entre corchetes. Los valores de los subndices empiezan en cero para el primer elemento, hasta el tamao del arreglo menos uno. Tmese como ejemplo el siguiente cdigo, donde se recorre e imprime el array bidimensional llamado nombres:
La salida esperada para esta porcin de cdigo ser:
Observa el aumento de los contadores y la manera en que van incrementndose, ya que ah es donde radica la importancia del recorrido de los arreglos, en la posicin de sus contadores.
4.2.3. Operaciones
Como los arrays unidimensionales y multidimensionales son tan parecidos en su mtodo de acceso (que de hecho es idntico), se ejemplifica los arrays multidimensionales de la misma manera que se hizo con los arrays unidimensionales, slo modificando sus dimensiones: Imagina que tenemos 2 arreglos unidimensionales, como sigue:
100

//recuerda que el nmero total de elementos de un array multidimensional es la multiplicacin de cada dimensin contra todas las restantes, y se quiere hacer una suma y multiplicacin punto a punto (posicin a posicin) de cada uno de sus elementos y almacenarlos en un tercer array para cada operacin sugerida, luego imprimir el resultado de la acumulacin de las operaciones. Se ejemplifica con la siguiente porcin de cdigo:
Nota la importancia de los ndices para poder acceder a los elementos de los arrays y de la misma manera para almacenar resultados. Se puede utilizar un mismo contador para n arrays, siempre y cuando stos sean del mismo tamao, como en el ejemplo anterior donde se sum y multiplic en un mismo Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software 101

ciclo. Slo en las impresiones como se buscaba que el resultado se viera de manera independiente, se utilizaron ms ciclos for, tantos como nmeros de resultados se quiera mostrar.
Actividad 3. Inversin de arreglos

El propsito de esta actividad es que identifiques la declaracin y recorrido de arreglos multidimensionales en JAVA.
1.
En NetBeans crea un nuevo proyecto.
2. Dentro de la clase Main crea un mtodo, donde se soliciten al usuario dos nmeros X y Y, y sean X el nmero de filas, Y el nmero de columnas de un arreglo, seguido a esto, se solicite al usuario ingrese elementos para llenar el arreglo, y por ltimo se muestre ese mismo arreglo en una salida pero en orden inverso. La llamada a esto mtodo estar dada en el mtodo main. 3. Guarda la actividad con el nombre POO_U4_A3_XXYZ. Sustituye las XX por las dos primeras letras de tu primer nombre, la Y por la inicial de tu apellido paterno y la Z por la inicial de tu apellido materno. 4. Enva el archivo a tu Facilitador(a) para recibir retroalimentacin.
Autoevaluacin
Para reforzar los conocimientos relacionados con los temas que se abordaron en esta primera unidad del curso, es necesario que resuelvas la Autoevaluacin de la unidad. Recuerda que es muy importante leer cuidadosamente los planteamientos indicados y elegir la opcin adecuada para cada uno. Ingresa al aula para realizar la actividad.
Evidencia de aprendizaje. Men del curso
102

Como parte de la evaluacin de esta unidad, debes realizar un programa cuyo propsito es que logres identificar los componentes de un programa modular y puedas aplicarlos. 5. En NetBeans crea un nuevo proyecto, y crea tantas clases como ejercicios se han realizado a lo largo del cuatrimestre, donde cada clase incluya cada programa. En la clase Main se debe contar con un mensaje tipo men al usuario, y este podr elegir ejecutar cualquier programa; en el mtodo main se debe tener un switch que tenga la llamada a todos los mtodos en forma de men y que al elegir el usuario un nmero se ejecute ese programa. 6. Consulta la Escala de evaluacin. 7. Guarda la evidencia con el nombre POO1_U3_EA_XXYZ. Sustituye las XX por las dos primeras letras de tu primer nombre, la Y por la inicial de tu apellido paterno y la Z por la inicial de tu apellido materno. 8. Enva la carpeta del proyecto a tu Facilitador(a) para recibir retroalimentacin. * Recuerda que puedes volver a enviar tu archivo tomando en cuenta las observaciones de tu Facilitador(a).
Autorreflexiones
Adems de enviar tu trabajo de la Evidencia de aprendizaje, es importante que ingreses al foro Preguntas de Autorreflexin y consultes las preguntas que tu Facilitador(a) presente, a partir de ellas, debes elaborar tu Autorreflexin en un archivo de texto llamado POO_U4_ATR_XXYZ. Posteriormente enva tu archivo mediante la herramienta Autorreflexiones.
Para saber ms
Consulta la pgina oficial del lenguaje Java, donde podrs encontrar manuales de referencia sobre arreglos. Java: http://www.java.com/es/
103

Fuentes de consulta
Froufe, A. (2009) Java 2, Manual de usuario y tutorial. Mxico: Alfaomega, RaMa. Hejlsberg, A., Torgersen, M., Wiltamuth, S. & Golde, P. (2011) C# Programming Language (Covering C# 4.0), The 4th Edition (Microsoft .NET Development Series). USA: Ed. Addison-Wesley.
104

04 PD DS Poo1

Uploaded by

Document Information

Original Title

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

04 PD DS Poo1

Uploaded by

Copyright:

Available Formats

Programacin orientada a objetos I

CARRERA: Ingeniera en Desarrollo de Software Cuatrimestre 04

Programa de la asignatura: Programacin Orientada a Objetos I

Clave: 160920414 / 150920414

Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software

Programacin orientada a objetos I

I. INFORMACIN GENERAL DE LA ASIGNATURA ............................................. 7

II. DESARROLLO DE CONTENIDOS POR UNIDAD ........................................... 15

Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software

Programacin orientada a objetos I

UNIDAD 2. MTODOS Y ESTRUCTURAS DE CONTROL ................................. 50

Programacin orientada a objetos I

UNIDAD 3. CARACTERSTICAS DE POO Y EXCEPCIONES ............................ 75

Programacin orientada a objetos I

UNIDAD 4. ARREGLOS ....................................................................................... 89

Programacin orientada a objetos I

Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software

Programacin orientada a objetos I

I. Informacin general de la asignatura a. Ficha de identificacin

Programacin orientada a objetos I

Programacin orientada a objetos I

Programacin orientada a objetos I

Programacin orientada a objetos I

Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software

Programacin orientada a objetos I

10% 30% 40% 10% 10% 100% 12

Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software

Programacin orientada a objetos I

Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software

Programacin orientada a objetos I

Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software

Programacin orientada a objetos I

Programacin orientada a objetos I

Para comenzar tu participacin, ingresa a la Actividad 1.Presentacin en el aula.

1.1. Caractersticas de la Programacin Orientada a Objetos

Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software

Programacin orientada a objetos I

Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software

Programacin orientada a objetos I

1.1.5. Programacin orientada a objetos vs estructurada

Programacin orientada a objetos I

Actividad 2. Diferencias entre Programacin estructurada y POO

Programacin orientada a objetos I

Actividad 3. Caractersticas de JAVA

1.2. Caractersticas del lenguaje JAVA

Programacin orientada a objetos I

1.2.1. Generalidades de JAVA

Programacin orientada a objetos I

Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software

Programacin orientada a objetos I

Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software

Programacin orientada a objetos I

Programacin orientada a objetos I

Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software

Programacin orientada a objetos I

1.2.2. Mquina virtual de JAVA

Programacin orientada a objetos I

Figura 1.1. Funcionalidad de la Mquina Virtual de JAVA (Zukowski, 1997).

1.2.3. Entorno de desarrollo y configuracin

Programacin orientada a objetos I

Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software

Programacin orientada a objetos I

Ciencias Exactas, Ingenieras y Tecnologa | Ingeniera en Desarrollo de Software