Manual Fundamentos de Programación 1.1

1
Manual para la asignatura de Fundamentos de Programacin Versin 1.0. Santiago Marzo de 2012
Este material ha sido diseado para el uso de los alumnos y profesores de la asignatura de Anlisis y Diseo Orientado a Objetos de las carreras del rea informtica. Queda estrictamente prohibido el uso en otros cursos ya sean en lnea o presenciales sin el consentimiento explcito de INACAP.
UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES
Agradecemos a todas las personas que de forma directa o indirecta han colaborado en la elaboracin de este manual. De forma significativa agradecemos a los docentes de las sedes que nos han apoyado y colaborado con ejercicios y propuestas durante la presentacin de este proyecto. Vayan nuestros sinceros agradecimientos a los siguientes docentes: Cristian Leiva Marn, Miguel Palma Esquivel, Marcelo Montecinos Cabrera, Rodrigo Toledo de los Santos, Paola Cifuentes Berrios, Servando Campillay Briones, Emerson Ilaja Villarroel, Hugo Herrera Valenzuela, Prez Fernando Fuentes, Santolaya, Manuel Morales, Roberto
Agradecimientos.
Fernando Neyra Castro, Victor Brquez, Francisco Andrs Daz Rojas, Ademar Araya Fuentes, Ricardo Vera Muoz, Mauricio Torres Pizarro, Ernesto Ramos Vega, Alberto Garrido Burgos, Helton Bustos Sez, Beatriz Contreras Guajardo, Jos Landeta Parra, Luis Pacheco Toro, Patricio Araya Castro, Ivn Torres, Hinojoza Vega Mauricio, Yasna Hernndez, Vctor Orellana, Rene Valderas Aros, Ricardo Toledo Barra, Cesar Eduardo Arce Jara, Luis Ponce Cuadra, Caballero, Javier Pedro Miles Avello, Carolina Ehrmantraut Jorge Alfonso Fuentealba Martnez,
Hormazabal Valds, Pedro Ernesto Ulloa Morales, Mara del Pilar Gallego Martnez, Claudio Fuenzalida Medina, Mara Encarnacin Seplveda, Francisco San Martin, Christian Sarmiento Zampillo, Romn Gajardo Robles, Ricardo
Hidalgo Hidalgo, Nelson Fredy Ganga Caldern, Manuel Reveco Cabellos, Jacqueline San Martin Grandon, Sergio Vergara Salvatierra, Pablo Lpez Chacn, Cinthya Acosta, Jocelyn Oriana Gonzlez Corts, Carlos Felipe Alten Lpez, Francisco Prieto Rossi, Giannina Costa Lizama, Christian Silva, Sebastin Pastn Daz.
El aporte realizado por ustedes durante las jornadas de capacitacin ha significado mejorar enormemente la calidad del material entregado. Saludos.
Contenidos
Fundamentos del procesamiento de datos. ....................................................................................... 8 Conceptos bsicos. .......................................................................................................................... 8 Dato ........................................................................................................................................... 10 Proceso ...................................................................................................................................... 10 Informacin. .............................................................................................................................. 12 Entrada y Salida. ........................................................................................................................ 12 Proceso manual de datos. ......................................................................................................... 13 Proceso computacional de datos. ............................................................................................. 13 Estructura funcional de un computador. ...................................................................................... 14 Dispositivos de entrada y salida. ............................................................................................... 14 Unidades Internas. .................................................................................................................... 15 Unidades externas de almacenamiento secundario. ................................................................ 16 Elementos o componentes de un procesamiento computacional de datos. ............................... 18 Plantilla para prueba manual o seguimiento de ejecucin de una secuencia lgica.................... 22 Tcnicas de algoritmos para el diseo de procesos computacionales. ............................................ 26 Conceptos bsicos. ........................................................................................................................ 26 Algoritmo................................................................................................................................... 26 Programa. .................................................................................................................................. 32 Etapas en la creacin de programas. ....................................................................................... 32 Caractersticas de la programacin. .............................................................................................. 39 Estructura descendente. ........................................................................................................... 39 Modularidad. ............................................................................................................................. 40 Cohesin. ................................................................................................................................... 40 Acoplamiento. ........................................................................................................................... 41 Descomposicin. ....................................................................................................................... 42 Estructura de un algoritmo. .......................................................................................................... 43 Conceptos de variables y constantes. ........................................................................................... 44 Definicin de variables y constantes. ........................................................................................ 44 Representacin de sentencias en Instrucciones. .......................................................................... 60
5 Operadores Aritmticos. ........................................................................................................... 60 Operadores unarios y de auto asignacin................................................................................. 61 Operadores Lgicos ................................................................................................................... 62 Introduccin a lenguajes formales de Programacin. ...................................................................... 66 Estructura de un programa. .......................................................................................................... 66 Sentencia condicionales ................................................................................................................ 67 Anidada. .................................................................................................................................... 75 Mltiple ..................................................................................................................................... 77 Sentencias de ciclo iterativo.......................................................................................................... 79 While ......................................................................................................................................... 80 For ............................................................................................................................................. 81 Do While. ............................................................................................................................... 85 Concepto de funcin ..................................................................................................................... 86 Estructura de una funcin ............................................................................................................. 89 Procedimientos ......................................................................................................................... 89 Funcin .......................................................................................................................................... 95 Llamada a una funcin .................................................................................................................. 97 Arreglos ....................................................................................................................................... 108 Unidimensionales .................................................................................................................... 108 Arreglos de dos dimensiones. ..................................................................................................... 111 Arreglos de arreglos. ............................................................................................................... 113 Introduccin a la Programacin Orientada a Objeto. ..................................................................... 117 Caractersticas generales de la programacin orientada a objetos. ........................................... 117 Qu es la programacin orientada a objetos .............................................................................. 117 Atributos...................................................................................................................................... 119 Comportamientos ....................................................................................................................... 120 Estados ........................................................................................................................................ 121 Clase ............................................................................................................................................ 122 Abstraccin.............................................................................................................................. 126 Encapsulacin .......................................................................................................................... 127 Herencia .................................................................................................................................. 128 Asociacin. ................................................................................... Error! Marcador no definido.
6 Aplicaciones bsicas .................................................................................................................... 129 Seguridad en una clase................................................................................................................ 138 Get y Set. ..................................................................................................................................... 142
Fundamentos del procesamiento de datos.

A continuacin vamos emprender un viaje slo de ida, no te preocupes no se trata de un trgico final, es slo de ida porque luego que conozcas todo lo que hay preparado para t en las pginas venideras no querrs volver atrs. Durante este manual nos encargaremos, con tu ayuda y por supuesto la de tu profesor, de dar los primeros pasos para convertirte en un desarrollador de proyectos de tecnologas de la informacin, este manual es el primero de varios y en cada uno iremos agregando ms dificultad, mayores novedades y elementos cada vez ms sorprendentes.
Conceptos bsicos.
Ahora nos referiremos de tienen el a los todos mismo fundamentos los objetivo, del procesamiento computacionales datos, programas primero
obtener datos de entrada (por lo general desde un usuario), luego los almacena, despus realiza algn procesamiento (clculos, ordenamientos, etc) con ellos y finalmente entrega el resultado. El proceso es muy similar a cuando un detective est interrogando a un sospechoso en las pelculas, imagina esas tpicas salas de interrogatorio y un detective como el de las series de los aos ochenta, el cual est de pie y al frente el sospechoso sentado en una silla, cuando el detective se acerque a l, lo mire a los ojos y le diga smith
anderson, el sospechoso recibir esta informacin y realizar una bsqueda interna para luego de unos segundos de silencio dar el paradero de Smith y otra informacin relevante para su detencin al detective, en este caso lo que el detective hace es recolectar datos durante su caso, pero estos datos por si slo no permitirn resolverlo, por otra parte los datos son en realidad alguna caracterstica de algo o alguien, Smith por ejemplo, es el nombre de una persona, pelo negro, 34 aos, 1.72 metros son tambin datos que representan a una entidad, pero para que el detective resuelva el caso necesita del sospechoso a quien le dio los datos como una entrada para que as el sospechoso haga algn tipo de procesamiento con los datos, los cuales pueden ser una suma, restas o alguna otra operatoria como por ejemplo una bsqueda, a partir de este procesamiento interno, el sospechoso logr obtener la direccin de Smith la cual gener como una salida hacia el detective. Lo que ha recibido el detective a cambio de la entrega de datos es informacin relevante para l. As como esta situacin el software se comporta de forma muy similar piensa los ltimos software que has usado, un ejemplo de ello es la calculadora de Windows a la cual le entregas datos de entrada, luego solicitas una operacin y presiones el botn igual, esto da como resultado que la calculadora procese los datos y finalmente entregue el resultado. Veamos ahora otro ejemplo, en el caso de un videojuego, el cual parece ser tan distinto a una calculadora sigue los mismos principios, a travs del
10
joystick el usuario ingresa datos de entrada con los cuales especifica la direccin en la que desea moverse, el software recibe estos datos los almacena y los procesa, al final el software presenta al usuario la informacin solicitada en la cual el personaje se encuentra ahora en una posicin distinta pero de acuerdo a lo que el usuario ha ingresado. Este modelo es muy simple y consta de tres partes, dato, proceso e informacin, las cuales se definen a continuacin.
Dato
Corresponde a un par ordenado de atributo con valor (atributo, valor) que representan el registro de un hecho importante para la organizacin en un momento determinado. Un dato esta compuesto de dos partes, un atributo y un valor, el atributo define que es lo que deseo guardar y el valor define el tipo de valor asociado, es decir el tipo de datos y sus valores mximos y mnimos. Los datos siempre estn formados por un par ordenado, ya que, sus partes por separado carecen de sentido.
Proceso
Corresponde a la aplicacin de clculos aritmticos, ordenamientos o algn otro tipo de manipulacin de los datos y que a partir de ello genera informacin.
11
Vemoslo a travs de un ejemplo, supongamos que tienes en tu closet una caja de pelculas, la forma en la que se han guardado las pelculas en la caja no ha sido mediante ningn orden, muy por el contrario han sido guardadas en el mismo orden que las has adquirido, por lo que hay dentro de la caja es un completo desorden que hace juego con el resto del closet. Para poder ver la pelcula que tanto anhelas vas a tener que buscarla, este proceso comienza con un dato de entrada, para el cual vas a necesitar el nombre de la pelcula (un dato), el cual puede ser por ejemplo: Nombre pelcula = hoy si estudiar. A partir de este dato el proceso que debes llevar puede variar segn tu forma de hacer las cosas, un posible camino es hacer una comparacin, proceso que consiste en tomar las pelculas una por una e ir comparando su nombre con el de la pelcula que buscas hasta dar con ella, otro camino puede ser verificar si ellas se encuentran ordenadas, de ser as bastar con realizar una bsqueda basado en el alfabeto para dar con ella, de no estar ordenadas entonces podras ordenarlas, as este proceso ser ms simple la prxima vez, el resultado de esta bsqueda ser un la buen pelcula consejo que deseas ver, adicionalmente ser considerar
mantener tu closet ordenado.
12
Informacin.
Mensaje vlido para un receptor resultante del procesamiento de datos. Debes considerar que no todo lo resultante de un proceso es informacin si esta no va dirigida a quien corresponde, por ejemplo, si vas caminando por afuera del aeropuerto y un mensaje que dice se informa que el vuelo 345 tiene un retraso de 45 minutos, sin duda eso es informacin y ha nacido desde el clculo de la posicin del vuelo, la distancia con el aeropuerto y la velocidad que lleva, sin embargo para ti que slo buscas un taxi, esa informacin no te sirve, por ende deja de ser informacin para ti.
Entrada y Salida.
Como lo mencionamos al inicio los software llevan a cabo principalmente cuatro acciones: recibir datos de entrada, almacenarlos, procesarlos y entregar un resultado. Muchas veces la palabra dato e informacin son utilizadas indistintamente, pero sin embargo en este contexto son muy distintas. Cuando un usuario interacta con un software es el usuario el que provee de datos al programa, estos datos como la definicin lo dice son la representacin de una entidad, es decir son datos que representan el valor de una entidad, cuando estos datos son recibidos por el software este los almacena en la memoria, luego los toma, los procesa, es decir realiza algn tipo de clculo en ellos para luego depositarlos nuevamente en la memoria. Podemos decir entonces que
13
dato e informacin no son lo mismo, debido a que para que los datos se conviertan en informacin deben haber pasado primero por un procesamiento. En general los datos por si solos no sirven para tomar una decisin en cambio la informacin s sirve para tomar decisiones.
Proceso manual de datos.

El procesamiento manual ha existido desde siempre y corresponde a toda transformacin o clculo que se realice con datos mediante clculos mentales o con la utilizacin de lpiz y papel, esta tcnica es muy propensa a errores sobre todo cuando se trata de realizar grandes clculos o la clasificacin y ordenacin de un conjunto muy numeroso de datos. Adicionalmente el proceso se lleva a cabo de forma lenta, lo que produce que muchas veces sea una tcnica poco viable para las empresas de hoy, las cuales procesan los datos de millones de personas.
Proceso computacional de datos.

El proceso computacional en cambio corresponde a la automatizacin de procesos comunes que en su comienzo solan hacerse con lpiz y papel, las operaciones aritmticas bsicas fueron un comienzo y as la tcnica ha ido refinndose hasta llegar a lo que hoy nos rodea: planillas de Excel, sistemas bancarios para llevar las cuentas de miles de clientes y reconocimiento facial o procesamiento de imgenes son algunos ejemplos, esto nace de la necesidad de que la informacin debe estar en el momento en que se necesita, imagina qu sucedera si
14
tratsemos de llevar el censo de nuestro pas utilizando el proceso manual, es probable que cuando los resultado estn listos la informacin generada no represente en lo absoluto la realidad nacional y por ello lo que en un momento hubiese sido informacin vital hoy es slo un dato que no sirve.
Estructura funcional de un computador.

Dispositivos de entrada y salida.
Si bien un software se basa en el procesamiento computacional informacin no de datos con que el fin estos de entregar se olvidemos software
almacenan y ejecutan dentro de un computador, es por ello que los computadores deben proveer alguna forma en la que podamos comunicarnos con ellos, todo los computadores poseen lo que se conoce como perifricos los cuales podemos dividir en entrada y salida. Los perifricos de entrada son todos aquellos dispositivos que permiten ingresar informacin, algunos ejemplos de ello son el teclado a travs del cual digitamos, el mouse, un escner el cual nos permite digitalizar las fotos o alguna imagen, el micrfono que utilizamos para chatear, o dictar un documento a nuestro computador. Los perifricos de salida en cambio son todos aquellos dispositivos que permiten al computador emitir informacin que ha procesado producto de los datos que
15
hemos ingresado, probablemente el ms utilizado de todos sea el monitor, en la cual el computador nos muestra la informacin requerida, otros ejemplos son la impresora, la que nos permite obtener la informacin en papel o los parlantes, que emiten sonidos segn lo que le pidamos o hagamos.
Unidades Internas.
En un computador el encargado de procesar toda la informacin es la Unidad Central de Proceso CPU (Central Processing Unit). Esta unidad es la encargada del control y de la ejecucin de las operaciones del sistema, tambin lo conocemos como el microprocesador. Las actividades que realiza la CPU son: Ejecutar las instrucciones de los programas
almacenados en la memoria. Controlar la transferencia entre la CPU y la memoria. Responder perifrico. a las peticiones realizadas por algn
Unidad de control.
Coordina las actividades del computador y determina qu operaciones se deben realizar y en qu orden; as mismo controla todo el proceso del equipo.
16
Unidad Aritmtica-lgica
Realiza operaciones aritmticas y lgicas, entre las operaciones aritmticas se encuentras las sumas o restas y en las lgicas las comparaciones del tipo mayor, menor, igual, etc.
Unidad de almacenamiento principal.

Es la parte de la CPU en la que se encuentran almacenadas las instrucciones y todos los datos que necesarios para llevar a cabo un proceso, esta memoria es temporal, esto quiere decir que si apagas el equipo toda la informacin alojada ah es eliminada, el procesador usa esta memoria debido a que es un lugar a la que puede acceder ms rpido, es por esto que los datos son cargados aqu como paso previo a su ejecucin. La unidad de almacenamiento principal es popularmente conocida como memoria RAM.
Unidades externas de almacenamiento secundario.

Adicional a los datos que el computador almacena de forma temporal para su procesamiento, existen dispositivos de almacenamiento que permiten que la informacin perdure en el tiempo y que se encuentran fuera del equipo, algunos ejemplo de ellos son el CD, DVD, blueray o memorias flash, en ellos se almacenan datos que podrn ser procesados ms adelante y su almacenamiento es permanente e independiente de si el computador est prendido o apagado.
17
Para ayudarte a comprender mejor cmo el computador utiliza los dispositivos de almacenamiento vemoslo con una simple analoga. Supongamos que t eres el procesador y tu misin hoy es recolectar un conjunto de datos histricos para procesarlos y crear con ellos un resumen de historia, el cual contiene informacin relevante para quien lo solicit, muy lejos de la silla y el escritorios donde te encuentras hay un estante llenos de libro, los cuales siempre estn all, este estante es el equivalente al disco duro de tu computador, pero imagina tuvieses que levantarte de la silla, ir hasta el estante, tomar un libro, volver a tu silla, buscar lo que necesitas y luego volver a dejarlo al estante para luego complementar el informe con otro libro lento verdad? Entonces al igual que t, el computador necesita traer un conjunto de datos para mantenerlos temporalmente ms cerca, entonces ese rol lo jugar el escritorio, de esta forma te acercars al estante y traers en uno o ms viajes todos los libros que necesites y lo dejars sobre tu escritorio, de esta forma no necesitars levantarte tan seguido, nuestro escritorio es el equivalente a la memoria RAM, por lo que tambin podemos afirmar que mientras ms memoria RAM tengamos mejor rendimiento tendremos, ya que podremos almacenar y dejar ms informacin all, ahora que mantenemos los datos cerca, para que puedas leer y producir un resumen con tu cerebro (equivalente al procesador de tu PC), necesitars acercar los libros que tienes en tu escritorio, lo recogers con la mano para de esta forma logrado acercar ms la
18
informacin, as estar lista para ser leda y procesada por t, tu mano en esta analoga es el equivalente a la memoria cache de tu procesador, cuando hayas finalizado tu informe todo lo que se encuentra en tu mano y escritorio desaparecer, pero volver a quedar de forma permanente en tu estante, esto se debe a que tu mano y el escritorio almacenan informacin slo de forma temporal, en el computador la RAM y la CACHE se comportan de la misma forma y existen con el fin de acercar la informacin hacia el procesador, dado que es ms rpida su lectura desde all, sin embargo este tipo de memoria mientras ms rpida suele ser ms pequea, al igual que la proporcin entre tu mano, escritorio y estante, que adicionalmente va desde la ms asequible a la ms distante, siendo la mano la unidad de almacenamiento ms pequea y el estante la ms grande.
Elementos o componentes de un procesamiento computacional de datos.

Cuando analices un proceso o un sistema, siempre debes prestar atencin a las etapas o acciones que se ejecutan en el sistema que ests analizando. Recuerda que los sistemas estn compuestos de una serie de elementos que interactan entre s para lograr un propsito. Para lograr este propsito cada uno de los objetos detectados en el proceso realizan un conjunto de acciones. Para
19
poder realizar estas acciones, las partes componentes necesitan datos de entrada. Estos datos son la materia prima con la cual los objetos realizan sus acciones. Una vez que reciben los datos, los objetos realizan las acciones para las cuales fueron creados, generando un resultado que se conoce como dato de salida. Podemos analizar las acciones que realiza un objeto como una caja negra es decir sabemos lo que entra y el resultado del proceso pero no lo que sucede adentro. Por ejemplo si utilizo un reproductor de DVD, los datos de entrada estn contenidos en el disco que ingreso al equipo, y la salida ser la imagen y el audio, pero el proceso es desconocido y por lo dems no me interesa, pues slo quiero ver el DVD no construir un reproductor. Ahora si mi necesidad aumenta y adems de usar un reproductor de DVD ahora quiero construir uno, entonces debo conocer qu es lo que hace el dispositivo con los datos que estn en el disco para generar la imagen y el audio, esto se conoce como procesamiento de los datos, el cual bsicamente consiste en leer los datos, ordenarlos y guardarlos, procesarlos y finalmente generar una salida. El procesamiento de los datos est asociado a la toma de decisiones, que se estructuran bsicamente siguiendo una serie de reglas y condiciones que en lenguaje informtico se conocen como reglas del negocio. Estas reglas y condiciones se basan en la definicin de cmo se debe comportar el sistema para tratar los datos que entran a ser procesados. Veamos un ejemplo,
20
supongamos que tienes un telfono celular de prepago y debes cargarle dinero cada cierto tiempo para poder realizar llamadas. Analicemos el proceso de carga de dinero con un poco ms de detalle Qu datos de entrada necesitamos?, si dices que lo que necesitas es solamente el dinero que vas a cargar, es correcto, pero eso es todo?, pensemos un poco ms en detalle y pongmonos en algunos casos especiales, es tu telfono el nico telfono en el sistema?, claramente no por lo tanto es necesario identificar a qu telfono quieres cargar el dinero, ah aparece un nuevo dato que es el nmero de telfono. Por lo tanto ahora ya tenemos los siguientes datos de entrada, el nmero de telfono y el monto de dinero que vas a cargar. Ahora la pregunta es la siguiente, que hace el sistema con los datos de entrada?, una respuesta acertada sera decir que suma al saldo anterior el valor que se est cargando, pero a cual de todos los telfonos que existen lo carga?, entonces ah determinamos que primero hay que buscar la informacin asociada al telfono y luego sumar el valor al saldo de dinero que tiene el telfono. As determinamos que el proceso se define en dos pasos: 1. Buscar los datos del telfono usando el nmero. 2. Sumar el valor a cargar al saldo existente. Si te fijas ya estamos avanzando, pero ahora comienzan a surgir algunos inconvenientes, supongamos que buscas los datos del telfono y te das cuenta que no es un telfono de prepago sino que uno con plan, entonces Qu haces?, si te fijas debes tomar un decisin usando
21
una regla, pensemos que hacer, todos los telfonos tienen el mismo plan?, la respuesta es no, de hecho existen bsicamente tres planes, prepago, cuenta controlada y plan ilimitado, slo a los dos primeros se les puede cargar dinero, pero bajo circunstancias distintas, al plan de cuenta controlada slo le puedes cargar ms dinero cuando se ha acabado el dinero anterior, mientras que al de prepago se le puede cargar en cualquier momento y si tienes plan ilimitado no le puedes cargar dinero. Con estos datos del proceso completo podemos definir que las condiciones son las siguientes: 1. Buscar los datos del telfono usando el nmero. 2. Identificar si el telfono tiene plan ilimitado. 3. Si lo tiene no se le puede cargar dinero. 4. Si no tiene plan ilimitado entonces hay que saber si el telfono tiene plan de cuenta controlada. 5. Si tiene plan de cuenta controlada, debemos fijarnos en el saldo y ver si an tiene. 6. Si tiene plan de cuenta controlada y tiene saldo no podemos cargar dinero. 7. Si tiene plan de cuenta controlada y no tiene saldo, entonces podemos cargar el dinero. 8. Si no tiene plan de cuenta controlada entonces sumamos inmediatamente el dinero al saldo anterior. Ahora slo nos queda analizar cul es la salida resultante de este proceso. Si analizamos con detencin el objetivo del proceso es cargar dinero a tu telfono celular, as podramos definir dos posibles salidas, que son:
22
a) Un mensaje que diga que el proceso se realiz de forma correcta o incorrecta. b) El nuevo saldo luego de realizada la carga. Analicemos el primer caso, si el proceso nos devuelve un mensaje Podremos conocer el nuevo saldo?, la respuesta en este caso es no. Si devolvemos el nuevo saldo Podemos saber si el proceso se realiz de forma correcta?, la respuesta en este caso es si, pero depende de un factor que es el conocer de antemano el saldo que tena, as si al iniciar el proceso tena 0 peso y luego de cargar 2000, tengo en mi saldo 2000 es que se realiz el proceso son xito. Cabe destacar que ninguna de las soluciones es correcta y ninguna es incorrecta, pues ambas dependen de datos que faltan en la definicin del contexto del problema.
Plantilla para prueba manual o seguimiento de ejecucin de una secuencia lgica.

Si bien la resolucin de problemas simples como el planteado anteriormente pudiera parecer una tarea sencilla y libre de complejidades a veces es necesario corroborar si el proceso que hemos definido est correcto y podemos obtener el resultado deseado a travs de lo que se conoce como una traza, es decir el seguimiento de los valores que nos interesa controlar y el comportamiento que vaya a tener el sistema en funcin de estos valores.
23
Para hacer la traza de un programa se van anotando los valores que nos interesa controlar y qu es lo que sucede cuando esos valores cambian asocindolos a las decisiones que se realizan durante el proceso. Muchas veces se elabora una tabla para hacer la traza y registrar los valores de forma ordenada asociados a cada uno de los procesos y adems se realiza una tabla para cada uno de los distintos cursos que pueda tomar la operacin. Por ejemplo si hacemos la traza del ejemplo anterior de carga del telfono podramos dibujar la siguiente tabla:
Datos de control Nro de Valor a cargar telfono 84480965 3500
Acciones Buscar los datos del telfono El telfono tiene plan ilimitado? Salida
Tipo Plan Ilimitado Ilimitado
Saldo 0 0 0
Acciones Buscar los datos del telfono El telfono tiene plan ilimitado? Tiene cuenta controlada y su saldo es 0? Salida
Tipo Plan Cuenta Controlada Cuenta Controlada Cuenta Controlada
Saldo 0 0
3500
3500
Acciones Buscar los datos del telfono
Tipo Plan Prepago
Saldo 1000
24
El telfono tiene plan ilimitado? Tiene cuenta controlada y su saldo es 0? Tiene cuenta controlada y su saldo es mayor a 0? Es de prepago? Salida Prepago Prepago 1000 1000
Prepago
1000
Prepago 4500
Si te fijas en las tablas anteriores hay un conjunto de preguntas que generan una respuesta basndose en los valores proporcionados a la funcin. Para cada grupo de preguntas y respuestas se realiza alguna accin o acciones que llevan al resultado expresado en la salida.
Datos de control Nro de telfono 84480965
Acciones Buscar los datos del telfono El telfono tiene plan ilimitado? Si tiene cuenta controlada su saldo es 0? Salida
Valor a cargar 3500
Tipo Plan Cuenta Controlada Cuenta Controlada Cuenta Controlada
Saldo 1000 1000 1000
1000
25
26
Tcnicas de algoritmos para el diseo de procesos computacionales.

Conceptos bsicos.
Algoritmo.
La palabra algoritmo se deriva de la traduccin al latn de la palabra rabe alkhowarizmi, nombre de un matemtico y astrnomo rabe que escribi un tratado sobre manipulacin de nmeros y ecuaciones en el siglo IX. Un algoritmo es una serie de pasos organizados que describe el proceso que se debe seguir para dar solucin a un problema especfico.
Otra definicin ms especfica es: Conjunto de pasos finitos no ambiguos que permitan dar solucin a un problema especfico. A simple vista la definicin formal de algoritmo puede no ser tan clara por si sola, pero vers que un algoritmo es algo que ya conoces y lo mejor es que durante toda tu vida has ejecutado varios algoritmos sin darte cuenta, comencemos con un ejemplo bsico, has jugado alguna vez a encontrar el tesoro pirata siguiendo un mapa? Aquel papelito de color caf que dando un par de pasos en varias direcciones te lleva a un lugar que marca una X, pues aquel papel lo que tiene escrito dentro en realidad es un algoritmo. veamos por qu: primero el
27
papel nos seala el lugar de inicio, luego de ello las instrucciones que sigues dicen algo as como dos pasos a la derecha, un paso a la izquierda, este tipo de instrucciones son un conjunto de pasos finitos, dado que no son interminables, tiene un punto de comienzo (donde obliga a ubicarte) y un final (donde marca la X), tampoco son ambiguos por que no hay doble interpretacin para cada una de ellas, finalmente si sigues todas las instrucciones en orden encontrars el lugar donde esta la X, entonces tambin podemos aseverar que estos pasos sirven para resolver un problema especifico, el cual nos indica el camino desde un punto hasta otro, donde debajo de la gran X probablemente nos esperen algunas monedas de oro. Sin embargo y siguiendo este criterio muchas actividades van a comenzar a parecer un algoritmo y de hecho es muy probable que lo sean, sin embargo no todo es un algoritmo y es bueno que tambin sepamos reconocer lo que no lo es, supongamos que estas viendo un programa de televisin donde estn dictando una receta para cocinar un rico pastel baado en chocolate, esta receta ser entonces un algoritmo si los pasos de la preparacin especifican los factores de tiempo y material que se deben utilizar en cada uno de ellos, si en determinado momento entre el listado de actividades que hay que realizar existe alguno que diga algo as como agregue azcar a gusto el conjunto de instrucciones dejar de ser un algoritmo, debido a que existe un paso ambiguo.
28
En informtica computador
el
algoritmo es a
una de
las
piezas
fundamentales en el desarrollo de software ya que el responder algoritmos que nosotros diseemos y pediremos a l que ejecute, para ello lo haremos a travs de los lenguajes que el computador entiende, los cuales irs aprendiendo durante el desarrollo de tu carrera. Todo lo que ejecuta el computador son algoritmos, un buen diseo de un algoritmo hace mejor y ms rpido a un programa, cmo la te has detenido alguna vez a pensar calculadora resuelve las operaciones
encomendadas?, es probable que no, pero de lo que s podemos estar seguros es que la calculadora es una gran ejecutora de algoritmos, ya que cada calculo matemtico es resuelto mediante algoritmos, es decir pasos que ya estn definidos para resolver una operacin, de ellos podemos destacar el clculo del potencial, el cual es un algoritmo muy popular, que da solucin a clculos como por ejemplo 24 =16. Otro algoritmo famoso es el de Dijkstra, este algoritmo es el encargado de encontrar la ruta ms corta entre dos puntos, es muy posible que lo hayas visto sin saberlo en los video juegos, ya que este algoritmo es el encargado de hacer que tus tropas avancen desde un punto hacia otro buscando el mejor camino en muchos juegos de estrategia Hacer buenos algoritmos no es una tarea sencilla, requiere de prctica y mucha lgica, durante este manual vas aprender a desarrollar tu lgica y comprender qu partes componen el problema que deseas solucionar,
29
cules son los datos de entrada y cul es el conjunto de pasos que debes aplicar sobre los datos para generar el resultado deseado, el cul no es otra cosa que informacin para la persona que lo solicita, tambin aprenders a cmo optimizar los algoritmos, para que tengas una idea, la optimizacin corresponde a la capacidad de lograr reducir la cantidad de pasos para solucionar el mismo problema, una de las cosas interesantes que tienen los algoritmos es que existe muchas formas de solucionar un mismo problema, con el tiempo te dars cuenta que incluso habrn ocasiones en las que para un ejercicio dado todos tu compaeros tendrn eventualmente una solucin distinta. Tipos de Algoritmos Cualitativos: Son aquellos en los que se describen los pasos utilizando palabras. Cuantitativos: Son aquellos en los que se utilizan clculos numricos para definir los pasos del proceso. Lenguajes Algortmicos. Es una serie de smbolos y reglas que se utilizan para describir de manera explcita un proceso. Hay dos tipos: Grficos: Es la representacin grfica de las operaciones que realiza un algoritmo. Ejemplo: Diagrama De Flujo, DFD. No Grficos: Representa en forma descriptiva las
operaciones que debe realizar un algoritmo. Ejemplo: Pseudocdigo.

30
Caractersticas de un buen algoritmo.

Debe tener un punto nico de inicio. Debe ser definido, no debe permitir dobles interpretaciones. Debe ser general, es decir, soportar la mayora de las variantes que se puedan presentar en la definicin del problema. Debe ser finito en tamao y tiempo de ejecucin. Es decir, debe tener un fin.
Diagrama de flujo
Para el diseo de algoritmos se utilizan tcnicas de representacin. Una de estas tcnicas son los Diagramas de Flujo (DDF), que se definen como la representacin grfica que mediante el uso de smbolos estndar unidos mediante lneas de flujo, muestran la secuencia lgica de las operaciones o acciones que debe realizar un computador, as como la corriente o flujo de datos en la resolucin de problema.
Pseudocdigo.
El escribir aplicaciones computacionales se necesita entregar al computador una serie de instrucciones las cuales sern ejecutadas por este. Para realizar este proceso se inventaron los lenguajes de programacin mediante los cuales el el programador escribe las estas instrucciones para que el computador realice las acciones correspondientes, programador escribe
31
instrucciones
las
cuales
son
interpretadas
luego
compiladas (transformadas en un lenguaje que entiende el computador llamado lenguaje de mquina), para que con el resultado de este proceso pueda ejecutar las instrucciones. Ahora como los lenguajes de programacin a veces son muy complejos de aprender, existe un subconjunto de lenguajes ms bsicos que se llaman pseudolenguajes, los cuales permiten generar pseudocdigo. El pseudolenguaje generalmente es un subconjunto de un lenguaje de programacin que es muy extenso, o a veces tambin se trata de un lenguaje que ocupa expresiones que son ms cercanas al lenguaje de las personas, pues en todos los lenguajes de programacin las instrucciones estn en ingls. Si bien existe una cercana mayor con el lenguaje con el que hablas (en este caso espaol), existe la complejidad posterior de tener que aprender de nuevo otro lenguaje de programacin. Para efectos de este manual, ocuparemos un lenguaje de programacin llamado java el cual tiene una sintaxis relativamente simple. Adicionalmente la sintaxis de java esta basada en un lenguaje de programacin denominado C que es el padre de los lenguajes ms utilizados: C++, javascript, java, c#, actionscript, php, entre otros, que utilizars durante el desarrollo de tu carrera.
32
Programa.
Conjunto ser de rdenes en tres o instrucciones bloques capaces de manipular un conjunto de datos. Estas rdenes pueden divididas grandes claramente diferenciables, estos son: Entrada de datos: En este bloque se engloban todas aquellas instrucciones que toman datos de un dispositivo o perifrico externo, depositndolos en la memoria principal del computador para ser procesados. Proceso: Engloban todas aquellas instrucciones
encargadas de modificar los datos que previamente haban sido depositados en la memoria principal. Todos los resultados obtenidos en el tratamiento de dichos datos son depositados nuevamente en la memoria principal quedando de esta manera disponible. Salida de resultados: Es el conjunto de instrucciones que toman los resultados finales desde la memoria principal y lo envan a dispositivos externos.
Etapas en la creacin de programas.

Durante el desarrollo hay un conjunto de etapas que sin importar el tipo de software que desee crearse siempre se repiten, ya sea desde un programa muy simple como una calculadora con las operaciones bsicas, hasta completos sistemas de clculos en tiempo real. Estas
33
etapas sern definidas y explicadas en forma lineal, sin embargo en el desarrollo real no significa que este sea un orden estricto y que no haya vuelta atrs, muy por el contrario, en muchas ocasiones cuando ya se piensa que se ha superado por completo una etapa es necesario volver atrs, agregar o corregir algo que se nos pas para luego volver a la etapa siguiente. Otra cosa importante, es que en algunas ocasiones tambin se da que las etapas se solapan, vale decir, que antes de finalizar una es posible avanzar en algunos puntos de la que viene, esto suele ser til para comenzar a dimensionar si lo que estamos haciendo esta correcto.
Requisitos.
Los requisitos de software son especificaciones claras y puntuales sobre lo que debe contener un software para cumplir con algn requerimiento. Es habitual que las personas confundan requisito con requerimiento, incluso una discusin de ello se encuentra en el manual de anlisis y diseo orientado a objetos dentro del capitulo de ingeniera de requerimientos, pues bien, en ese captulo se habla de la necesidad de extraer la informacin sobre los procesos que realizan los clientes los cuales luego queremos construir como software ms adelante, dichas necesidades son requerimientos y estn asociados a las necesidades que tiene la empresa y que luego resolveremos o apoyaremos con un software, un requisito en cambio est ms bien asociado a lo que debe
34
hacer un software para que en su funcionamiento cumpla con lo que deseamos construir, vemoslo con un ejemplo: si deseas construir un software para apoyar el proceso de venta de juguetes, estamos hablando de un requerimiento, sin embargo, cuando dices que tu software necesita validar que el mtodo de pago sea slo en pesos chilenos, entonces estamos hablando de un requisito del software, los cuales en su conjunto debiesen alinearse con los requerimientos. Una forma fcil de recordar la diferencia es mirar la contratapa de algn software que hayas comprado alguna vez, all veras los requisitos mnimos necesarios para se ejecucin y que por tanto estn absolutamente ligado a una pre condicin del software, no del proceso que desea resolver.
Anlisis.
En la etapa de anlisis es en la que recopilamos todos los requisitos necesarios para desarrollar el software, los analizamos y buscamos restricciones que deban ser aplicadas por el software. Este anlisis es recomendable hacerlo en equipo, para ello los encargados cuentan con un conjunto de diagramas que les permiten dibujar los procesos que desean construir antes de comenzar a desarrollar la aplicacin. Esta etapa es fundamental en el ciclo de desarrollo de un software, un mal anlisis de los requisitos podra tirar por la borda el esfuerzo de mucho tiempo.
35
Diseo de la solucin.
En el diseo de la solucin es el momento en el que se planifica la arquitectura de lo que se desea construir, el diseo de una aplicacin abarca varios temas, algunos mucho ms complejos que otros, donde todo depender del tipo de aplicacin que deseamos construir. Durante esta asignatura el diseo que abarcaremos estar principalmente enfocado a cmo organizaremos el cdigo dentro de una sola aplicacin, tal vez por ahora sea complicado de comprender, pero pequeas rutinas de cdigo con el tiempo las iremos organizando y agrupando en mtodos, donde cada uno de estos mtodos representa un proceso, es decir una entrada de datos, algn conjunto de operaciones aritmticos y lgicos que aplicaremos sobre ellos, para luego generar una salida. En la medida que vayamos aprendiendo resolveremos ejercicios ms complejos donde para llegar a una solucin necesitaremos crear varios procesos, los cuales agruparemos en una entidad mayor llamada clase, dichas clases y sus mtodos (o comportamientos) dibujaremos en un diagrama llamado diagrama de clases. El diseo no slo se refiere a cmo organizaremos los componentes internos de un programa, hay ocasiones en que una solucin consta de ms de un programa, por ejemplo, hay redes sociales que tienen un componente Web y otro en equipos mviles, en este caso el diseo
36
tambin debe incorporar la forma en que ambos software se comunicarn. Otro aspecto que tambin se refiere al diseo, es la forma en que los componentes se instalarn. Muchas veces los software estn diseados para recibir grandes cargas de datos o altos niveles de trfico de usuarios y estn ejecutndose sobre ms de un equipo, por lo que en estas ocasiones, el diseo tambin esta ligado al hardware en el que se ejecutar. Conocer esto a tiempo, nos dar una pauta de la forma lgica en la que debemos construirlo.
Codificacin.
Esta etapa se refiere a la construccin del software, es el equivalente a comenzar a levantar los cimientos de una casa luego de que ha sido diseada. La codificacin es un proceso que no debiese generar problemas si el anlisis de requisitos ha sido realizado correctamente y si los programadores estn guindose por un diseo (diagrama de clases) que ha sido discutido y aprobado por el equipo responsable. Durante esta etapa los programadores debern idear los algoritmos que permitan solucionar cada uno de los objetivos planteados en el diseo de la solucin y la comunicacin entre las partes. Durante la codificacin utilizaremos algn lenguaje de programacin que nos permita comunicarnos con la
37
mquina, la eleccin del lenguaje es una conversacin que da para mucho, pero por lo general depende de las prestaciones que nos da la tecnologa que la rodea, de las restricciones y aunque no debiese ser una limitante, muchas veces influye su valor.
Prueba.
Las pruebas corresponden a la etapa de la post construccin, aqu es donde probamos lo que hemos construido. Para iniciar las pruebas no es necesario terminar el software completo, los programadores suelen hacer muchas pruebas de cada mtodo que han construido con el fin de determinar si sus algoritmos hacen lo que se espera de ellos. A estas pruebas se les llama prueba unitaria y consiste bsicamente en ingresar datos de entrada y verificar que la salida sea la esperada, adems suelen hacerse durante todo el periodo de codificacin. Adicionalmente, existen otros tipos de pruebas que tienen relacin con la cantidad de recursos que un software utiliza, esta tarea por lo general realizada por el departamento de aseguramiento de la calidad realiza tareas como la revisin de la carga del procesador y los tiempos de respuesta de la aplicacin.
38
Mantencin.
La mantencin del software es un proceso que se realiza post entrega y corresponde a modificaciones posteriores. Las mantenciones siempre nacen a causa del cambio de un proceso en la organizacin del cliente que lo ha solicitado. Las mantenciones pueden ser una buena fuente de ingreso posterior a la venta, ya que casi siempre las mantenciones son realizadas por la misma empresa desarrolladora, sin embargo en otras pueden convertirse en un gran dolor de cabeza cuando el software ha sido construido de forma poco modular (divididos en sub programas), la mantencin se vuelve muy dificultosa y los cambios en una parte comienzan a provocar errores en otros. Algunos paradigmas de programacin como la programacin orientada a objetos (POO) aporta mucho a la facilidad de mantener sistemas, ya que divide los procesos en procesos ms pequeos y luego los agrupa con un nombre que los represente, de esta forma es ms sencillo ubicar donde hay que realizar el cambio y cuales son los datos de entrada y salida esperados.
39
Caractersticas de la programacin.
Estructura descendente.
En la etapa de anlisis se determina que hace el programa, en la etapa de diseo se determina cmo hace el programa la tarea solicitada. Con el objetivo de hacer el proceso de la resolucin de problemas ms eficaz es que se utiliza el proceso de diseo conocido como divide y vencers. Esto quiere decir que la resolucin de problemas complejos se realizan dividiendo dicho problema en subproblemas y a continuacin dividir dichos subproblemas en otros de nivel ms bajo hasta que pueda ser implementada la solucin. La solucin de estos subproblemas se realiza con subalgoritmos. Los subalgoritmos son unidades de programa o mdulos que estn diseados para ejecutar alguna tarea especfica. Estas unidades (las que distinguiremos como Funciones y Procedimientos y que estudiaremos en profundidad ms adelante) se escriben slo una vez, pero pueden ser invocadas o referenciadas en diferentes puntos del programa o mdulo principal con el objeto de no duplicar el cdigo innecesariamente. Este mtodo de disear algoritmos diseo con el proceso de romper el o problema subdividindolo en varios subproblemas se denomina descendente, TOP-DOWN Modular y en cada etapa, expresar cada paso en forma ms detallada se denomina refinamiento sucesivo . Cada subprograma es resuelto en un mdulo que tiene
40
un nico punto de entrada y un solo punto de salida. Los mdulos pueden ser planeados, codificados, comprobados y depurados de forma individual (hasta por programadores distintos) y combinarlos mas tarde lo que implica la combinacin de los siguientes pasos: Programar un mdulo. Comprobar el mdulo. Depurar el mdulo Combinar el mdulo con los dems. Esta tcnica es utilizada hoy en casi todas las disciplinas, en programacin existe ms de un paradigma (una forma o modelo de cmo hacer las cosas).
Modularidad.
El concepto de modularidad al en programacin y vencers. esta Este directamente asociado divide
concepto hoy est fuertemente asociado al paradigma de programacin orientado a objetos, el cual tiene como principio dividir la funcionalidad de un programa en programas ms pequeos de manera en que ellos sean lo ms independientes posible.
Cohesin.
Este trmino tiene relacin con la capacidad de unir las partes, la palabra cohesin es sinnimo de adhesin, por lo tanto estamos hablando de la unin de partes. En la
41
programacin siempre se busca hacer todo modular, es decir tomar un gran software y construirlo de pequeas partes que ojal fuesen funcionales de forma independiente, sin embargo si vamos a programar de esa manera hay que pensar despus en como unir todo, a este concepto se le llama cohesin y se dice que un software tiene una alta cohesin cuando la llamada a una de esas partes la realiza una que contiene toda la informacin para ello.
Acoplamiento.
El acoplamiento esta muy ligado a la cohesin, cuando un software se encuentra dividido en partes y estas partes son unidas de forma correcta estamos hablando de una alta cohesin entre las partes, cuando esto esta presente en un software de forma automtica decimos entonces que nuestro programa tiene un bajo nivel de acoplamiento, lo que es muy bueno, ya que esto quiere decir que las partes no son dependientes entre s, por tanto, una modificacin en un proceso slo afectar a alguna de las piezas del software y no al 100%, evitando volver a modificar partes que si funcionan y cuya funcin no se ve alterada.
42
Descomposicin.
La descomposicin es una caracterstica que permite desarmar un problema complejo en una serie de subproblemas que por el hecho de ser partes reducidas de un todo, pierden complejidad. Esta prdida de complejidad nos permite concentrarnos en una parte especfica del problema utilizando el concepto de divide y vencers.
43
Estructura de un algoritmo.
Los algoritmos se definen como una serie de pasos bien definidos y finitos que permiten solucionar un problema para cualquier tipo de valores. Bsicamente un algoritmo permite definir las acciones que se deben realizar para solucionar un problema. Existe una serie de acciones que acciones que se realizan para dar solucin a un problema, por ejemplo declarar variables, leer datos desde teclado, mostrar datos en una pantalla, etc. Esta serie de acciones se ordenan lgicamente para solucionar un problema. Un ejemplo de la definicin de la estructura de un algoritmo es el siguiente: 1. 2. 3. 4. 5. Leer el pedido. Examinar el historial de crdito del cliente. Si el cliente es solvente, entregar el pedido. En caso contrario, rechazarlo. Fin.
Si te fijas en el ejemplo anterior, existe una serie de pasos formales para dar solucin a un problema que en el caso anterior es tomar una decisin respecto a si se entrega o no un pedido a un cliente utilizando el historial de crdito que posee.
44
Conceptos de variables y constantes.

Definicin de variables y constantes.
Cuando creamos software, los datos que van a ser procesados, se deben guardar de forma temporal para ser procesados por la aplicacin. El programa por lo tanto debe solicitar al sistema operativo que defina un espacio en la memoria donde guardar estos datos. Para esto los lenguajes de programacin definen una forma de reservar este espacio y es mediante la declaracin de variables y constantes. Cuando se declara una variable o una constante, se realiza el proceso de solicitar un espacio en la memoria del computador para almacenar valores que representan datos que queremos procesar. El problema surge cuando nos damos cuenta que el espacio en la memoria del computador es limitado, por lo tanto el sistema operativo para proteger la ejecucin de mltiples programas nos solicita que pidamos un espacio especfico, en funcin de lo que vamos a guardar, por ejemplo si tengo que construir un lugar para guardar mi auto, no construyo un galpn para guardar un avin, porque lo ms probable es que no ocupe todo el espacio y quede con mucho espacio sin utilizar, de la misma forma que no construyo un galpn para guardar una moto, pues lo que necesito guardar es un auto. Por lo tanto para indicar al sistema operativo cual es el espacio
45
que se debe dejar disponible para guardar datos, los lenguajes de programacin definen los tipos de datos. Un tipo de dato por lo tanto permite definir el espacio en la memoria que el sistema operativo reservar para guardar datos que sern procesados por un software. En java los tipos de datos se pueden catalogar bsicamente en dos grupos, los primitivos (o simples) y las referencias a objetos.
Primitivos
Los tipos de datos primitivos son aquellos que pueden utilizarse directamente en un programa sin necesidad de utilizar POO, dado que no son objetos, los tipos de datos primitivos grupos, los aportan un y uso ms eficiente los en el se almacenamiento de datos y pueden ser divididos en dos booleanos numricos, cuales subdividen en dos grupos, los enteros (byte, short, int, long y char) y los reales (float y double). (Importante) la declaracin de una variable utiliza la siguiente sintaxis: Tipo de dato identificador = [valor][, identificador] [=valor] ; En java los identificadores tambin tienen una norma. La forma correcta de declarar una variable es escribindola con minsculas y las maysculas slo se utilizan en la primera letra a partir de la segunda palabra si es que la hay, por ejemplo el identificador miVariable lleva la letra V con mayscula debido a que es una palabra
46
escrita
despus
de
mi
lo
mismo
sucede
con
miPrimeraVariable, donde tanto P como V van con maysculas
byte:
El byte es una variable que tiene una capacidad de 8 bits y permite almacenar un valor de tipo entero (sin decimales) entre el -128 y + 127. El siguiente ejemplo declara la variable y luego le asigna el valor de cero, cuando un valor es dado de forma inicial recibe el nombre de inicializacin de la variable. byte dia=0; (Importante) las variables pueden ser inicializadas con un valor (cero en este caso) o una expresin. Se entiende por expresin un conjunto de operadores que dan un resultado, pudiendo as declarar byte (o cualquier otro tipo de dato) de la siguiente forma: byte a = 1+1*2; tambin debes tener en cuenta que las variables numricas no inicializadas comienzan en cero.
Short:
El short tiene una capacidad de 16 bits y permite almacenar un valor entero entre -32768 y +32767 (al igual que el entero en C). La siguiente lnea de cdigo declara e inicializa dos variables.
47
Int:
El tipo de dato entero tiene una capacidad de 32 bits y permite almacenar un valor entero entre -2147483648 y +2147483647.
Long:
El tipo de dato long tiene una capacidad de 64 bits y permite almacenar un valor entero entre y 9.223.372.036.854.775.808 +9.223.372.036.854.775.809
Float:
El tipo de dato float tiene una capacidad de 32 bits y permite almacenar un valor real en coma flotante (decimales) entre -3,4*10-38 hasta 3,4*1038 . Los valores expresados en float deben ir acompaados de una letra f minscula al final.
48
Double:
El tipo double tiene una capacidad de 64 bits y permite almacenar un valor real entre -1,7*10-308 y +1,7*10308. El double es el tipo de dato que asume Java al escribir un real, por ello no va acompaado de ningn carcter como en el caso del float.
Boolean:
El tipo de dato booleano es utilizado para conocer el resultado de una evaluacin booleana, los dos posibles valores son true y false (verdadero y falso).
Si su valor de inicio no es especificado, el valor por defecto es false.
Char:
El tipo char, es un tipo de datos que permite almacenar un caracter, sin embargo el valor que en realidad almacena es un entero equivalente entre los valores del 0 al 127 de la tabla de caracteres ASCII, la forma de declarar un char es la siguiente:
(Importante) Para el caso de la variable letra1 el valor es el caracter a, el cual sebe ir entre comillas, sin embargo en letra2, las comillas no existen, porque no se le est asignando un carcter, el nmero 97 representa la letra a
49
en la tabla ASCII, esto significa que la variable letra1 y letra2 tienen en realidad la misma letra almacenada.
Tipo de objetos.
Los tipos de objetos incluyen todos los objetos que pueden ser instanciados a partir de las clases provenientes con java y todas las que sean desarrolladas por el programador. Si bien ambos tpicos sern vistos ms adelante, en este captulo se mostrar el String, la cual es una clase de mucha utilidad y que a veces tratada como un tipo primitivo, aunque no lo sea.
String
Un String (con su letra s mayscula) no es un tipo de dato primitivo, sin embargo se trata en este apartado debido a que su uso es muy habitual en los programas y adicionalmente se puede utilizar de la misma forma en la que se declaran los tipos primitivos. Un String es un tipo de dato que permite almacenar una cantidad de caracteres variables. Su declaracin y asignacin es de la siguiente forma:
(Importante) String, es en realidad una clase, que almacena como atributo un arreglo de caracteres. Tanto las clases como los arreglos sern estudiados con mayor detalle ms adelante. El siguiente ejemplo muestra la
50
declaracin
de
variables
bajo
el
paradigma
de
la
programacin estructurada dentro del mtodo main.
La
siguiente
imagen,
presenta
un
ejemplo
de
la
utilizacin de los tipos vistos en declaracin de atributos de nuestra clase Persona.
51
(Importante) private representa el nivel de accesibilidad y ser estudiado ms adelante.
Vida y mbito de una variable

Las variables cuando son declaradas, tienen lo que se conoce como un mbito, el cual define las fronteras dentro de las cuales las variables pueden ser utilizadas. Tradicionalmente la programacin estructurada tiene dos niveles de visibilidad distintos: las variables locales y globales, sin embargo en la programacin orientada el mbito de una variable dentro de una clase es algo ms
52
complejo y ser tratado a lo largo de este manual. Las variables siempre deben ir dentro de una estructura que los contenga, para cada estructura existe un inicio y cierre de bloque que la delimita. Como ejemplo la siguiente imagen muestra una clase con su respectivo inicio y cierre de bloque.
Fjate que ahora la clase Persona posee adems un comportamiento llamado correr y descansar, los cuales tambin tienen limitado su bloque. Podemos decir entonces que la clase Persona contiene dentro un comportamiento llamado correr y descansar.
53
En este caso, la variable cansancio es una variable de instancia debido a que est definida dentro de la clase, pero fuera de sus comportamientos, por ende los mtodos descansar y correr (que tambin son parte de la clase) tienen visibilidad sobre cansancio, aumentando en este caso su valor al correr y disminuyndola al descansar.
54
El mbito de una variable siempre depender de del lugar donde se produzca su declaracin, por ejemplo, ya vimos que si declaramos la variable dentro de los bloques que limitan la clase persona, pero fuera de correr o descansar, la variable se denomina una variable de instancia y est disponible para todos los mtodos que la clase contenga. En el siguiente ejemplo la variable cansancio es ahora una variable declarada dentro de del comportamiento correr, esto se denomina variable local del mtodo. Para este caso la visibilidad de dicha variable son los lmites donde fue declarada, vale decir el inicio y bloque de correr, el siguiente ejemplo causa un
55
error debido a que descansar no tiene una visibilidad sobre la variable cansancio.
(Importante) las variables de instancia son capaces de mantener el valor durante toda la vida de un objeto, sin embargo las declaradas dentro de un comportamiento son creadas, utilizadas y eliminadas al finalizar la ejecucin del comportamiento que la contiene. Tambin es posible crear lmites dentro de los comportamientos correr, si bien la tcnica que se presenta en el siguiente no es muy comn, es reconocida por el lenguaje Java.
56
En el segmento de cdigo anterior se muestran dos casos a considerar. En el interior del mtodo correr existe una delimitacin dentro que contiene la declaracin de una variable entera cuyo identificador es a, sin embargo al
57
terminar el lmite donde fue declarada la variable ha vuelto a ser declarada, a primera vista da la idea de que correr tiene dos variables llamadas a, pero sabemos que eso es imposible. Recordemos que el identificador de una variable debe ser nico en un mismo mbito, lo que en realidad sucede es que la variable que se declara primero tiene una vida til desde que se declara hasta el cierre de bloque en el que fue declarada, por ende al ser declarada la segunda variable llamada a, la primera ya ha sido eliminada. En descansar en cambio se produce un error debido a que se declara primero una variable entera dentro de los lmites del comportamiento descansar, lo que provoca que tambin est disponible para el mbito que existe en el interior del mtodo, por lo tanto, en el mbito interior, no es posible declarar la variable entera con el identificador a, debido a que ya existe en l.
Conversin entre tipos.

En Java existen dos tipos de conversiones, la implcita y explicita. La implcita es aquella que no necesita de alguna intervencin por parte del programador para que se lleve a cabo, siendo Java el encargado de realizarla. El ejemplo ms comn es la operacin aritmtica de dos tipos de datos distintos, en una variable de qu tipo debo almacenar el resultado entre la suma entre un float y un double?
58
La clave a la respuesta de esta pregunta no est en el resultado de la operacin, de hecho, en este caso el resultado es 6, el cual podramos asumir de forma errnea que es un resultado entero, sin embargo la clave del xito est en el tamao del resultado. Si tuvieses que construir un estacionamiento, donde se estaciona un camin gigante o un pequeo auto, pero nunca los dos al mismo tiempo, cul es el estacionamiento ms pequeo que debes construir? El del tamao del camin, pues Java hace lo mismo, el double es un valor ms grande (en bits) que el float, por ende Java siempre dar como resultado el tipo ms grande, con ello se asegura de que no exista perdida de precisin en el resultado. La conversin implcita es aplicada en la direccin de izquierda a derecha entre los datos presentados en el siguiente diagrama, lo que significa que un byte, puede almacenarse en una variable de tipo short o char o cualquiera de las 3 puede almacenarse en un int.
59
La conversin explcita o tambin conocida como cast consiste en forzar la conversin entre un tipo de dato a cualquier otro (excepto desde booleanos a enteros o reales), la sintaxis para realizar una conversin explicita es la siguiente: (Tipo destino) expresin o variable A=(int)promedio; En el siguiente ejemplo, se convierte una expresin que da como resultado un float (debido a que es ms grande que un short y un long) en un entero, dando como resultado el valor de 3.
(importante) muchas veces se piensa que el resultado es 4, debido a que la suma de las tres variables da en realidad 3.8f sin embargo convertir este resultado a un entero no implica una aproximacin, sino que slo tomar la parte entera del valor resultante (tambin conocido como truncar datos) El siguiente ejemplo muestra una clase en la que el comportamiento miPeso el cual retorna los kilos de su peso sin contar los gramos.
60
Representacin de sentencias en Instrucciones.

Operadores Aritmticos.
Los operadores aritmticos son aquellos que permiten realizar operaciones matemticas y son:
61
El siguiente ejemplo muestra una operatoria aritmtica que incluye una conversin explicita cuyo resultado es 4:
Operadores unarios y de auto asignacin
Este tipo de operadores son una forma reducida de utilizar los operadores aritmticos muestra las equivalencias: tradicionales, por ejemplo: Dada la declaracin int a=6; la siguiente tabla
Debes
prestar
especial
atencin
cuando
uses
los
operadores -- y ++ dentro de una expresin aritmtica,
62
debido a que el orden en el que se utilizan cambia el resultado de la operacin. -- y ++ pueden ser utilizados como sufijos o como prefijos, lo que implica la jerarqua con la que se ejecuta, por ejemplo, en este caso ++ est antes de la variable a lo que implica que previo a cualquier operacin que vaya ejecutarse sobre l la prioridad es incrementarlo en 1, siendo el resultado para este caso igual a 6 dado que a es 1 antes de ejecutar la suma.
Operadores Lgicos
Relacionales
Se usan para formar expresiones booleanas, es decir expresiones que al ser evaluadas producen un valor booleano: verdadero o falso. Se utilizan para establecer una relacin entre dos
63
Cuando la comparacin se hace con datos alfanumricos, opera de acuerdo a las siguientes reglas: Se compara uno a uno de izquierda a derecha. Si son de diferente longitud pero exactamente iguales hasta el ltimo carcter del ms corto, entonces el ms corto es el menor. Slo son iguales dos datos alfanumricos si son Las letras minsculas tienen mayor valor que las iguales su contenido y su longitud. maysculas. (tabla ascii)
Booleanos:
Combinan sus operandos de acuerdo al lgebra de Boole para producir un nuevo valor que se convierte en el valor de la expresin.
OR u O: es un operador binario, afecta a dos operadores. La expresin que forma es verdadera cuando al menos uno de sus operandos es verdadero. Es un operador de disyuncin. Ejemplo: estudiamos o vamos al estadio AND o Y: tambin es un operador binario. La expresin formada es cierta cuando ambos operadores son ciertos al mismo tiempo. Es el operador lgico de conjuncin Ejemplo: si es verano y hace calor vamos a la playa NOT o NO: es un operador unario, afecta a un solo operando. Cambia el estado lgico de la expresin; si es
64
verdadera la transforma en falsa y al revs. Ejemplo: no es verano. El orden de prioridad de estos operadores es: NOT, AND y OR.
65
66
Introduccin a lenguajes formales de Programacin.

Estructura de un programa.
En JAVA al igual que en la mayora de los lenguajes de programacin orientados a objetos, el cdigo se estructura en clases, la forma bsica de estructurar una clase es la siguiente: Los Atributos que representarn un objeto, por ejemplo, para una persona los atributos pueden ser, su edad y peso entre otros, los atributos de una clase estn representados por la declaracin de estructuras y tipo primitivos, para este caso por ejemplo, la edad puede estar representada por un tipo de dato int (entero) y un float respetivamente. Accesadores y mutadores, los cuales son comportamientos especiales dentro de una clase que permiten conocer y cambiar el valor de un atributo. Los comportamientos que un objeto tendr, por ejemplo, para nuestra persona, algunos ejemplos son correr y jugar.
67
Sentencia condicionales
Las sentencias condicionales representan un punto en nuestro programa donde el flujo del proceso cambiar dependiendo de alguna condicin. Si haces un anlisis simple vers que esto no es tan complicado de comprender como se lee, la vida a diario esta lleno de
condiciones, las cuales vamos resolviendo da a da y esto provoca que nuestro diario vivir sea incierto, siempre hay una condicin para todo, por ejemplo, dependiendo si vas o no atrasado decidirs si ir a estudiar en metro o bus, dependiendo de qu da es, la hora a la que te levantars. Este proceso mental es tan rpido que apenas nos habamos dado cuenta que lo realizamos tantas veces al da. Si a cada una de estas situaciones que nos enfrentamos a diario nos detuviramos un momento y nos analizramos de qu depende que vayamos hacer algo, nos daramos cuenta que programar es muy similar, por ejemplo, imagina que alguien te ofrece bebida y antes responder en voz alta expresas la condicin que te llevar a determinar si aceptas o no, si lo haces muy probablemente dirs algo similar a tengo sed? y si la respuesta es verdadera entonces lo hars. Una condicin esta antecedida de la conjuncin si (sin acento). Podemos hacer uso de ella entonces para formular todas aquellas condiciones a la que nos enfrentamos a diario, algunos ejemplos son: Si mi amigo va, yo voy. Si estoy aburrido jugar PC.
68
Si me han enseado algo nuevo lo reforzar. Fjate que en cada una de las frases anteriores hay una accin que va a realizarse dependiendo de la condicin expresada en el s, adems debes notar que si bien no esta escrito explcitamente tambin estamos diciendo que si la condicin no se cumple hay algo que dejar de hacer. En informtica este comportamiento es exactamente igual, salvo por la forma en la que se escribe. Recuerda que para comunicarnos con el computador debemos usar algn lenguaje de programacin y los lenguajes que ms se utilizan en el mercado estn en ingls, as que comenzaremos a dar nuestro primer gran paso en el mundo de las condiciones, cambiaremos la conjuncin si, por la palabra clave if. if mi amigo va, yo voy. if estoy aburrido jugar PC. if me han enseado algo nuevo lo reforzar. Bien, ya nos vamos acercando a nuestra meta y de lo anterior podemos afirmar entonces que la palabra if debe siempre ir acompaada de una condicin la cual tambin debemos representar de una forma que el computador pueda entender. Supongamos ahora que para ir de paseo con tus amistades hoy necesitas cancelar una cuota de $10.000, en ese caso la condicin debemos expresarla de la siguiente forma:
69
if (plata >= 10000) Donde plata es una variable que contiene algn valor el cual podr ser mayor, menor o igual a $10.000, no importa el valor que esta tenga , siempre una sentencia condicional de este tipo tendr dos posibles resultados, en el primer caso se cumple la condicin y en el segundo la condicin no se cumple .El resultado de la condicin siempre determina si hay o no hay que hacer algo, en este caso por ejemplo si el valor de la variable plata es mayor o igual 10.000, entonces saldremos de paseo, de lo contrario podemos tomar dos acciones posibles, no hacer nada o buscar una actividad donde no necesitemos esa cifra de dinero. Adicionalmente tal y como lo muestra el ejemplo la condicin debe ir entre parntesis. Supongamos ahora que si la condicin se cumple
entonces podremos salir de paseo lo que provoca un incremento de uno en la variable diversin, en este caso el if ser presentado de la siguiente forma:
if(plata >= 10000) { diversion++; } Como puedes ver justo debajo de la condicin el incremento de la variable diversion se encuentra entre un inicio de bloque { y un cierre de bloque }. Estos
70
bloques delimitan el alcance de la condicin, es decir entre ellos debes escribir todo lo que suceder si la condicin resulta ser verdadera. Observa ahora lo que sucede si existen sentencias de cdigo que se encuentran fuera del inicio y cierre de bloque: if(plata >= 10000) { diversion++; } tiempo++; en este caso tenemos dos incrementos, el de la variable diversion y el de la variable tiempo, sin embargo slo una de ellas est condicionada a la cantidad de dinero que tengamos, dado que est encerrada entre los bloques. Este extracto de cdigo tiene entonces dos posibles ejecuciones, el primero corresponde a cuando la condicin es verdadera, slo si esto ocurre la variable diversin har su incremento, sin embargo la variable tiempo no se encuentra dentro del alcance de la condicin y por ello har su incremento ya que no depende de nada, el flujo contrario entonces har que diversin no incremente su valor pero si lo har la variable tiempo. Hasta ahora hemos visto como debiese comportarse el cdigo cuando la condicin es verdadera, pero muchas veces tambin nos gustara definir un comportamiento para cuando esta es falsa, o dicho de otra forma definiremos el comportamiento de la condicin para el
71
caso sino es verdadera. Para ello utilizaremos la palabra reservada else (sino en ingls) la cual nos permitir delimitar todas aquellas acciones que deben llevarse a cabo cuando la condicin no se cumple, vemoslo con un ejemplo, en el caso anterior cuando disponamos del dinero para salir entonces la diversin tenia un incremento, pues ahora supongamos que sino logramos salir entonces la diversin disminuye en uno, para ello escribiremos lo siguiente:
if(plata >= 10000) { diversion++; } else { diversion--; } Como puedes ver en el caso anterior si la condicin no se cumple todo el cdigo que se encuentre entre los primeros bloques no se ejecutar, dando paso a ejecutar todo lo que se encuentre dentro del else, realizando entonces el decremento de la variable. Volvamos ahora a agregar la variable tiempo, para que veas donde debe ir ubicada:
72
if(plata >= 10000) { diversion++; } else { diversion--; } tiempo++; Al igual que el caso anterior la variable tiempo esta luego del if, por lo que su ejecucin no esta condicionada ni al caso verdadero ni al falso, por ello al igual que en el caso anterior esta variable har su incremento sin excepcin, sin embargo la variable diversin en cambio tendr un incremento o decremento en su valor sin escapatoria pero nunca ambas. La mayora de las veces, el cumplimiento o no de una condicin requiere ejecutar ms de una sentencia de cdigo, en ese caso bastar con agregar dentro de los bloques tanto del if como todo else todas las que desees, por ejemplo supongamos que si el dinero alcanza no slo incrementa la diversin, si no que tambin descansas y que por otro lado si no alcanza el dinero para el paseo no solo te aburres, si no que adems incrementa tu estrs.
73
if(plata >= 10000) { diversion++; descanso++; } else { diversion--; estres++; } tiempo++; As como muestra el ejemplo puedes agregar todas las instrucciones que desees en cualquiera de los bloques, por supuesto la cantidad de cada uno no debe ser igual, lo importante es que por claridad siempre escribas alguno, por ejemplo: if(plata >= 10000) { } else { diversion--; }
Aqu lo que tratamos de hacer es establecer slo el caso del else diciendo que si el valor de la variable plata no es mayor o igual a $10.000 se decrementa el dinero, pero si es mayor o igual no pasa nada. Este caso puede ser
74
escrito de forma mucho ms clara cambiando la condicin de la siguiente forma: if(plata < 10000) { diversin--; } Dado que slo else nos interesaba entonces ahora cambiamos la condicin y en vez de preguntar si el valor de la variable plata es mayor o igual a $10.000 preguntamos lo contrario, es decir si el valor es menor, de esta forma decimos que si esto se cumple entonces se decrementa la diversin quedando mucho ms fcil de leer. Veamos ahora un caso un poco ms complejo, no siempre tenemos la suerte de que una accin que deseamos ejecutar dependa de una sola condicin por ejemplo, para salir de paseo tal vez necesites que el dinero alcance, pero adicionalmente que la temperatura se encuentre sobre los 17 grados, en este caso ambas condiciones deben cumplirse y por ende deben compararse con el operador lgico Y, el cual debe simbolizarse con &&. if(plata >= 10000 && temperatura >17) { diversion++; descanso++; }
75
En este caso para que se incremente diversin y descanso ambas condiciones deben ser verdaderas. Veamos otro ejemplo, supongamos ahora que no deseas pasear slo y para ir basta con que a cualquiera de tus mejores amigos les alcance el dinero para ir. En este caso la condicin utilizada es O, dado que si el dinero requerido lo posee cualquiera de ellos nosotros tambin asistiremos al paseo (la condicin es verdadera). if(plataAmigo1 >= 10000 || plataAmigo2>= 10000) { diversion++; descanso++; }
Utilizamos entonces || para representar la condicin O, en este caso bastar que el valor en dinero de cualquiera de ellos (o ambas) supere el valor de $10.000.
Anidada.
Las condiciones anidadas son condiciones que encuentras de forma muy habitual en la vida diaria, en muchas ocasiones una condicin depende de otra, continuemos pensando que saldremos de paseo y an nuestra limitante es el valor de la cuota y la temperatura, pero si vamos de paseo an nos queda dilucidar si iremos en clase Premium o normal y ello depender del dinero que tengamos, ya sabemos que es igual o mayor a $10.000 y
76
asumamos que si llevamos sobre los $15.000 podemos darnos el gusto de viajar en Premium y gastar los $7.000 que vale el pasaje, de lo contrario pagaremos los $2.000 que cuesta el pasaje normal. Esta condicin tiene sentido slo si se ha cumplido la primera, es decir slo si la temperatura es mayor a 17 y el dinero es igual o mayor a los $10.000, de ninguna forma tiene validez pensarlo al revs. if(plata >= 10000 && temperatura >17) { diversion++; descanso++;
if(plata >= 15000) { descanso++; plata = plata 7000; } else { plata = plata-2000; }
} else { diversion--;}
77
En el cdigo anterior si la condicin que nos va a permitir salir de paseo se cumple, nuevamente incrementar la diversin y el descanso, pero adicionalmente nos lleva a otra condicin, la cual nos permite saber, basndose en el dinero obtenido, cuanto pagaremos por el pasaje. Si el valor es superior o igual a $15.000 se restar de la variable plata $7.000 pesos e incrementar el descanso dada la comodidad que esto otorga, de lo contrario descontar $2.000. Este tipo de if anidados (uno dentro de otro) no tienen limitantes, vale decir puedes agregar una dentro de otra tantas estructuras de condicin sea necesario, ya sea para el caso verdadero a para el falso. Este tipo de if son utilizados cuando necesites evaluar una condicin que depende de una o ms condiciones previas.
Mltiple
En otras ocasiones no todo depende de una condicin con un resultado verdadero o falso. Un buen ejemplo es simular el comportamiento felicidad que un alumno tiene segn la nota que ha obtenido, convengamos que la felicidad es mayor mientras ms alta la nota que obtenga, supondremos que las notas que un alumno puede obtener son C, B, A siendo C la nota ms baja y A la ms alta. Para calcular la felicidad diremos que si ha sacado una C el valor de la felicidad se multiplicar por 1, si es B por 3 y si es A por 5. Para lograr esto necesitamos conocer la nota preguntando si es A, si no lo es habra
78
que evaluar si es B o C, la forma de realizar esto es utilizando varios if, lo que podra volverse muy tedioso si las notas fuesen desde la A hasta la F, sin embargo (y para suerte nuestra) existe una estructura condicional llamada switch que nos permitir definir varios flujos segn el valor de todas una las variable, acciones de que esta forma programaremos deseemos
ejecutar para cualquiera de sus valores. switch (nota) { case a: felicidad*5; break; case b: felicidad*3; break; case c: felicidad*1; break; } en el ejemplo anterior le pedimos a switch que evalu el valor de nota y definimos varios casos. Fjate que cada caso esta compuesto por la palabra case y a su derecha el valor que esperamos tenga la variable evaluada, si es a ejecutar todo lo que venga luego del signo : (dos puntos). En este caso multiplicar la felicidad*5 y har un break, el break es importante y significa corte o quiebre, la utilidad que presta es de cortar la ejecucin del switch, dado que si el valor es a, no tiene mucho sentido verificar si es b o c. Al igual que en if si la condicin se cumple puedes agregar cuantas sentencias desees
79
ejecutar, supongamos que si sacas una C tu animo decae temporalmente en 1. switch (nota) { case a: felicidad*5; break; case b: felicidad*3; break; case c: { felicidad*1; animo--; } break; }
Sentencias de ciclo iterativo

Los ciclos permiten que una o ms sentencias de cdigo se repitan hasta que una condicin deje de cumplirse, es muy similar a lo que sucede con un conductor de la formula uno, el cual estar dando vueltas hasta que la cantidad de vueltas que ha dado deje de ser insuficientes para ganar la carrera, dicho en un lenguaje ms informtico si la cantidad de vueltas que debe dar el vehculo son diez, podremos expresarlo como mientras la cantidad de vueltas sea menor a 10, entonces debe seguir corriendo, pues en informtica eso se expresa tal
80
cual como lo hemos mencionado. Veamos un ejemplo de uno de los ciclos ms utilizados, el cual recibe como nombre el ciclo mientras al que de ahora en adelante lo conoceremos por su traduccin al ingls while.
While
while(vuelta<10) { vuelta++; } tiempo++; Aqu la ejecucin ocurrir de la siguiente forma, lo primero que har while ser evaluar si el valor de la variable vuelta es o no menor a 10, si el valor fuese por ejemplo 11, la condicin no se cumplir y para este caso se comportar muy similar al if dejando de ejecutar todo lo que se encuentre entre el inicio y cierre de bloques de manera que la variable vuelta no se incremente, sin embargo si el valor es 8, la condicin ser verdadera lo que provocar que si se ejecute todo lo que esta dentro de los bloques haciendo entonces el incremento de la variable. Cuando haya finalizado el incremento el while a diferencia del if no pasar directo a incrementar el tiempo, dado que cuando alcance el cierre de bloque volver a preguntar por el valor de vuelta, el cual ser 9 y dado que 9 an es menor que 10 entonces while volver a ejecutarse, incrementando el valor de vuelta en uno, al llegar al final de bloque nuevamente se va a
81
evaluar si vuelta es menor a 10, esta vez la condicin no se cumple y es entonces cuando el ciclo termina para dar paso al incremento del tiempo.
For
Existen varias estructuras que permiten iterar una o ms lneas de cdigo, el ciclo for es uno de ellos, pero antes de continuar, es importante aclarar que si bien entre ellos existen diferencias todos tienen el mismo objetivo, por ende no existir nunca una limitante para uno u otro, pudiendo utilizar cualquiera de ellos cuando necesites iterar, sin embargo cada uno tiene una estructura y sintaxis diferente, el criterio de seleccin estar dado principalmente por el que te acomode ms y de las necesidades que tengas. Volvamos al ejemplo de las vueltas en una pista de carreras presentada anteriormente. En aquel ejemplo el while tiene por misin cerciorarse de que la variable vuelta llegue a 10, pero no se preocupa del valor inicial de la variable, supongamos que las condiciones cambian y debes realizar el mismo algoritmo pero la variable vuelta debe comenzar siempre en cero. int vuelta=0; while(vuelta<10) { vuelta++; } tiempo++;
82
El ciclo while cumple a la perfeccin con nuestro propsito, sin embargo en el algoritmo hay 3 elementos a considerar: primero hay una inicializacin se variable, la cual hemos agregado recientemente al solicitar que vuelta siempre comience en cero, luego tenemos una condicin y un incremento, para este tipo de casos el for es principalmente provechoso dado que permite escribir de forma muy cmoda estos tres elementos. Veamos como luce este while convertido en un cliclo for. for(int vuelta=0; vuelta<10;vuelta++) { } tiempo++; Como puedes ver este ciclo contiene los tres elementos como parte de la declaracin del ciclo, por ende el cuerpo de este ha quedado vaco, ya que hemos cambiado la lgica de incremento de la variable a otro lugar. La forma de ejecutarse no es igual que en while, para que lo entendamos mejor vamos a decir que el for est dividido en partes, la primera es una declaracin, en la cual declaramos e inicializamos el valor de la variable vuelta, la segunda es la condicin en la que decimos que vuelta no debe ser mayor a 10 y finalmente una seccin donde incrementamos el valor de la variable vuelta en uno, entonces podemos decir que las partes son, declaracin e inicializacin, condicin e incremento, entonces la forma en la que el ciclo for funciona es la siguiente: lo primero que ocurre es la declaracin e inicializacin, con esto se asegura de que la variable exista y tenga un valor
83
inicial. Esta seccin slo se ejecuta una vez, el siguiente paso es verificar si luego de la inicializacin de la variable la condicin se cumple, de cumplirse ejecutar todo lo que este entre los inicios y cierre de bloques, el cual tenemos vaco por ahora. Al igual que el while el for intentar hacer una iteracin, pero slo a partir de la segunda vuelta y hasta que termine lo que har es primero ejecutar la seccin de incremento, haciendo que vuelta pase de cero a uno para luego verificar si la condicin an se cumple. De cumplirse volver a ejecutar todo lo que se encuentre entre el inicio y cierre de bloques, al finalizar nuevamente har el incremento y luego evaluar la condicin. Este proceso se repetir hasta que la condicin ya no se cumpla, como puedes ver la responsabilidad de inicializar, evaluar e incrementar esta toda definida dentro del for quedando entonces tiempo para preocuparse de otros elementos dentro del ciclo en s, por ejemplo, contemos la cantidad de bencina que gasta por cada vuelta almacenndola en una variable llamada consumo. int consumoPorVuelta = 0; for(int vuelta=0; vuelta<10;vuelta++) { consumo += consumoPorVuelta; } tiempo++; el ciclo for se puede adaptar a varias situaciones gracias a que cualquiera de sus partes puede ser omitida, en el
84
siguiente ejemplo la declaracin e inicializacin de la variable es quitada del for y declarada antes. int vuelta=0; for(; vuelta<10;vuelta++) { }
As
podemos
entonces
obtener
un
for
cuyo
comportamiento es idntico al de un while. int vuelta=0; for(; vuelta<10;) { vuelta++; }
En este caso este for ha quedado exactamente como el ciclo while que vimos en un comienzo. Podr parecer extrao pero incluso la condicin puede ser omitida, sin embargo eso nos obliga a tener que agregar a nosotros una forma de quebrar el ciclo para que no este iterando de forma indefinida. Sobre los quiebres de ciclos hablaremos ms adelante en la seccin de break y continues, pero por ahora como demostracin de que todas las partes son opcionales lo haremos analizando el siguiente ejemplo:
85
for(; ; ;) { } En este extrao caso no hay ninguna de las partes, sin embargo la forma en la que se ejecutar no es ningn misterio, ya que la ausencia de una condicin da por defecto falso, as que luego de comprobar que no hay nada que inicializar, evaluar falso y omitir la ejecucin del ciclo for.
Do While.
Si del ciclo do while traducimos la palabra do veremos que significa hacer, pues esta es la principal diferencia con el ciclo while que vimos en una primera oportunidad, la condicin es evaluada al final, es decir que toda la lgica agregada entre los inicios y cierres de bloque se ejecutar siempre al menos una vez. Supongamos ahora que el vehculo de carreras debe dar 10 vueltas seguidas para hacer reconocimiento de la pista de forma obligatoria, pero si ya ha dado 10 entonces slo se le
permitir dar una. do { vuelta++; } while(vuelta<10); Como puedes ver la condicin se encuentra al final, por lo tanto lo primero que suceder es incrementar el nmero
86
de vueltas en uno, sin ninguna condicin que pueda evitarlo. Supongamos que el valor de la variable acaba de incrementarse a 8, por lo tanto el corredor debe de forma obligatoria completar sus 10 vueltas, dado que 8 es menor a 10 la condicin se hace verdadera dando paso a una nueva ejecucin del bloque incrementando el valor de la variable a 9, con este valor la condicin vuelve a evaluarse siendo verdadera dado que an es menor a 10, en su ltima iteracin la variable se incrementa a 10 y la condicin se vuelve falsa, saliendo as del ciclo, sin embargo la diferencia est dada en que si vuelves a ejecutar este ciclo con un valor de 10 o superior, con un while el vehculo no hubiese sido aceptado, sin embargo con este ciclo no se evala la cantidad de vueltas al comienzo, por lo que las sentencias de cdigo se ejecutarn haciendo que vuelta sea 11, luego de la primera ejecucin el ciclo evaluar si debe proseguir, como la condicin es falsa, el vehculo no dar una segunda vuelta.
Concepto de funcin
Una funcin representa una porcin de cdigo (un conjunto de sentencias) que tienen por objetivo resolver un problema especifico. La mayora de las veces este conjunto de instrucciones es parte de un algoritmo de mayor tamao, donde las funciones tienen como objetivo la divisin de un problema en problemas ms pequeos y
87
sencillos, los que en su conjunto resuelven el problema mayor. Supongamos que deseas conocer el vuelto de la compra de varios productos del mismo precio, el precio de ellos no incluye el IVA por lo que hay que sumarlo, una vez se obtiene el total a pagar hay que determinar cuanto es el vuelto segn el monto cancelado. Los datos de entrada para este problema son: Cantidad de productos. Precio. Monto cancelado. El valor del IVA La salida: Vuelto. El proceso: Multiplicar el precio por la cantidad de productos, sumar el 19% para obtener el valor a pagar y luego al monto cancelado restar el valor a pagar. Este proceso puede ser dividido en partes ms pequeas y mucho ms fciles, identifiquemos algunos sub procesos. 1) Determinar el valor de los productos, este proceso es sencillsimo, los datos de entrada son slo el precio y la cantidad, el proceso es una multiplicacin y la salida el producto de ambos (sub total).
88
2) Calcular el IVA, la entradas es el sub total el cual calculamos en el paso anterior, el proceso agregar el 19% y la salida ser el total. 3) Calcular el vuelto, los datos de entrada son el total y el monto cancelado, el proceso es restar al monto el total, la salida es el vuelto o el monto adeudado. Estos tres procesos son pequeos programas con una dificultad mucho menor que el total, por ende tambin son ms sencillos de programar, lo importante es reconocer las entradas y las salidas de cada uno de ellos, as como tambin tener en consideracin que alguna combinacin de ellos dar el resultado final. Adems de todo lo anterior el control y la correccin se hace ms fcil, por ejemplo, supongamos que has entregado un software encargado de realizar distintos clculos algebraicos y el resultado de ello son alrededor de 200 lneas de cdigo, llena de bifurcaciones, sentencias switch y varios bucles, es probable que luego de un corto tiempo no recuerdes qu lgica usaste o para qu sirve cada una de las variables que utilizaste. Ahora tratemos de corregir el clculo de la tangente de un circulo, lo que sin duda alguna podr generar ms de algn dolor de cabeza debido a que el cdigo est en algn lugar dentro de las 200 lneas y lo que es peor no sabemos si el cambio del valor de alguna variable pueda afectar otros clculos que la utilizan dentro del mismo mbito, sin embargo si nuestro cdigo esta dividido en pequeos sub programas, donde cada una de las partes reciben nombres apropiados y descriptivos de lo que hacen como por
89
ejemplo AreaCirculo
perimetroCuadrado donde cada
uno de estos programas pequeos tienen sus propias variables y un proceso que no depende del resto, por ende slo tendrs que hacer la mantencin de ese pequeo sub programa, donde el cdigo es ms limpio y fcil de entender, adicionalmente el cambio slo afecta a las partes que lo utilicen y no a todo el programa.
Estructura de una funcin

Existen dos tipos de subprogramas, las funciones y los procedimientos, los cuales pasaron a llamarse mtodos con la programacin orientada a objetos, la cual veremos ms adelante, mientras tanto procederemos a estudiar en qu consiste cada una de ellas.
Procedimientos
Representa una porcin de cdigo agrupada con un nombre cuantas que describa lo se puede que hace. Las sentencias adicionalmente opcional un contenidas en dicho procedimiento pueden ser ejecutadas veces quiera, de procedimiento forma recibir
parmetros de entrada, con el fin de que en base a los valores de dichos parmetros el procedimiento ejecute alguna accin. Una caracterstica importante del procedimiento es que el proceso que se ejecuta ejemplo, dentro si nunca retorna hacer un un resultado, por necesitas
comportamiento al que le entregas dos valores para que

90
los sume, entonces el procedimiento deber hacer el proceso de sumar ambos, pero no tendr la facultad para devolverte el resultado, a cambio le puedes pedir que lo muestre por pantalla, que lo imprima u algn otro tipo de salida, pero nunca esperes respuesta. Otro buen ejemplo ser un procedimiento que se llame correr, el que supongamos incrementa la variable cansancio en 1 y estado fsico en 2, como puedes ver el procedimiento descrito se ha ocupado de cambiar valores a variables, pero no ha retornado un resultado. Los procedimientos pueden recibir de forma opcional parmetros, los parmetros como lo mencionamos antes tienen la funcin de determinar como se ejecutar dicho procedimiento. Aclaremos esto un poco ms, supongamos que un procedimiento llamado saludar al ejecutarlo imprime por pantalla la cadena hola amigo, este procedimiento ser utilizado por el programa principal cada vez que necesite imprimir dicho mensaje, evitando as codificarlo varias veces, sin embargo el mensaje jams variar por lo que aseguramos que el procedimiento saludar siempre imprimir el mismo mensaje sin excepcin. Si deseamos que ste tenga un comportamiento variable y que imprima hola Anakin, hola Obi Wan o algn otro nombre, entonces debemos determinar qu es lo que variar y qu no, de esta forma podemos determinar de forma muy fcil que el parmetro de entrada corresponde a un nombre (la parte variable) y que hola es parte del procedimiento. El proceso que se llevar a cabo es la unin (concatenacin) de hola con
91
el valor de la variable que represente el nombre, de esta forma si deseas mostrar hola Sebastin, tienes 29 aos, bastar con agregar un segundo parmetro de entrada que contenga la edad. De esta forma un procedimiento tendr todos los parmetros que desees, debes considerar que si decides entregar nombre y edad, entonces ya nunca ms podrs entregar al procedimiento slo la edad ya que los parmetros de entrada que definas en un procedimiento se convierten en una obligacin para su ejecucin, sin embargo puedes segn los valores tomar acciones, por ejemplo si la edad es cero omitir la parte que dice tengo xx aos. (Ms adelante en el capitulo de POO veremos como una tcnica llamada sobrecarga nos facilita esto an ms). Dado entonces que los procedimientos no retornan un valor, todos ellos utilizan la palabra reservada void para indicarlo, donde void significa la no existencia de un tipo de datos. A la derecha de la palabra reservada void indicaremos el nombre del procedimiento, el cual debe ser un nombre que describa lo que hace y cuyo proceso intelectual para inventarlo es nuestro, por ejemplo saludar La tercera parte corresponde a los parmetros de entrada de nuestro programa, partiremos analizando un ejemplo que no recibe parmetros y que imprime el mensaje de hola como lo vimos antes.
92
void saludar() { //tu cdigo aqu } Como muestra el cdigo anterior el procedimiento saludar se acompaa de parntesis vacos, lo que significa que no recibe parmetro alguno. Las llaves representan el inicio y trmino del cuerpo de nuestro procedimiento, en l debemos agregar toda la lgica referente a nuestro proceso saludar, el cual lucir as: void saludar() { System.out.println(Hola); } Para recibir parmetros debemos especificar para cada uno de ellos su tipo y nombre de la variable que contiene el valor de entrada. Agreguemos al cdigo realizado la posibilidad de mostrar un nombre distinto cada vez. void saludar(String nombre) { System.out.println(Hola + nombre); } Como puedes ver este mtodo imprimir el mensaje de hola y lo concatenar con el valor de la variable nombre. La obtencin del valor de dicha variable no es una responsabilidad del procedimiento saludar, recuerda que este es un sub programita cuya responsabilidad es
93
slo generar el mensaje, por ende este comportamiento deber ser utilizado por el programa principal, quien recurrir a el cada vez que necesite generar un saludo, sin embargo el procedimiento como requisito para generar su objetivo requerir que se le entregue algn nombre. Supongamos ahora que queremos mostrar tambin la edad, en ese caso debemos agregar un nuevo parmetro con su respectivo tipo, veamos como utilizar un segundo parmetro de entrada para nuestro procedimiento. void saludar(String nombre, int edad) { System.out.println(Hola + nombre + , tengo + edad + aos); } A partir del segundo parmetro en adelante debemos utilizar una coma para separarlos, de esta forma podrs agregar cuantos parmetros consideres necesario como requisito para ejecutar tu procedimiento. Por otra parte el cuerpo de nuestro procedimiento llevar todas las lneas de cdigo que desees, sin embargo debes tener muy presente de que los inicios y cierres de bloque definen el mbito (la frontera) de nuestra funcin, esto significa que todas las variables que all se declaren estarn disponibles slo dentro de la funcin esta regla tambin es valida para los parmetros que recibe. veamos un ejemplo:
94
void saludar(String nombre, int edad) { int codigo = 66; System.out.println(Hola + nombre + , tengo + edad + aos y mi cdigo de trabajador es: } void despedir() { System.out.println(chao, recuerden que mi nombre es + nombre + y tengo + edad + aos y mi cdigo de trabajador es: } El procedimiento saludar tiene 3 variables declaradas en su mbito, dos de ellas son nombre y edad, cuyas valores vienen asignados desde otro lugar del cdigo y son recibidos como una entrada. La variable cdigo en cambio es declarada como una nueva variable e inicializada dentro del mtodo, pero las tres tienen el mismo mbito pudiendo usarse cualquiera de ellas dentro de los lmites del procedimiento. Si miramos el procedimiento despedir en cambio aseguraremos que existen 3 errores, los cuales corresponden a la utilizacin de las variables nombres, edad y cdigo, ya que ninguna de las tres existe en este mbito. Si desean usarse hay que recibirlas como mtodo, ambas parmetro alternativas o declararlas dentro son correctas, pero del la + codigo); + codigo);
diferencia la determinar si deseas que los valores sean asignados dentro del mtodo (el caso de cdigo en el
95
mtodo saludar) o como parmetros cuyo uso representa un valor que viene desde fuera del procedimiento. Dado que como lo mencionamos antes una variable declarada dentro de un procedimiento define el mbito en el que la variable vive, veamos el siguiente cdigo:
void saludar() { int var1 = 66; } void despedir() { int var1 = 66; } En el cdigo anterior la variable var1 ha sido declarada en ambos procedimientos, esto no provocar un error ya que ambas variables viven en un mbito diferente y el cambio en el valor de alguna de ellas no afectar el valor de la otra, ya que si bien comparten un mismo identificador son variables totalmente distintas.
Funcin
Una funcin es muy similar a un procedimiento, con la salvedad de que la funcin debe retornar algn valor, o dicho de otra forma el proceso dentro de la funcin debe generar algn resultado en algn tipo de datos conocido
96
para retornarlo a quien llame al procedimiento. Un ejemplo ser el comportamiento sumar, el cual recibir dos parmetros y cuyo resultado de la suma no ser una impresin por pantalla, el resultado generado ser devuelto a quien llame a la funcin como un valor representado por alguno de los tipos de datos que tenga el lenguaje, la funcin utiliza la palabra reservada return para realizar el retorno del resultado del proceso, por ello return siempre debe estar presente y su ejecucin significa tambin el final de la funcin, ya que una vez se retorna el resultado significa que la funcin ha finalizado. int suma(int a, int b) { int c = a + b; return c; } El cdigo anterior es un ejemplo de la funcin suma, en este caso y al igual que en el procedimiento, la funcin recibe dos parmetros de tipo entero, la diferencia est dada en que void ha sido remplazada por int, el cual define el tipo de dato que la funcin va a retornar, en este caso se ha utilizado int dado que la suma de a y b representarn un entero. As una funcin podr retornar cualquier tipo de datos conocido por el lenguaje. Luego de la operatoria encontraras la sentencia return c, la cual contiene el resultado de la operatoria a+b y cuyo resultado concuerda con el tipo que explicitamos que la funcin retornara.
97
Llamada a una funcin

En la programacin estructurada las funciones y procedimientos acompaan el mtodo principal, llevando parte de la lgica a ellas, las cuales tienen como propsito resolver problemas ms pequeos, hacer ms fcil la programacin y reutilizar el trabajo ya hecho. Una funcin que nos indique si un archivo existe en nuestro disco duro es un buen ejemplo, la prxima vez que se necesite verificar la existencia de un archivo bastar con llamar a dicha funcin entregando la ruta del archivo a buscar, estas tareas especficas no tienen sentido por s solas, casi siempre son parte de un programa que tiene algn propsito mayor y este programa es el encargado de llamar a una o mas funciones para lograr el objetivo. Durante este capitulo veremos cmo utilizar las funciones desde el punto de vista estructurado y ms adelante veremos como las funciones son utilizadas en la programacin orientada a objetos. La forma en la que las utilizaremos depender de dos factores, lo primero a considerar es si lo que estamos llamando es un procedimiento o funcin, ya que la primera diferencia entre ellos es su retorno. Recuerda que un procedimiento no retornar nada, sin embargo si llamamos una funcin debemos esperar algn resultado, el otro factor corresponde a los parmetros que reciben, para ambos casos hay que considerar cuantas variables hay que enviarle al procedimiento o funcin y de qu tipos son.
98
Comenzaremos con el caso ms sencillo e iremos transformando un programa simple en un programa dividido en funciones, supongamos que tenemos el siguiente cdigo: public class JavaApplication2 { public void miEjemplo() { int fechaNacimiento=1982; String nombre = sebastian; int fechaActual = 2012; int edad = 0; edad = fechaActual - fechaNacimiento; String correo = nombre + edad + empresa.cl System.out.println("Hola mi nombre es " + nombre + ", tengo " + edad + "aos y mi correo es " + correo); } } Este pequeo programa presenta el nombre y la edad de una persona, la cual se ha calculado slo considerando el ao de nacimiento, por lo que en este simplificado ejemplo es posible que la falta de la inclusin de los meses produzca alguna diferencia, el clculo que se almacena en una variable edad que es despus desplegada como parte del mensaje, adems el correo de
99
la persona tambin se muestra, pero previo a ello se genera basndose en el nombre y la edad de la persona y se le agrega @empresa.cl. Si hacemos un pequeo anlisis aqu hay 3 pequeas funcionalidades que pueden ser fcilmente llevadas funciones y procedimientos. 1) Calculo de la edad 2) Generacin del correo. 3) Presentacin de la persona mediante una impresin. El paso siguiente ser determinar cmo debemos
modularizar estas funcionalidades, especificando cuales sern procedimientos, cuales deben ser funciones y que valores deben recibir. Si hacemos un pequeo anlisis nos daremos cuenta que algunas variables como por ejemplo el nombre, deben ser conocidos por dos de los tres procesos. Primero la debemos utilizar para la generacin del correo y luego en el paso nmero tres para la impresin, esto nos indica rpidamente que el nombre no es una variable exclusiva de ninguno de los dos, ya que si se declara dentro de alguno de los dos mtodos la variable y su valor estara slo disponible dentro de l, por lo tanto la variable nombre debe declararse en el mtodo miEjemplo ya que este ser el encargado de llamar a las dems funciones pudiendo as pasarlas de una a otra sin perder la variable. Esto se deber a que las funciones que vaya llamando miejemplo crearn sus variables que tengan declaradas, pero al finalizar su ejecucin todas ellas sern destruidas, sin embargo, miEjemplo estar activo durante todo el
100
proceso, llamando y ejecutando las funciones que en el programamos. Comencemos entonces a desmenuzar este problema en pequeos problemitas, analicemos el proceso del clculo de la edad. Para realizarlo lo que necesitamos es la fecha de nacimiento y la fecha actual, el proceso es la resta de ambas y el resultado la edad, por lo tanto cuando miejemplo llame la funcin que se encarga de calcular la edad debe especificar ambos parmetros y luego esperar la respuesta de la funcin, la cual corresponde a la edad calculada. Este valor de retorno nos indica que la funcin no puede ser un procedimiento, dado que debe retornar el valor para que luego dicho valor sea mostrado en el mensaje, entonces nuestro pequeo programa queda as: int calcularEdad(int fechaNacimiento, int FechaActual) { int edad = fechaActual- fechaNacimiento; return edad; } La funcin recibe ambos parmetros como un entero y retorna la resta de ellos, valor que tambin es de tipo int. La variable edad que est declarada al interior slo vive dentro de calcularEdad y no es compartida con nadie, sin embargo la ltima lnea de cdigo se encarga de retornar el valor de tipo entero que aseguramos retornaramos. Debes tener cuidado con no confundirte, la funcin no retorna una variable, lo que hace es
101
devolver el valor de ella, segn sea el resultado debes imaginar que lo que all dice es algo as como: return 10 o return 39 segn el resultado del clculo. Veamos ahora la generacin del correo, para ello las entradas son, la edad y el nombre de la persona, el proceso es una concatenacin de ellos y el resultado (el valor a devolver) el correo, este proceso entonces lucir as: String generarCorreo(String nombre, int edad) { String email = nombre + edad + @ return email; } En este caso el tipo de retorno ser un String y ello se notifica a la izquierda del nombre de la funcin, tambin recibe dos parmetros los cuales son el nombre y la edad. Fjate que la edad se asume viene calculada, ya que no es responsabilidad del mtodo generarCorreo realizar este calculo, para ello hemos escrito otra funcin. Luego de la concatenacin el mtodo retorna el valor de la variable email hacia miEjemplo. Finalmente el mdulo que realiza la impresin ser un procedimiento, ya que no hay un valor que deseemos retornar hacia mi Ejemplo, sin embargo para lograr la impresin necesitaremos el nombre, la edad y el correo. void imprimirDatos(String nombre, int edad, String correo)
+ empresa.cl;
102
{ System.out.println("Hola mi nombre es " + nombre + ", tengo " + edad + "aos y mi correo es " + correo); } En este caso la impresin no es un valor que vayamos a devolver, por esto el procedimiento no lleva return y en su firma informa que el tipo de retorno es void, vale decir que no hay retorno. Para unir todo el mtodo miejemplo ser el encargado llamar a todas las funciones y dar el orden lgico de ejecucin, luego de recodificar el cdigo el miejemplo lucir as: public class JavaApplication2 { public void miEjemplo() { int fechaNacimiento=1982; String nombre = sebastian; int fechaActual = 2012; int edad = calcularEdad(fechaNacimiento,fechaActual); String correo =generarCorreo(nombre,edad); imprimirDatos(nombre,edad,correo); } }
103
Como puedes ver leer el programa es mucho ms sencillo ahora, ya que palabras como calcularEdad dejan de forma ms explicita lo que hace esa lnea, fjate que para ejecutar ese mtodo es necesario pasar dos parmetros, estos deben ir separados por coma y en el mismo orden en el que la funcin esta declarada, al igual que antes no es la variable la que se entrega sino el valor de ellas, tambin forma: public class JavaApplication2 { public void miEjemplo() { String nombre = sebastian; int edad = calcularEdad(1982,2012); String correo =generarCorreo(nombre,edad); imprimirDatos(nombre,edad,correo); } } En este caso a la llamada a calcularEdad se le entregan los valores explcitamente, eso tambin esta correcto ya que ambos valores son recibidos en las variables declaradas dentro de la funcin, se resta y se retorna el resultado, el cual guardamos en una variable declarada dentro de miejemplo que se llama edad. Una nota importante, si bien la variable de la que se retorna el valor en calcularEdad se llama igual que la
es
valido
entonces
solicitar
la
funcin
calcularEdad que lo haga llamndola de la siguiente
104
variable en la que miEjemplo lo recibe no significa que esto deba ser as, recuerda que las variables estn en mbitos distintos y por ende son variables totalmente independientes, por esto los nombres que utilicen no generaran alguna diferencia, pudiendo ellas llamarse iguales o tener nombres diferente, recuerda que la variable edad de miejemplo lo que recibe es un nmero (el valor de la variable edad de calcularEdad) Al igual que en calcular edad en generarCorreo debemos recibir el valor de retorno, el cual en este caso es una concatenacin que simula el correo del usuario y que almacenamos en una variable llamada correo. Finalmente para llamar a imprimirDatos no hay una asignacin pero no (signo igual) dado que este es un procedimiento que ejecuta una o ms lneas de cdigo retorna un valor, sin embargo si recibe tres parmetros los cuales al igual que antes deben ser entregados en el mismo orden y con sus tipos de datos correspondientes. El cdigo completo quedar de la siguiente forma, donde los procedimientos y funciones son agregados al cdigo, no importa su orden, slo importa el orden en el que miejemplo los utiliza, siendo entonces miejemplo el punto de inicio de nuestro algoritmo y de all se ejecuta todo lo dems.
105
public class JavaApplication2 { public void miEjemplo() { String nombre = sebastian; int String edad correo = calcularEdad(1982,2012); =generarCorreo(nombre,edad);
imprimirDatos(nombre,edad,correo); } void imprimirDatos(String nombre, int edad, String correo) { System.out.println("Hola mi nombre es " + nombre + ", tengo " + edad + "aos y mi correo es " + correo); } String generarCorreo(String nombre, int edad) { String email = nombre + edad + @ return email; } int calcularEdad(int fechaNacimiento, int FechaActual) { int edad = fechaActual- fechaNacimiento; return edad; } } + empresa.cl;
106
Con las llamadas a las funciones y/o procedimientos puedes utilizar todas las combinaciones que gustes, observa este ejemplo, el cual hace lo mismo pero de otra forma, he aqu el cdigo y luego la explicacin. public class JavaApplication2 { public void miEjemplo() { String nombre = sebastian; int edad = calcularEdad(1982,2012); imprimirDatos(nombre,edad, generarCorreo(nombre,edad)); } void imprimirDatos(String nombre, int edad, String correo) { System.out.println("Hola mi nombre es " + nombre + ", tengo " + edad + "aos y mi correo es " + correo); } String generarCorreo(String nombre, int edad) { String email = nombre + edad + @ return email; } int calcularEdad(int fechaNacimiento, int FechaActual) { int edad = fechaActual- fechaNacimiento; + empresa.cl;
107
return edad; } } En este caso la lnea que asignaba el correo ha sido eliminada, sin embargo para obtener el correo y luego poder imprimirlo remplazamos la variable correo que ya no est por la llamada al mtodo generarCorreo, esto es posible ya que el mtodo lo que solicita es un string con el correo y dado que el orden de ejecucin es desde adentro hacia afuera, primero se ejecutar la funcin generarCorreo la cual retornar un String y cuyo valor es entregado a imprimir. De esta misma forma tambin podrs llamar a funciones desde otras funciones y/o procedimientos como muestra el siguiente cambio realizado a imprimir. void { System.out.println("Hola mi nombre es " + nombre + ", tengo } En este caso para obtener el correo le pedimos " + edad + "aos y mi correo es " + generarCorreo(nombre,edad); imprimirDatos(String nombre, int edad, String
correo)
directamente desde dentro de imprimirDatos.
108
Arreglos
Un arreglo es un grupo de variables de un mismo tipo, las cuales son referenciadas con un mismo nombre. Los arreglos existen en ms de una dimensin, siendo los arreglos de una dimensin (o slo arreglos) los ms comunes y los de dos dimensiones (matrices), afortunadamente para los conocedores de lenguajes como C o C++ los arreglos y matrices sern algo familiar, sin embargo no son exactamente iguales, ya que existen algunas diferencias en su sintaxis.
Unidimensionales
Los arreglos de una dimensin, permiten almacenar una cantidad N de variables de un tipo, la declaracin general de un arreglo es la siguiente: Tipo identificador [ ]; Por ejemplo:
Para este caso la declaracin ha creado una variable llamada mes que permitir referenciar a nuestro arreglo, sin embargo an el arreglo no se ha creado y mucho menos definido su tamao, esto significa que en mes an
109
no es posible almacenar valores. Para obtener un arreglo de tamao n, se debe ejecutar la siguiente sintaxis. Declaracin = new tipo[tamao] De esta forma se reservar el espacio de memoria que permitir almacenar una n cantidad de elementos, la palabra clave new crea dicho arreglo con los valores por defecto del tipo especificado, por ejemplo, la siguiente declaracin declara y construye un arreglo de tamao 12, donde cada entero dentro del arreglo es inicializado en 0:
mes es un arreglo capaz de almacenar 12 nmeros de tipo entero, los elementos estn almacenados de forma adyacente y se pueden referenciar utilizando un nmero entre 0 y 11 (12 en total). Por ejemplo, el siguiente cdigo almacena el valor de 10 en la posicin 1 del arreglo, de forma adicional, si cada posicin tuviese directa equivalencia con el nombre de un mes, la posicin 1 seria febrero, ya que, 0 es la primera posicin y equivaldra a enero, luego 1 es igual a Febrero.
A pesar de no ser muy comn los arreglos tambin pueden ser inicializados, por ejemplo el siguiente cdigo crea el arreglo mes con un valor para sus 12 enteros:
110
Note, que de esta forma el tamao del largo est indicado por la cantidad de elementos con el que se inicializa. El ciclo for estudiado en captulos anteriores es el utilizado de forma ms comn en la operatoria con arreglos, el siguiente cdigo muestra la forma de imprimir todos los valores del arreglo mes:
La salida del dicho cdigo ser:
111
Arreglos de dos dimensiones.

Los arreglos multidimensionales son en realidad arreglos que contienen otros arreglos. Es muy comn asociar un arreglo multidimensional con una matriz, sin embargo las matrices son slo una posibilidad dentro de la enorme cantidad de combinaciones que permite trabajar con arreglos de arreglos. El siguiente cdigo permite declarar un arreglo en dos dimensiones.
Para este caso nuestro elemento es de tipo rectangular, dado por 4 filas y 5 columnas, como muestra la siguiente tabla. [0][0] [0][1] [0][2] [0][3] [0][4]
112
[1][0] [1][1] [1][2] [1][3] [1][4] [2][0] [2][1] [2][2] [2][3] [2][4] [3][0] [3][1] [3][2] [3][3] [3][4] Por lo tanto, toda operatoria con arreglos de dos dimensiones, debe especificar las dos dimensiones para poder referenciar un elemento dentro de la estructura, por ejemplo, el siguiente cdigo muestra cmo se asigna el valor de 10 al tercer elemento de la segunda fila.
La siguiente tabla muestra los valores que contiene la matriz. 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0 0 0 0 0 0
Note que la tabla anterior muestra los valores por defecto que tiene nuestra matriz, sin embargo es importante comentar que la tabla muestra una vista conceptual de cmo se almacenan los datos en una matriz, dado que en la memoria fsica los datos no son almacenados con esta estructura. El siguiente algoritmo permite poblar una matriz de 4 x 5 con los nmeros desde el 1 al 20:
113
Arreglos de arreglos.
Es muy usual que cuando se trabaja con arreglos de dos dimensiones, muchos asociamos inmediatamente la estructura con una forma rectangular, si vamos ms all, descubriremos que en Java tambin pueden declararse arreglos multidimensionales de tres dimensiones de la siguiente forma:
sin embargo, es slo el comienzo, ya que, en Java puedes agregar todas las dimensiones que desees Cmo es eso posible? la respuesta no es tan compleja como se piensa, sucede que una matriz, en realidad no es un rectngulo, sino que, arreglos de arreglos, por ejemplo,
114
la matriz vista anteriormente de 4 filas y 5 columnas, en la memoria se encuentra almacenada de la siguiente forma:
Como se puede apreciar, existe en realidad un arreglo de 4 elementos, pero cada uno de ellos es adems un arreglo de 5 posiciones, por ello la anotacin de una matriz es [][] (arreglos de arreglos), por ende, cuando se escribe una referencia a algn elemento como:
Se est en realidad diciendo, que en el arreglo que ocupa la posicin 1 (es decir el segundo elemento, dado que comienza de cero) almacenamos en su posicin 2 (la tercera) el valor de 10. De esta forma el siguiente ejemplo muestra como luce un arreglo de tres dimensiones:
115
116
117
Introduccin a la Programacin Orientada a Objeto.

Caractersticas generales de la programacin orientada a objetos.
Muchas personas al escuchar por primera vez la frase programacin orientada a objetos la asocian inmediatamente a un programa o una tecnologa, sin embargo dicha asociacin es incorrecta, por ello antes de adentrarnos en el mundo de la programacin orientada a objetos (POO. desde ahora en adelante) y sus beneficios vamos a aclarar algunos puntos importantes.
Qu es la programacin orientada a objetos

La programacin orientada a objetos es un conjunto de normas, que se basan en la idea de construir un software de forma mucho ms cercana a la vida real, simplificando las tareas de desarrollo de software y entregando importantes beneficios a los programadores, los cuales se benefician principalmente de la reutilizacin de cdigo, evitando as volver a realizar tareas comunes una y otra vez. (Importante) La POO no es aplicable slo a JAVA, la POO es una norma (una forma de hacer las cosas)
118
independiente del lenguaje, por ende, esta norma puede ser utilizada no slo con JAVA, sino que con cualquier lenguaje orientado a objetos del mercado, como por ejemplo, C#, C++ o PHP desde su versin 5.0. Esto representa un importante beneficio para el programador, ya que la transicin de aprender un lenguaje orientado a objetos distinto se hace ms fcil cuando ya dominas alguno de ellos. Antes de continuar, es imprescindible comprender a qu nos referimos con Objeto y para ello hagamos el siguiente ejercicio: miremos a nuestro alrededor y veamos los objetos que nos rodean, fjate que cada elemento que miras es un objeto y que para cada uno de ellos existen propiedades, un comportamiento y un estado. En informtica nos referimos a un objeto como el bloque de construccin de un programa orientado a objetos. Un programa que utiliza la Orientacin a Objetos (desde ahora en adelante OO) bsicamente contiene una coleccin de objetos. (Definicin) Un objeto es la instancia de una clase, la cual contiene propiedades, comportamientos, estados y una identidad que lo hace nico.
119
(Definicin)Un objeto es un concepto, abstraccin o cosa con un significado y lmites claros en el problema en cuestin (Rumbaugh) (Definicin) Es aquel que posee propiedades, estado y comportamientos. (Booch)
Atributos
Piensa en un televisor y trata de identificar qu atributos este contiene, algunos de los ms visibles son: Color Marca Modelo Tamao Peso (Definicin)Podemos definir entonces un atributo como la caracterstica de un objeto, la cual posee un valor. Por ejemplo el atributo color puede tener los valores: verde, caf, blanco, etc. As como la propiedad peso puede ser: 3 kilos, 4 kilos, etc. No es vlido entonces afirmar que 2 metros es un atributo, debido a que la expresin 2 metros es en realidad el valor de un atributo. Ahora si bien un objeto puede tener muchas propiedades, no todas son tiles al momento de programar, pues slo las que son tiles en el contexto del
120
problema deben ser consideradas. Por ejemplo, si estoy creando un objeto que me permita representar al cliente de un banco es muy probable que la estatura que tenga no sea un dato relevante para el proceso que realiza el banco.
Comportamientos
(Definicin)Estos se refieren a todas aquellas actividades que pueden llevarse a cabo con el objeto, los cuales se ejecutan como respuesta a un mensaje proveniente desde el usuario u otros objetos. Volvamos al ejemplo del televisor y pensemos en los distintos comportamientos que un televisor tiene, los cuales son por ejemplo: Encender Apagar Cambiar canal Cambiar el volumen. Con estos comportamientos entramos a analizar una caracterstica bsica de los sistemas de informacin en general, y dice que cualquier proceso que estos realicen, afecta al valor de un atributo, ahora los valores de dichos atributos alguien los produce y el software los consume para realizar un proceso. En el caso de los objetos, los datos generalmente estn asociados a un atributo y el comportamiento del objeto utiliza estos datos. As se da una relacin directa entre el dato y el comportamiento, el
121
comportamiento afecta al atributo y el valor del atributo afecta al comportamiento. Por ejemplo, si creamos una clase que represente un plumn, podemos identificar un comportamiento bsico que es rayar (el plumn no escribe lo haces t), ahora, un atributo del plumn es la cantidad de tinta que este posee, si te fijas si no tengo tinta no puedo rayar y cada vez que rayo, la cantidad de tinta disminuye. De esta forma la propiedad define al comportamiento y el comportamiento afecta a este atributo.
Estados
(Definicin)Es informacin que posee el objeto, la cual puede ser fija o variable. Por ejemplo, en el caso de nuestro televisor algunos estados son: Encendido Apagado En silencio (mute). El estado permite definir los comportamiento que el objeto puede o no realizar, por lo tanto no slo se trata de los valores de las propiedades del objeto, sino de como este se comporta con los valores que est manejando.
122
Clase
A menudo en informtica se utiliza la palabra clase y objeto como sinnimos, sin embargo dicha asociacin es incorrecta. (Definicin)Una clase es la definicin de un objeto, de sus atributos,comportamientos y estados, es muy similar a lo que para un arquitecto es el plano de una casa, en l se definen la posicin de las puertas y las dimensiones que estas tendrn. En informtica, por ejemplo, la clase que permite crear objetos de tipo persona definir atributos como el Rut, nombre y edad y comportamientos como comer, jugar, cantar y estudiar. Continuando con el ejemplo del televisor, pensemos en qu sucede si ahora ponemos frente a nuestra vista 3 televisores, qu es lo que tienen en comn? La respuesta a la pregunta sera, atributos, comportamientos y estados, debido a que los 3 son el mismo objeto. Ntese, que la expresin el mismo objeto es en realidad ms compleja de lo que parece, debido a que son en realidad el mismo objeto? Definitivamente no, es verdad que tienen los mismos atributos, por ejemplo, ambos tienen tamao, marca y modelo, recuerde que los valores de las propiedades pueden variar, es decir uno puede ser de 22 pulgadas y los otros dos de 15 sin embargo los tres comparten un atributo llamado cantidad de pulgadas, donde lo que
123
cambia
es
su
valor,
as
mismo
comparten
los
comportamientos de encender, apagar y los estados de encendido y apagado. Dado lo anterior podemos decir entonces que los objetos siempre se pueden identificar como un objeto distinto a otro, a este concepto se llama identidad. (Importante) La identidad es un concepto que no est asociado a los valores de los atributos o diferencias entre los comportamientos que estos puedan tener, es decir, si para el ejemplo anterior los tres televisores tuviesen la misma cantidad de pulgadas, la misma marca y modelo, aun as son 3 objetos que poseen su propia identidad. Recordemos que uno de los principales beneficios de la programacin orientada a objetos dice que permite la reutilizacin de cdigo, pues bien, ahora veremos como las clases aportan de manera significativa en este proceso. Para simplificar an ms la explicacin, vamos a recurrir nuevamente a nuestro arquitecto, el cual tiene la difcil tarea de construir un gran condominio de 20 casas iguales, es necesario que nuestro arquitecto idee, calcule, mida y dibuje 20 planos de casas? Pues no, el slo idear un plano y por qu?, sencillo, porque no es necesario, debido a que todas las casas tienen mucho en comn y a partir de un solo plano (clase) se puede construir una N cantidad de casas (objetos). (Importante) de all proviene la definicin de objeto, la cual dice que un objeto es la instancia de una clase,
124
debido a que todos los objetos son construidos a partir de una misma clase. Veamos como habra que construir una clase para satisfacer el requerimiento de registro del personal de una clnica, del cual sabemos que existen alrededor de 1000 trabajadores entre los que se incluyen doctores, enfermeras, dentistas, administrativos, personal de aseo, etc. Solucionar este problema es mucho ms sencillo de lo que parece. Primero tenemos que definir qu informacin se desea obtener de cada uno, como se puede notar, todos tienen algo en comn y es que todos son personas, por ende comparten comportamientos y propiedades y de ellas registraremos: el Rut el cual representa un usuario como nico (identidad), nombres, apellidos, edad y departamento en el que trabajan. Por ende la clase que debemos crear debe tener las siguientes propiedades: Rut (representado por una combinacin de nmeros y caracteres). Nombres y apellido (representado por una combinacin de caracteres). Edad (representada por un nmero) Departamento. (representada por una combinacin de caracteres)
125
Adicionalmente comportamientos:
podemos
agregar
algunos
Verificar edad (el cual verifica que la edad sea mayor a 18 aos) Una vez nuestra clase (definicin de cmo es un objeto) est resuelta, debemos utilizar un lenguaje como JAVA para crear la clase en nuestro computador y a partir de ella podemos crear todos los objetos que deseemos con distintos Finalmente valores en sus la propiedades Java los que representarn a las personas que laboran en la clnica. utilizando lo tecnologa creando debemos que complementar anterior aplicaciones
permitan a los usuarios interactuar a travs de una aplicacin Web o de escritorio que les permita ingresar y posteriormente ver la informacin referente al personal.
126
En la programacin Orientada a Objetos existen 4 pilares fundamentales que hay que conocer antes de arriesgarse a programar clases, el profundo conocimiento de ellos, te permitir identificar cmo crear mejores clases y ahorrar una gran cantidad de trabajo, as como disminuir las posibilidades de cometer errores: Abstraccin. Encapsulamiento. Herencia.
Abstraccin
(Definicin)La abstraccin corresponde a la ignorancia selectiva con la que enfrentamos un problema, el concepto de abstraccin nos dice que debemos preocuparnos slo de lo importante e ignorar de manera selectiva lo que no lo es. Un ejemplo de abstraccin es el siguiente, Rut, Peso, sabes que algunas masa propiedades muscular, correspondientes a una persona seran: Edad, Nombre, Estatura, gnero, nacionalidad. Pero qu sucede si las personas que deseamos gestionar mediante un software son jugadores de ftbol? En dicho caso algunas propiedades candidatas a tomar en cuenta son: nmero de camiseta, equipo en el que juega, edad, nacionalidad y cantidad de goles realizados. Observa que en esta ocasin de manera selectiva hemos obviado propiedades como alimento preferido, el color que ms le gusta, color de ojos, etc. Que si bien son propiedades comunes para las personas, para un futbolista no son relevantes.
127
Encapsulacin
(Definicin)Es la caracterstica que tienen las clases de ocultar la complejidad de sus comportamientos, mediante la presentacin al usuario de una interfaz, la cual responde a peticiones a travs de mtodos sin la necesidad de exponer los medios utilizados para brindar un resultado. El encapsulamiento es un concepto con el que lidiamos a menudo sin darnos cuenta, por ejemplo, si volvemos al caso del televisor citado antes y recordamos los comportamientos que este posee, nos daremos cuenta que encender y apagar el televisor son comportamientos que utilizamos a menudo, pero que afortunadamente la complejidad del proceso, es decir el qu sucede para que se encienda o apague est oculta para nosotros (el usuario), curiosamente, tampoco nos interesa saber como funciona. La razn de esto se debe a que el televisor expone al usuario una interfaz que presenta de forma comprensible las entradas (lo que necesita para encenderse) y las salidas (el resultado) , entonces, el usuario enva un mensaje al televisor el cual es enviado a travs del control remoto. Por otra parte el televisor en su interfaz, a travs del receptor o el botn de encendido, nos indica qu es lo que necesita para comenzar a ejecutar el comportamiento encender, entonces, sin importar si el mensaje es enviado a travs de la pulsacin del botn o por medio del control remoto, el mensaje es entregado como dato de entrada necesario para la
128
ejecucin, as, el televisor de forma oculta (encapsulada) ejecuta todos el los mecanismos recibe para encenderse. un Finalmente usuario como recompensa
televisor preparado para comenzar a disfrutar de su programa preferido.
Herencia
La herencia es una de las ms interesantes bondades que presenta la POO. Gracias a ella es posible una jerarquizacin de las clases y una mayor reutilizacin de cdigo, donde las clases en lo ms alto de la jerarqua contendrn un conjunto de funcionalidad comunes que utilizarn las clases de niveles inferiores, las cuales agregan nuevas funciones que son cada vez ms especficas, (Definicin)La herencia define una relacin entre clases, en la cual una clase comparte su estructura y comportamientos con otra. El ejemplo ms claro de la herencia es la especie humana, donde la herencia se da en un conjunto de atributos fsicos que se van pasando de generacin en generacin (nuestros atributos), incluso los humanos heredamos a nuestros hijos una serie de comportamientos que son propios de lo humanos y otros que vamos modificando (especializando) con el tiempo.
129
Aplicaciones bsicas
Como habamos conversado anteriormente, Java es un programa OO, lo que significa que slo se compone de objetos y que ellos son instanciados (construidos) a partir de una clase, la cual es la que define los atributos y comportamientos que puede realizar. Afortunadamente para nosotros, no todos los objetos que se necesitan comnmente en un software debemos construirlos a partir de una clase desarrollada con esfuerzo nuestro, esto debido a que Java ya ha identificado muchos objetos que los programadores necesitan y para cada uno de ellos ya existe una clase que contiene toda su funcionalidad. Si bien, ya vimos que al igual que otros
130
lenguajes de programacin el comienzo de ella es el mtodo main, no debemos olvidar que en un programa desarrollado bajo la OO debe contener al menos una clase, es por ello que nuestro mtodo main se encuentra dentro de una, tal y como muestra la imagen a continuacin:
Para este caso nuestro programa comienza por la clase HolaMundo, siendo el mtodo main el encargado de iniciar y terminar nuestro programa. Probablemente una de las formas ms fcil de conocer la estructura de un programa en Java es generar uno. Para eso vamos a crear un pequeo ejemplo, que consista en un programa que nos permita ingresar el cdigo de una asignatura, sus notas y luego nos entregue el promedio de ellas. La pregunta ser entonces: Qu datos nos permiten solucionar este problema? La conclusin ser: El cdigo de la asignatura, la sumatoria de las notas y la cantidad
131
de notas ingresadas para realizar la divisin en el clculo del promedio. De forma tradicional estas variables hubiesen sido declaradas dentro del mtodo main, sin embargo, esta vez no slo crearemos un programa que nos permita realizar dicho clculo, sino que definiremos en una clase como debe ser un objeto que permita realizar esta operacin. La ventaja principal de esta solucin, versus la anterior, es que a partir de esta clase podremos crear todos los objetos que queremos, incluso esta clase (nuestro plano del objeto) la podremos portar a otros programas que requieran realizar este clculo. Comenzaremos a confeccionar nuestra clase en un nuevo archivo, el Es muy cual llamaremos que el CalculadorDeNota.Java. importante
nombre del archivo coincida con el nombre de la clase que contendr en su interior, adicionalmente debes recordar que las clases comienzan con maysculas y luego se escribe todo con minsculas, salvo la primera letra de cada nueva palabra que contenga. El archivo CaluladorDeNota.Java debe lucir de la siguiente forma:
132
Hasta aqu hemos definido una clase que permitir crear un objeto de tipo CalculadorDeNota, sin embargo nuestro futuro objeto no contiene atributos ni comportamientos, o dicho de otra forma, nuestro objeto ya se puede construir (instanciar), pero no hace nada. Ha llegado el momento de definir en nuestra clase, que atributos y comportamientos se necesitan para resolver el problema. Como lo habamos mencionado, se necesitar el cdigo de una asignatura, la sumatoria de las notas y la cantidad de notas ingresadas para saber por cuanto hay que dividir. A estos datos los llamaremos atributos de una clase. (Definicin) Los atributos de una clase sirven para almacenar datos que son propios del objeto y se crean a partir de su instancia. Las variables declaradas como atributos no deben ir dentro de un mtodo, ya que, debido al concepto de mbito de una variable, slo quedara como una variable local del mtodo, en cambio los atributos, deben ser vistos por todos los comportamientos que esta contenga. Para nuestro caso la clase y su respectiva declaracin de atributos debe lucir de la siguiente forma:
133
Ya que conocemos los atributos que nuestra clase tiene, ahora debemos enfocarnos en su funcionalidad, esta clase consta principalmente de 3 mtodos o comportamientos: Sumar nota: el cual nos permite agregar una nueva nota, la que agregaremos a la sumatoria de las notas anteriores, adicionalmente debe contar la cantidad de notas sumadas al realizar la operacin. Resultado: divide la sumatoria de las notas en la cantidad de notas ingresadas. Asignar asignatura: permite ingresar el cdigo de la asignatura. Comenzaremos por el ms sencillo, el comportamiento que calcula el resultado.
134
Aqu se puede apreciar una importante ventaja con respecto al encapsulamiento que las clases poseen. Nota que se ha realizado el comportamiento resultado sin necesidad de tener el resto del cdigo, este nivel modularidad permite llevar un mejor control sobre los errores. Agreguemos ahora el comportamiento que nos permite agregar una nueva nota.
135
Con esto, nuestra clase ya se encuentra funcional y podemos realizamos probarla ahora desde una nuestro mtodo main, es pequea demostracin,
importante que se comprenda que el cdigo escrito en la clase no se ejecutar si no es llamado desde el mtodo main, ya que mientras main no tenga la instruccin de construir un objeto, ste no lo har.
136
La
explicacin
al
cdigo
anterior
es
la
siguiente:
Declaramos un objeto de tipo CalculadorDeNota (de nuestra clase). Se crea un objeto CalculadorDeNota a partir de la clase y se almacena en el objeto calculador.
Asigna un cdigo a nuestra calculadora Agrega el nmero 50 y luego 40, al agregar cada uno de ellos es sumado con el resultado anterior, adicionalmente en la cantidad de notas es aumentada, para este caso tenemos: 0 + 50 +40 = 90; cantidadDeNotas = 2;
137
Imprime el valor que contiene la variable asignatura del objeto calculador, es decir el el 001 ingresado de la anteriormente. Imprime valor resultante
ejecucin del comportamiento resultado. Analicemos ahora el siguiente cdigo:
En este caso hemos creado dos calculadoras con cdigos de asignatura distintos, es importante mencionar que el beneficio que aqu se presenta es la posibilidad de crear dos objetos, donde cada uno de ellos posee sus propios atributos sin la necesidad de volver a codificarlos nuevamente. Fjate que es incluso comprobable, ya que,
138
en el cdigo anterior el objeto calculador y otroCalculador reciben en el nombre de la asignatura 001 y 002 respectivamente. Si miramos el resultado de las dos lneas que imprimen los valores de cada uno de los objetos creados, podra darte la impresin de que el resultado ser 002 para ambos, debido a que has reescrito el valor de la variable asignatura, sin embargo dicho razonamiento, afortunadamente para nosotros es errneo, siendo el resultado de la impresin 001 y luego 002 respectivamente. Esto comprueba de que cada objeto es distinto (concepto de identidad) y que las variables no son compartidas, sino que son propias de cada instancia.
Seguridad en una clase

Qu sucedera si decimos que todas los notas ingresadas al calculador de notas debe estar entre el valor 1 y 7? Nota que a los objetos instanciados a partir de la clase CalculadorDeNota se les puede forzar a dar un resultado que no tiene validez en el clculo de las notas de una institucin que utiliza la escala 1-7 que utilizamos en Chile, observe las siguientes formas en las que el cdigo puede fallar.
139
Como se puede ver, el valor entregado (-4564654) provocar que el clculo final falle, de momento no parece algo tan difcil de solucionar, dado que no tiene sentido escribir como parte del cdigo dicho valor, sin embargo, en un futuro no lejano, el cdigo lucir de la siguiente forma:
Esta variacin permite que el valor entregado lo digite el usuario y es aqu cuando se presenta el mayor de los problemas, ya que es imposible adivinar qu valores digitar el usuario y es por ello que debemos prestar una especial atencin en la forma de proteger nuestro software de las entradas de este tipo. La solucin ms utilizada es la de crear el mtodo get y set para cada atributo. Para proteger los atributos de nuestra clase, por ejemplo, en el programa que tenemos, podemos de forma sencilla asignar valores a sus atributos utilizando las siguientes lneas de cdigo:
140
El
valor
68
son
asignados
las
variables
cantidadNotas y sumatoria, pero es eso correcto? Evidentemente no, ya que no existe ninguna posibilidad de que 4 notas sumen 68. El problema de seguridad ha sido causado debido a que ambos atributos son por defecto pblicos, esto significa que sus valores pueden ser cambiados desde fuera de la propia clase, por ejemplo, en este caso el cambio lo genera el mtodo main. Este problema tiene una solucin bastante sencilla y consiste en proteger los atributos de forma que slo la clase que los contiene los pueda cambiar, para ello es necesario cambiar su nivel de visibilidad (desde donde las variables son visibles y desde donde sern ocultas). Existen 3 niveles de visibilidad: public: significa que los atributos de una clase pueden ser accedidas desde fuera de la propia clase. private: significa que las variables slo pueden ser utilizadas desde la misma clase. protected: permite a los atributos comportarse como privadas, pero pblicas para las clases hijas de la clase que las declara. (se ve ms adelante en el captulo de herencia). (Importante) en Java por definicin todos los atributos de una clase deben ser privados.
141
Si dejamos de esta forma la declaracin de variables de forma automtica hemos ayudado a la seguridad, debido a que estas dos lneas de cdigo ya no compilarn:
Sin embargo esto provoca un nuevo problema con la lnea:
El error se produce debido a que ya no se puede obtener acceso ni de escritura ni lectura sobre la variable asignatura de ningn objeto de tipo CalculadorDeNota. Se preguntar ahora, si bien el problema de agregar notas con un valor inconsistente segn la cantidad de notas ya ha sido solucionado, dado que la nica forma de hacerlo es a travs del comportamiento agregarNota, el cual mantiene una consistencia entre la suma de las notas y la cantidad de ellas, pero, qu suceder con la asignatura?
142
Get y Set.
La respuesta a este problema se encuentra en el get y set de Java, los cuales no son otra cosa que dos comportamientos que existen por cada atributo que exista en la clase. Los get y set proveen un mecanismo que permiten cambiar o conocer el valor de un atributo desde fuera de la clase como si fuesen pblicas, sin embargo agregan la posibilidad de llevar un mejor control sobre los valores que se le asignan. El comportamiento get (acceder) para el atributo asignatura lucir de la siguiente forma:
Note, que nuestro get es un comportamiento muy sencillo de programar, su nivel de visibilidad es pblico, con ello conseguimos que sea visto desde otros lugares del cdigo como por ejemplo, el mtodo main, el tipo de retorno siempre es el mismo de la variable, en este caso es de tipo String y el nombre del comportamiento comienza con
143
get (obtener) y continua con el nombre de la variable que obtiene (getAsignatura), su firma no recibe parmetros y la nica lnea de cdigo que posee el cuerpo del mtodo corresponde a la devolucin del valor de asignatura. El set en cambio es el comportamiento que nos permite cambiar el valor de nuestra asignatura:
El mtodo set es todo lo contrario a get. Note que tambin es pblico, sin embargo no retorna ningn parmetro, dado que su objetivo es cambiar el valor del atributo asignatura, a cambio este mtodo recibe como parmetro con un nuevo valor para la asignatura, el valor debe coincidir con el tipo de destino, finalmente dentro del cuerpo se asigna el nuevo valor a nuestro atributo. La siguiente lnea de cdigo tiene un papel fundamental en la asignacin del nuevo valor:
Note que el mtodo setAsignatura tiene dos variables llamadas asignaturas, una corresponde al atributo
144
asignatura) y un parmetro con el mismo nombre, el objetivo final es recibir el valor en un parmetro para almacenarlo en nuestro atributo, pero cmo podra discernir Java si escribimos lo siguiente:
Pues de hecho s lo hace, siempre que exista este tipo de situacin la preferencia la tiene el parmetro que recibe el mtodo, debido a que es una variable local del mtodo que lo recibe, esto significa que la siguiente lnea de cdigo nunca asigna el nuevo valor al atributo, muy por el contrario slo asigna al parmetro el valor que ya contiene, dejando al atributo intacto. Es aqu cuando la palabra reservada this marca la diferencia, debido a que sta se utiliza para referenciar a todos los atributos o comportamientos que pertenezcan a la clase, por ende this.asignatura se refiere al atributo debido a que por medio de this no podemos llegar a variables locales de mtodos u otros elementos que no se encuentren a nivel de clase. Desde el mtodo main, la utilizacin del objeto asignatura quedar de la siguiente forma:
145
Existen diversos beneficios al utilizar este mtodo, siendo uno de los ms importantes la encapsulacin de las validaciones que pueden aplicarse sobre los datos, por ejemplo, si necesitamos que la asignatura contenga tres caracteres, entonces debemos validar que la entrada del usuario nos entregue un String que cumpla con la condicin de la siguiente forma:
Aqu se reciben los datos desde el usuario y luego se comprueba que la variable nuevaAsignatura que almacena el valor recibido cumpla con la condicin de tener tres caracteres antes de ser entregada a la calculadora mediante setAsignatura. El problema que presenta esta validacin es que tendremos repetirla por cada objeto que creemos, de la siguiente forma:
146
El proceso de validacin ha tenido que ser reiterado para cada objeto de tipo calculadorDeNota que existe, simplifiquemos de manera significativa esto, utilizando la encapsulacin y la ventaja que los mutadores nos proveen, en la clase CalculadorDeNota, modificamos el set para que luzca de la siguiente forma:
De esta forma la validacin es parte del objeto y no ser necesaria repetirla varias veces en el mtodo main ya
147
que se ejecutar cada vez que se ejecute la siguiente lnea:
Es considerado una buena prctica crear el get y set para cada atributo de la clase. Si se desean mantener oculto el acceso a algunos de sus atributos deje el get y set del atributo con el modificador private, sin embargo, dentro de la misma clase an podr canalizar las validaciones en los set para realizar cambios en los valores de los atributos internos. De esta manera, la estructura de su cdigo a partir de ahora debe lucir as:

Manual Fundamentos de Programación 1.1

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Manual Fundamentos de Programación 1.1

Hochgeladen von

Copyright:

Verfügbare Formate

1

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

Fundamentos del procesamiento de datos.

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

mantener tu closet ordenado.

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

Proceso manual de datos.

Proceso computacional de datos.

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

Estructura funcional de un computador.

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

Unidad de almacenamiento principal.

Unidades externas de almacenamiento secundario.

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

Elementos o componentes de un procesamiento computacional de datos.

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

Plantilla para prueba manual o seguimiento de ejecucin de una secuencia lgica.

Tipo Plan Ilimitado Ilimitado

Datos de control Nro de Valor a cargar telfono 84480965 3500

Tipo Plan Cuenta Controlada Cuenta Controlada Cuenta Controlada

Acciones Buscar los datos del telfono

Datos de control Nro de Valor a cargar telfono 84480965 3500

Tipo Plan Prepago

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

Valor a cargar 3500

Tipo Plan Cuenta Controlada Cuenta Controlada Cuenta Controlada

Saldo 1000 1000 1000

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

Tcnicas de algoritmos para el diseo de procesos computacionales.

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

operaciones que debe realizar un algoritmo. Ejemplo: Pseudocdigo.

Caractersticas de un buen algoritmo.

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

Etapas en la creacin de programas.

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

Conceptos de variables y constantes.

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

miPrimeraVariable, donde tanto P como V van con maysculas

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

Si su valor de inicio no es especificado, el valor por defecto es false.

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

programacin estructurada dentro del mtodo main.

utilizacin de los tipos vistos en declaracin de atributos de nuestra clase Persona.

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

(Importante) private representa el nivel de accesibilidad y ser estudiado ms adelante.

Vida y mbito de una variable

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES

UNIVERSIDAD TECNOLGICA DE CHILE INACAP - REA INFORMTICA Y TELECOMUNICACIONES