Source: https://www.slideshare.net/victdiazm/java-a-traves-de-ejemplos
Timestamp: 2017-05-01 04:40:32+00:00

Document:
by MoniJuanAlex
by slidewoman
Luis Alberto Bonilla Lopez
, Programador Analista en Sepen
Angel Hermida Otero
at Sermatica
Victor Leyva Fernandez
, Simple en Estado
PRÓLOGOIntroducción Java a través de ejemplos presenta los conceptos básicos del lenguaje deprogramación Java y muestra sus posibilidades más relevantes para el desarrollo deaplicaciones. El libro se centra en la explicación detallada de los fundamentos dellenguaje, evitando los temas de carácter especializado. La didáctica de esta publicación se basa en el aprendizaje guiado medianteejemplos comentados y gráficos de apoyo a las explicaciones, evitándose lasaclaraciones puramente teóricas y e uso de un nivel de detalle excesivo en la linformación suministrada. Este libro, por tanto, resulta especialmente adecuado para los lectores que noposeen unos conocimientos previos del lenguaje o para aquellos cuyo principalobjetivo es adquirir los fundamentos de Java para, posteriormente, poder afrontarcon una base sólida el aprendizaje de aspectos específicos tales como lascomunicaciones, acceso a bases de datos, presentaciones multimedia, etc. Se incluyen dos apéndices con más de 500 preguntas y sus respuestasbasadas en los conceptos fundamentales de Java. Estas cuestiones permiten que ellector pueda comprobar la corrección y completitud con los que va asimilando lasdiferentes materias. Los contenidos del libro se han dividido en 9 capítulos que contienen 38lecciones; cada una de estas lecciones forma una unidad de estudio que convieneafrontar de manera individualizada. Para facilitar la comprensión de estas unidades,las lecciones se han diseñado con un tamaño reducido: de unas 8 páginas portérmino medio. En el siguiente apartado se presenta una relación de las lecciones, agrupadasen capítulos y con la referencia del número de página donde comienza cada una. 2.
XIV JAVA A TRAVÉS DE EJEMPLOS © JESÚS BOBADILLA SANCHO (JBOBI@EUI.UPM.ES)Lecciones incluidas en la publicaciónCapítulo 1: toma de contacto, variables, tipos de datos y operadores LECCIÓN 1: Instalación del entorno de desarrollo LECCIÓN 2: Primer programa en java: “Hola mundo” LECCIÓN 3: Variables y tipos de datos LECCIÓN 4: OperadoresCapítulo 2: estructuras de control LECCIÓN 5: El bucle FOR LECCIÓN 6: El bucle WHILE LECCIÓN 7: La instrucción condicional IF LECCIÓN 8: La instrucción condicional SWITCH LECCIÓN 9: EjemplosCapítulo 3: métodos y estructuras de datos LECCIÓN 10: Métodos LECCIÓN 11: Strings LECCIÓN 12: Matrices (arrays, vectores) LECCIÓN 13: Ejemplos de programaciónCapítulo 4: programación orientada a objetos usando clases LECCIÓN 14: Definición de clases e instancias LECCIÓN 15: Sobrecarga de métodos y constructores LECCIÓN 16: Ejemplos LECCIÓN 17: Clases utilizadas como Parámetros LECCIÓN 18: Propiedades y métodos de clase y de instancia LECCIÓN 19: Paquetes y atributos de acceso LECCIÓN 20: Ejemplo: máquina expendedoraCapítulo 5: programación orientada a objetos usando herencia LECCIÓN 21: Herencia LECCIÓN 22: Ejemplos LECCIÓN 23: Polimorfismo LECCIÓN 24: Clases abstractas e interfacesCapítulo 6: excepciones LECCIÓN 25: Excepciones predefinidas LECCIÓN 26: Excepciones definidas por el programadorCapítulo 7: interfaz gráfico de usuario LECCIÓN 27: Creación de ventanas LECCIÓN 28: Paneles y objetos de disposición (layouts) LECCIÓN 29: Etiquetas, campos y áreas de texto LECCIÓN 30: Cajas de verificación, botones de radio y listas 3.
© JESÚS BOBADILLA SANCHO (JBOBI@EUI.UPM.ES) PRÓLOGO XV LECCIÓN 31: Diseño de formularios LECCIÓN 32: Diálogos y menúsCapítulo 8: eventos LECCIÓN 33: Mecanismo de eventos en java LECCIÓN 34: Eventos de ratón y de movimiento de ratón LECCIÓN 35: Eventos de teclado y de ventana LECCIÓN 36: Eventos de acción, enfoque y elementoCapítulo 9: aplicaciones de ejemplo LECCIÓN 37: Ejemplo: calculadora LECCIÓN 38: Ejemplo: editorPlanificación en el estudio de las lecciones 05 06 01 02 03 04 07 09 10 08 11 13 14 15 16 17 18 19 12 20 21 22 23 24 25 26 27 28 29 36 31 32 33 34 37 38 30 36 4.
XVI JAVA A TRAVÉS DE EJEMPLOS © JESÚS BOBADILLA SANCHO (JBOBI@EUI.UPM.ES) El diagrama presentado en la página anterior nos muestra la secuencia de laslecciones contenidas en el libro. El estudio de las lecciones que presentan fondo decolor blanco es importante para conseguir un nivel adecuado de conocimientos en ellenguaje Java. Las lecciones del gráfico que tienen fondo gris pueden ser omitidas en casode necesidad; esto es posible debido a que se corresponden con ejercicios deconsolidación de los temas anteriores o porque se refieren a características dellenguaje que se utilizan con menos frecuencia. En cualquier caso, el estudio de estaslecciones resulta importante para conseguir una mejor asimilación de los conceptosexplicados, por lo que es muy conveniente acudir a ellas una vez comprendidas laslecciones que les preceden. Los cuadrados grises contienen lecciones que pueden ser abordadas encualquier orden, por ejemplo, después de la lección 10, podemos estudiar en primerlugar la 12 y después la 11 o viceversa. Esperamos que estas indicaciones puedan ayudar a ahorrar tiempo a loslectores que desean estudiar en primer lugar las características más relevantes dellenguaje, pudiendo profundizar posteriormente en dichos conceptos y en algún otromenos utilizado en la programación general. 5.
ÍNDICEPRÓLOGO ......................................................................................... XIIICAPÍTULO 1: TOMA DE CONTACTO, VARIABLES, TIPOS DE DATOS Y OPERADORES ........................................ 1 1.1 Instalación del entorno de desarrollo................................... ........................................1 1.2 Primer programa en java: “Hola mundo”........................................................................5 1.3 Variables y tipos de datos...................................................................................................7 1.3.1 Variables ......................................................................................................................7 1.3.2 Tipos de datos.............................................................................................................9 1.3.3 Tipos numéricos enteros .........................................................................................10 1.3.4 Tipos numéricos decimales ....................................................................................12 1.3.5 Tipo booleano...........................................................................................................13 1.3.6 Tipo carácter .............................................................................................................14 1.3.7 Conversión exp lícita de tipos (Casting)...............................................................15 1.4 Operadores ..........................................................................................................................16 1.4.1 Introducción..............................................................................................................16 1.4.2 Operadores aritméticos............................................................................................17 1.4.3 Operadores lógicos ..................................................................................................18 1.4.4 Operadores de comparación...................................................................................19CAPÍTULO 2: ESTRUCTURAS DE CONTROL ............................. 21 2.1 El bucle FOR ......................................................................................................................21 2.1.1 Sintaxis .......................................................................................................................21 2.1.2 Ejemplos de aprendizaje ..........................................................................................22 2.1.3 Situaciones erróneas.................................................................................................24 2.1.4 Ejemplos de resolución de problemas...................................................................26 2.2 El bucle WHILE ................................................................................................................29 2.2.1 Sintaxis .......................................................................................................................30 6.
VIII JAVA A TRAVÉS DE EJEMPLOS © JESÚS BOBADILLA SANCHO (jbobi@eui.upm.es) 2.2.2 Ejemplos de aprendizaje..........................................................................................30 2.2.3 Ejemplos de resolución de problemas...................................................................32 2.3 La instrucción condicional IF..........................................................................................35 2.3.1 Sintaxis .......................................................................................................................35 2.3.2 Ejemplos de aprendizaje..........................................................................................36 2.3.3 If anidados.................................................................................................................37 2.3.4 Situaciones erróneas.................................................................................................38 2.3.5 Ejemplo de resolución de problemas ....................................................................39 2.4 La instrucción condicional SWITCH.............................................................................40 2.4.1 Sintaxis .......................................................................................................................40 2.4.2 Ejemplos de aprendizaje..........................................................................................41 2.4.3 Switch anidados........................................................................................................44 2.4.4 Situaciones erróneas.................................................................................................46 2.4.5 Ejemplo de resolución de problemas ....................................................................47 2.5 Ejemplos..............................................................................................................................49 2.5.1 Cálculo de la hipotenusa de un triángulo .............................................................50 2.5.2 Punto de corte de dos rectas situadas en el espacio bidimensional..................52 2.5.3 Soluciones de una ecuación de segundo grado...................................................55CAPÍTULO 3: MÉTODOS Y ESTRUCTURAS DE DATOS ......... 57 3.1 Métodos...............................................................................................................................57 3.1.1 Sintaxis ......................................................................................................................58 3.1.2 Ejemplo 1...................................................................................................................59 3.1.3 Resultados del ejemplo 1........................................................................................60 3.1.4 Ejemplo 2...................................................................................................................60 3.1.5 Resultados del ejemplo 2........................................................................................61 3.1.6 Paso de argumentos por valor y por referencia ...................................................61 3.2 Strings..................................................................................................................................62 3.2.1 Sintaxis ......................................................................................................................62 3.2.2 Ejemplo básico..........................................................................................................64 3.2.3 Resultado...................................................................................................................65 3.2.4 Ejemplo de utilización de la clase String .............................................................65 3.2.5 Resultados..................................................................................................................66 3.3 Matrices (arrays, vectores)...............................................................................................66 3.3.1 Sintaxis ......................................................................................................................67 3.3.2 Acceso a los datos de una matriz..........................................................................68 3.3.3 Ejemplo 1...................................................................................................................69 3.3.4 Resultados del ejemplo 1 ........................................................................................70 3.3.5 Ejemplo 2...................................................................................................................70 3.3.6 Resultados del ejemplo 2 ........................................................................................72 3.3.7 Ejemplo ......................................................................................................................72 3.4 Ejemplos de programación...............................................................................................74 3.4.1 Obtención de números primos ...............................................................................74 3.4.2 “Revienta claves”.....................................................................................................76 3.4.3 Estadísticas................................................................................................................78 7.
© JESÚS BOBADILLA SANCHO (jbobi@eui.upm.es) ÍNDICE IXCAPÍTULO 4: PROGRAMACIÓN ORIENTADA A OBJETOS USANDO CLASES ...................................................... 83 4.1 Definición de clases e instancias.....................................................................................83 4.1.1 Sintaxis .......................................................................................................................83 4.1.2 Representación gráfica ............................................................................................84 4.1.3 Instancias de una clase.............................................................................................84 4.1.4 Utilización de los métodos y propiedades de una clase.....................................86 4.1.5 Ejemplo completo ....................................................................................................87 4.1.6 Resultado...................................................................................................................89 4.2 Sobrecarga de métodos y constructores .........................................................................89 4.2.1 Sobrecarga de métodos............................................................................................89 4.2.2 Ejemplo ......................................................................................................................90 4.2.3 Resultado ...................................................................................................................93 4.2.4 Constructores.............................................................................................................93 4.3 Ejemplos..............................................................................................................................96 4.3.1 Figura genérica .........................................................................................................96 4.3.2 Agenda de teléfono ..................................................................................................98 4.3.3 Ejercicio de logística............................................................................................. 100 4.4 Clases utilizadas como Parámetros.............................................................................. 104 4.4.1 Código ..................................................................................................................... 105 4.4.2 Resultados............................................................................................................... 109 4.5 Propiedades y métodos de clase y de instancia ......................................................... 109 4.5.1 Propiedades de instancia ...................................................................................... 109 4.5.2 Propiedades de clase............................................................................................. 111 4.5.3 Métodos de instancia ............................................................................................ 113 4.5.4 Métodos de clase................................................................................................... 113 4.5.5 Ejemplo que utiliza propiedades de clase......................................................... 115 4.5.6 Código del ejemplo ............................................................................................... 116 4.5.7 Resultados............................................................................................................... 120 4.6 Paquetes y atributos de acceso..................................................................................... 120 4.6.1 Definición de paquetes ......................................................................................... 121 4.6.2 Utilización de las clases de un paquete.............................................................. 122 4.6.3 Proceso de compilación cuando se utilizan paquetes ...................................... 123 4.6.4 Atributos de acceso a los miembros (propiedades y métodos) de una clase124 4.7 Ejemplo: máquina expendedora .................................................................................. 125CAPÍTULO 5: PROGRAMACIÓN ORIENTADA A OBJETOS USANDO HERENCIA.............................................. 137 5.1 Herencia............................................................................................................................ 137 5.1.1 Funcionamiento básico......................................................................................... 137 5.1.2 Accesibilidad a los miembros heredados en una subclase............................. 140 5.1.3 Constructores de las subclases ............................................................................ 141 5.1.4 El modificador final.............................................................................................. 145 5.2 Ejemplos........................................................................................................................... 146 8.
X JAVA A TRAVÉS DE EJEMPLOS © JESÚS BOBADILLA SANCHO (jbobi@eui.upm.es) 5.2.1 Figuras geométricas .............................................................................................. 146 5.2.2 Vehículos................................................................................................................ 150 5.3 Polimorfismo ................................................................................................................... 155 5.3.1 Conceptos............................................................................................................... 155 5.3.2 Ejemplo ................................................................................................................... 157 5.4 Clases abstractas e interfaces........................................................................................ 160 5.4.1 Métodos abstractos................................................................................................ 160 5.4.2 Clases abstractas .................................................................................................... 161 5.4.3 Interfaces................................................................................................................. 164 5.4.4 Ejercicio ................................................................................................................... 167CAPÍTULO 6: EXCEPCIONES ........................................................ 171 6.1 Excepciones predefinidas .............................................................................................. 171 6.1.1 Introducción ........................................................................................................... 171 6.1.2 Sintaxis y funcionamiento con una sola excepción ......................................... 174 6.1.3 Ejemplo con una sola excepción......................................................................... 176 6.1.4 Sintaxis y funcionamiento con más de una excepción .................................... 177 6.1.5 El bloque finally .................................................................................................... 180 6.1.6 Propagación de excepciones................................................................................ 180 6.1.7 Estado de una excepción ...................................................................................... 182 6.2 Excepciones definidas por el programador ................................................................ 184 6.2.1 Introducción ........................................................................................................... 184 6.2.2 Definición de una excepción definida por el programador............................ 185 6.2.3 Utilización de una excepción definida por el programador ........................... 186 6.2.4 Ejemplo ................................................................................................................... 187CAPÍTULO 7: INTERFAZ GRÁFICO DE USUARIO .................. 193 7.1 Creación de ventanas...................................................................................................... 193 7.1.1 Introducción ........................................................................................................... 193 7.1.2 Utilización de la clase Frame .............................................................................. 195 7.1.3 Creación y posicionamiento de múltiples ventanas........................................ 196 7.2 Paneles y objetos de disposición (layouts)................................................................. 199 7.2.1 Introducción ........................................................................................................... 199 7.2.2 Utilización básica de paneles .............................................................................. 202 7.2.3 Objeto de disposición (Layout): FlowLayout................................................... 203 7.2.4 Objeto de disposición (Layout): BorderLayout ............................................... 205 7.2.5 Objeto de disposición (Layout): GridLayout.................................................... 208 7.3 Etiquetas, campos y áreas de texto .............................................................................. 211 7.3.1 Introducción ........................................................................................................... 211 7.3.2 Etiqueta (Label) ..................................................................................................... 211 7.3.3 Campo de texto (TextField)................................................................................. 215 7.3.4 Área de texto (TextArea)..................................................................................... 218 7.3.5 Fuentes (Font)........................................................................................................ 219 9.
© JESÚS BOBADILLA SANCHO (jbobi@eui.upm.es) ÍNDICE XI 7.4 Cajas de verificación, botones de radio y listas......................................................... 221 7.4.1 Introducción ........................................................................................................... 221 7.4.2 Cajas de verificación (Checkbox) ....................................................................... 221 7.4.3 Botones de radio (CheckboxGroup)................................................................... 223 7.4.4 Lista (List).............................................................................................................. 226 7.4.5 Lista desplegable (Choice)................................................................................... 229 7.5 Diseño de formularios.................................................................................................... 230 7.5.1 Diseño del interfaz gráfico deseado................................................................... 230 7.5.2 Implementación en una sola clase...................................................................... 232 7.5.3 Implementación en varias clases......................................................................... 235 7.6 Diálogos y menús ........................................................................................................... 240 7.6.1 Introducción ........................................................................................................... 240 7.6.2 Diálogo (Dialog).................................................................................................... 241 7.6.3 Diálogo de carga / almacenamiento de ficheros (FileDialog) ....................... 243 7.6.4 Menús (Menu y MenuBar) .................................................................................. 245CAPÍTULO 8: EVENTOS .................................................................. 247 8.1 Mecanismo de eventos en java..................................................................................... 247 8.1 Introducción............................................................................................................... 247 8.2 Arquitectura de los eventos..................................................................................... 248 8.3 Interfaces que soportan el mecanismo de eventos.............................................. 250 8.4 Esquema general de programación........................................................................ 253 8.2 Eventos de ratón y de movimiento de ratón............................................................... 257 8.2.1 Introducción ........................................................................................................... 257 8.2.2 Eventos de ratón.................................................................................................... 259 8.2.3 Eventos de movimiento de ratón ........................................................................ 267 8.3 Eventos de teclado y de ventana.................................................................................. 272 8.3.1 Introducción ........................................................................................................... 272 8.3.2 Eventos de teclado................................................................................................. 274 8.3.3 Eventos de ventana................................................................................................ 276 8.4 Eventos de acción, enfoque y elemento...................................................................... 278 8.4.1 Introducción ........................................................................................................... 278 8.4.2 Eventos de acción.................................................................................................. 280 8.4.3 Eventos de enfoque............................................................................................... 284 8.4.4 Eventos de elemento............................................................................................. 287CAPÍTULO 9: APLICACIONES DE EJEMPLO ........................... 293 9.1 Ejemplo: calculadora ...................................................................................................... 293 9.1.1 Definición del ejemplo ......................................................................................... 293 9.1.2 Diseño del interfaz gráfico de usuario ............................................................... 294 9.1.3 Implementación del interfaz gráfico de usuario ............................................... 296 9.1.4 Diseño del tratamiento de eventos...................................................................... 300 9.1.5 Implementación de las clases de tratamiento de eventos................................ 302 10.
XII JAVA A TRAVÉS DE EJEMPLOS © JESÚS BOBADILLA SANCHO (jbobi@eui.upm.es) 9.1.6 Diseño del control................................................................................................. 305 9.1.7 Implementación del control................................................................................. 307 9.2 Ejemp lo: editor................................................................................................................ 316 9.2.1 Definición del ejemplo ......................................................................................... 316 9.2.2 Estructura de la aplicación................................................................................... 318 9.2.3 Propiedades de la clase......................................................................................... 321 9.2.4 Constructores.......................................................................................................... 322 9.2.5 Método PreparaMenus.......................................................................................... 324 9.2.6 Método PreparaZonaInferior............................................................................... 325 9.2.7 Clase Colores ......................................................................................................... 325 9.2.8 Tratamiento de las opciones de menú................................................................ 327 9.2.9 Tratamiento de las opciones “Buscar” y “Reemplazar” ................................. 329 9.2.10 Tratamiento de los botones de radio “Color texto” y “Color fondo”......... 331 9.2.11 Tratamiento a las pulsaciones de los botones de colores............................. 331APÉNDICESA: CUESTIONES DE AUTOEVALUACIÓN .................................. 333B: SOLUCIONES A LAS CUESTIONES DE AUTOEVALUACIÓN ............................................................................................ .............. 359ÍNDICE ALFABÉTICO ............................................................. ....... 361 11.
CAPÍTULO 1 TOMA DE CONTACTO, VARIABLES, TIPOS DE DATOS Y OPERADORES1.1 INSTALACIÓN DEL ENTORNO DE DESARROLLO Para poder realizar programas en lenguaje Java es necesario disponer de unmínimo de herramientas que nos permitan editar, compilar e interpretar el códigoque diseñamos. Para escribir físicamente los programas podemos utilizar cualquiereditor de texto (por ejemplo el bloc de notas, el WordPad, etc.). Para compilar yejecutar los programas existen dos opciones: • Utilizar un entorno integrado de desarrollo (por ejemplo JBuilder de Borland, Visual J++ de Microsoft, etc.) • Emplear el software básico de desarrollo (SDK) de Sun Microsystems La primera opción resulta especialmente interesante para afrontar la creaciónde aplicaciones de manera eficiente, puesto que estos entornos facilitanenormemente el diseño, escritura y depuración de los programas. La segunda opciónes mucho más adecuada para aprender a programar en Java, porque no existe lageneración automática de código que incorporan los entornos integrados dedesarrollo. El SDK de Sun Microsystems puede ser obtenido de forma gratuita (es unsoftware de libre distribución) en la dirección www.sun.com; una vez que se disponedel fichero con el SDK (por ejemplo j2sdk-1_4_0-win.exe) basta con ejecutarlo paraconseguir que el software se instale en su ordenador. En primer lugar se descomprime automáticamente la información: 12.
2 JAVA A TRAVÉS DE EJEMPLOS © JESÚS BOBADILLA SANCHO (JBOBI@EUI.UPM.ES) Por defecto, el software se instalará a partir de un directorio cuyo nombretiene que ver con la versión del SDK (en este caso j2sdk1.4.0), aunque siemprepuede elegirse una ubicación personalizada (con la opción Browse). La propia instalación rellenará la variable de entorno CLASSPATH con losvalores adecuados (donde el entorno debe buscar los ficheros compilados .class). Lavariable de entorno PATH la deberemos actualizar para que el sistema operativoencuentre los ficheros ejecutables del SDK, que en nuestro caso están ubicados en eldirectorio c:j2sdk1.4.0bin (suponiendo que hemos realizado la instalación sobre eldisco c: y el directorio j2sdk1.4.0). Para asegurarse de que la variable CLASSPATH se encuentra correctamenteestablecida, podemos consultar su valor de la siguiente manera: 13.
© BOBADILLA CAPÍTULO 1: CONCEPTOS BÁSICOS, VARIABLES, TIPOS DE DATOS Y OPERADORES 3 Sun Microsystems proporciona, además, ayuda en línea sobre lascaracterísticas del lenguaje y las clases más comunes para el desarrollo deaplicaciones. Escribiendo programas en Java resulta necesario instalar esta ayudapara poder consultar los métodos y clases disponibles. La ayuda puede ser obtenidaen Internet a través del sitio Web de Sun (www.sun.com). Una vez instalada, seaccede a ella a través de su página principal (index.html).Para escribir programas enJava, el enlace más importante de esta página es: Java 2 Platform API Specification,correspondiente al apartado API & Language Documentation. El software de desarrollo SDK funciona en modo texto sobre una ventana deconsola del sistema operativo. En Windows, para acceder a la consola se debe pulsarsobre el símbolo de MS-DOS (habitualmente accesible a través del botón de Inicio).Una vez en la consola, dirigirse al directorio de trabajo (en el ejemploC:CursoJavaIntroducción), tal y como aparece en la siguiente figura: Podemos configurar la consola en cuanto al tamaño con el que aparece,memoria que utiliza, fuentes que emplea, etc. Para realizar esta configuración bastacon acceder al símbolo de MS-DOS y, en lugar de pulsar con el botón izquierdo delratón, hacerlo con el derecho y seleccionar Propiedades. 14.
4 JAVA A TRAVÉS DE EJEMPLOS © JESÚS BOBADILLA SANCHO (JBOBI@EUI.UPM.ES) En concreto, nos interesa seleccionar la solapa Programa y variar el valordel campo de texto Carpeta de trabajo, introduciendo el directorio sobre el quesolemos trabajar, con ello conseguimos que la consola se abra directamente en esedirectorio. En nuestro ejemplo, hemos introducido el valorC:CursoJavaIntroducción. Como veremos en el siguiente apartado, el fichero javac.exe es elcompilador de java. Se encuentra en el directorio c:j2sdk1.4.0bin (hacia dondehemos apuntado la variable PATH). Si todo se encuentra correctamente al invocar elcompilador sin parámetros nos indica la forma de uso correcta, tal y como apareceen la siguiente figura: 15.
© BOBADILLA CAPÍTULO 1: CONCEPTOS BÁSICOS, VARIABLES, TIPOS DE DATOS Y OPERADORES 51.2 PRIMER PROGRAMA EN JAVA: “HOLA MUNDO” El aprendizaje de todo lenguaje de programación pasa por la etapaobligatoria de realizar un primer programa, lo más sencillo posible, que muestre: • La estructura sintáctica mínima a la que obliga el lenguaje • La manera de introducir, traducir y ejecutar el programa • La validez del entorno en el que se sustentarán los desarrollos (para nosotros el SDK) Nuestro programa únicamente escribirá el texto “Hola mundo”, pero servirápara asentar cada uno de los puntos expuestos en el párrafo anterior. Pasos detallados: 1 Abrir un editor de texto (por ejemplo el WordPad) Habitualmente a través del botón de Inicio: (Inicio → Programas → Accesorios → WordPad). 2 Introducir el código (sin incluir los números de línea):1 public class HolaMundo {2 public static void main (String[] args) {3 System.out.println("Hola Mundo");4 }5 } Es necesario respetar la condición mayúscula/minúscula de cada letra del programa, puesto que en este lenguaje una letra en minúscula es diferente a su correspondiente en mayúsculas. La línea 1 define la clase (objeto) HolaMundo. Java es un lenguaje orientado a objetos, donde toda las aplicaciones se estructuran en grupos de objetos (clases en Java). La clase se define como public (publica), indicando que será accesible a cualquie r otra clase. El último carácter de la línea 1 es una llave de comienzo; indica el comienzo de la clase. La clase termina en la línea 5 (con la llave de fin). La línea 2 define un método (procedimiento, subrutina) de la clase HolaMundo. Este método es espe cial, le indica al entorno de Java el comienzo de nuestra aplicación. Su nombre (identificador) es: main (método principal). Este método siempre lleva un parámetro String[] que identifica un conjunto de literales (textos); por ahora no emplearemos esta característica, aunque debemos respetar su sintaxis. El método es público y estático (atributos que veremos en detalle en los temas siguientes). El contenido del método main, en nuestro ejemplo, se encuentra delimitado entre la llave de inicio situada en la línea 2 y la llave de fin 16.
6 JAVA A TRAVÉS DE EJEMPLOS © JESÚS BOBADILLA SANCHO (JBOBI@EUI.UPM.ES) situada en la línea 4. Únicamente contiene la instrucción situada en la línea 3, que imprime el literal (texto) que aparece entre comillas y como parámetro de la llamada al método println. Obsérvese el carácter ‘;’ que se debe utilizar obligatoriamente para separar instrucciones. El sangrado de cada una de las líneas no es necesario, pero resulta muy conveniente para hacer más legible los programas. Su función principal es facilitar la identificación visual de cada bloque de código. 3 Grabar el código en el fichero HolaMundo.java y con formato de texto Es absolutamente necesario que la extensión sea .java, que el fichero este grabado con formato de texto y que el nombre de la clase coincida EXACTAMENTE con el nombre del fic hero (en nuestro caso HolaMundo). Finalmente, en el WordPad nos quedará una ventana similar a la siguiente: 4 Compilar el programa En la ventana de MS-DOS, en el directorio donde hemos grabado el fichero HolaMundo.java, debemos ejecutar el compilador (javac) poniendo como argumento el nombre del fichero CON LA EXTENSIÓN .java (javac HolaMundo.java). Si existen errores, se obtendrá un listado de los mismos. Si no los hay, como en nuestro caso, no aparece nada: 17.
© BOBADILLA CAPÍTULO 1: CONCEPTOS BÁSICOS, VARIABLES, TIPOS DE DATOS Y OPERADORES 7 Tras la compilación con éxito del programa, obtenemos el fichero objeto HolaMundo.class: 5 Ejecutar el programa En el directorio en el que estamos trabajando, ejecutar el intérprete de java (java) suministrando como parámetro el nombre de la clase (HolaMundo) SIN la extensión .class (java HolaMundo). Nos aparecerá el texto “Hola Mundo” correspondiente a la impresión de datos por consola que codificamos en la línea 3 de nuestro programa:1.3 VARIABLES Y TIPOS DE DATOS1.3.1 Variables Las variables se utilizan para almacenar datos asociados a nombres. Cadavariable tiene un nombre que sirve de referencia para introducir datos o acceder a los 18.
8 JAVA A TRAVÉS DE EJEMPLOS © JESÚS BOBADILLA SANCHO (JBOBI@EUI.UPM.ES)mismos. Un ejemplo de utilización de variable es: Edad_Pedro = 23; en este caso,introducimos el valor numérico 23 en la variable con nombre Edad_Pedro. A partirde ahora podemos utilizar la variable a través de su nombre (Edad_Pedro) parareferirnos a su valor (23), por ejemplo estableciendo Edad_Ana = Edad_Pedro – 2;donde Ana podría ser la hermana pequeña de Pedro, que es dos años más joven queél. Los nombres de las variables, en Java, pueden tener cualquier longitud ydeben comenzar con una letra, el símbolo de subrayado “_” o el dólar “$”. El restode los caracteres del nombre pueden ser cualquiera, salvo los que pueden dar lugar aconfusión, como los operadores (+,-,*,etc.). Por ejemplo, sería correcto el nombreMiAmigoMasQuerido, pero no el nombre MiAmigo+Querido, puesto que en esteúltimo caso el compilador interpretaría que hay que sumar el contenido de lavariable MiAmigo con el contenido de la variable Querido. Los nombres de variables no deben tener espacios en blanco, puesto que elcompilador identificaría más de una variable; por ejemplo, NumeroDeAciertos es unnombre de variable correcto, sin embargo Numero De Aciertos no lo es, porque elcompilador identificaría tres variables diferentes: Numero, De y Aciertos. Por último, los nombres de variables no deben coincidir con palabrasreservadas (tales como public, static, class, void , main, etc.), puesto que estosidentificadores tienen un significado especial para el compilador. En Java, los identificadores de variables suelen definirse empezando por uncarácter en minúscula, por ejemplo contador. Si en el identificador existe más deuna palabra, los comienzos del resto de las palabras se ponen con mayúsculas,ejemplo: contadorDeAciertos. En este curso seguiremos una notación parecida,aunque no idéntica; comenzaremos todas las palabras con mayúsculas:ContadorDeAciertos. Para asentar los conceptos expresados en este apartado, veamos una serie decasos de identificadores de variables correctos e incorrectos: LaCasaDeLaPradera → identificador correcto El Hombre Sin Rostro → identificador incorrecto, no debe existir ningún espacio en blanco en un nombre de variable 3Deseos → identificador incorrecto, el nombre no empieza por una letra (sino por un número) TresDeseos → identificador correcto _4 → identificador correcto $ → identificador correcto 19.
© BOBADILLA CAPÍTULO 1: CONCEPTOS BÁSICOS, VARIABLES, TIPOS DE DATOS Y OPERADORES 9 $Ganado → identificador correcto public → identificador incorrecto, public es un nombre reservado por el lenguaje Los identificadores deben intentar ser representativos de los datos quealbergan, de esta manera ValorAcumulado, NumeroAlumnos, CantidadEuros, Edad,Potencia son variables que determinan de forma adecuada el significado de suscontenidos, mientras que los nombres Variable, Valor, V1, V2 , no sonrepresentativos de sus contenidos. La longitud de los identificadores no debe ser excesivamente larga, para nodificultar la legibilidad de las instrucciones, por ejemplo resulta mucho más legibleStock = LibrosEditados – LibrosVendidos, que StockTotalDeLibrosEnAlmacen =LibrosEditadosEnElAñoEnCurso – LibrosVendidosYSacadosDelAlmacen. Los identificadores en mayúsculas se suelen reservar para nombres(normalmente cortos) de constantes, de esta manera las instrucciones (basadasmayoritariamente en operaciones con variables) son más legibles, al utilizarseminúsculas. Compárese Stock = LibrosEditados – LibrosVendidos con STOCK =LIBROSEDITADOS – LIBROSVENDIDOS.1.3.2 Tipos de datos Las variables albergan datos de diferentes tipos (numérico decimal,numérico entero, caracteres, etc.). Para indicar el tipo de dato que contendrán lasvariables debemos “declarar” las mismas, indicando sus tipos. Este mecanismopermite que el traductor (compilador) realice comprobaciones estáticas de validez,como por ejemplo que no empleamos en el programa una variable que no ha sidodeclarada, que no asignemos un carácter a una variable de tipo numérico, que nosumemos un carácter a un valor numérico, etc. A continuación se establece una relación de los tipos de datos primitivos(los que proporciona el lenguaje): TIPOS PRIMITIVOS Nombre del tipo Tamaño en bytes Rango Tipos numéricos enteros byte 1 -128 a 127 20.
10 JAVA A TRAVÉS DE EJEMPLOS © JESÚS BOBADILLA SANCHO (JBOBI@EUI.UPM.ES) short 2 -32768 a 32767 int 4 -231 a 231 long 8 -263 a 263 Tipos numéricos decimales float 4 -3.4x1038 a 3.4x1038 double 8 -1.7x10308 a 1.7x10308 Tipo carácter char 2 Conjunto de caracteres Tipo lógico (booleano) boolean 1 true, false Para declarar una va riable se emplea la sintaxis: tipo identificador; tipo identificador [=valor]; tipo identificador1,identificador2,identificador3,etc.; tipo identificador1 = valor1,identificador2 = valor2, etc.; Por ejemplo: byte EdadPedro = 60; short SueldoMensual; float PrecioEnEuros, Cateto1, Cateto2, Hipotenusa; boolean Adquirido = false, Finalizado = true;1.3.3 Tipos numéricos enteros A continuación se proporcionan diversos programas comentados quemuestran la manera de utilizar los tipos numéricos enteros: En el primer ejemplo TiposNumericos1, se declaran las variables de tipobyte EdadJuan y EdadPedro (líneas 3 y 4) y las variables de tipo short SueldoBase yComplementos (líneas 6 y 7). La línea 9 muestra, a modo de ejemplo, el valor deSueldoBase, que es 1980. Obsérvese que se ha seleccionado el tipo byte para albergar edades, por loque asumimos que nunca tendremos que introducir un valor superior a 127; delmismo modo empleamos el tipo short para contener sueldos (en euros), por lo queno podremos pasar de 32767, lo que puede ser válido si nos referimos a sueldos 21.
© BOBADILLA CAPÍTULO 1: CONCEPTOS BÁSICOS, VARIABLES, TIPOS DE DATOS Y OPERADORES 11mensuales. Si estamos indicando sueldos anuales, sería conveniente pasar alsiguiente tipo en tamaño (int).1 public class TiposEnteros1 {2 public static void main (String[] args) {3 byte EdadJuan = 20;4 byte EdadPedro = 22;56 short SueldoBase = 1980;7 short Complementos = 400;89 System.out.println(SueldoBase);10 }11 } Si al inicializar el valor de una variable nos pasamos en el rango permitido,el compilador nos dará un error, indicándonos el tipo que deberíamos emplear: En el siguiente ejemplo TiposEnteros2 se define una variable de tipo entero(int) y otra de tipo entero largo (long), cada una de ellas con valores adecuados altipo de datos que representan. Es importante saber que los valores numéricos enterosno pueden ser representados con puntos (ejemplo 4.000.000 en lugar de 4000000),puesto que se confundirían con valores numéricos decimales. En la línea 4 del ejemplo, se define el valor 5000000000L acabado en laletra L. Esta letra indica que el valor debe ser tomado como long antes de serasignado a la variable. Si no ponemos esta indicación, el valor numérico se tomacomo int (por defecto) y el compilador muestra un error indicando que el número esdemasiado grande para pertenecer a este tipo.1 public class TiposEnteros2 {2 public static void main (String[] args) {3 int HabitantesEnMadrid = 4000000;4 long HabitantesEnElMundo = 5000000000L;56 System.out.println(HabitantesEnElMundo); 22.
12 JAVA A TRAVÉS DE EJEMPLOS © JESÚS BOBADILLA SANCHO (JBOBI@EUI.UPM.ES)7 }8 }1.3.4 Tipos numéricos decimales Existe una gran cantidad de valores numéricos que, por su naturaleza,requieren la utilización de decimales; Java proporciona los tipos de datos float ydouble para albergar este tipo de valores. Como ejemplos de valores que requierendecimales podemos establecer: el precio en euros (con centimos) de un artículo, elpeso en kilos (con precisión de gramos) de una persona, la medida en metros (conprecisión de centímetros) de un objeto, etc. El siguiente ejemplo (TiposDecimales) muestra la manera d declarar y eutilizar variables de tipo float y double. En las líneas 3 y 4 establecemos el precio deuna pieza de pan en 0.87 euros y el del kilo de queso en 1.93 euros; la letra “f” conla que terminamos las declaraciones le indica al compilador que los literalesnuméricos (0.87 y 1.93) son de tipo float, si no pusiéramos esta indicación, elcompilador los tomaría (por defecto) como de tipo double , con lo que la asignaciónfloat = double resultaría fallida. En la línea de código 6 introducimos en la variable $Bocadillo el precio deun bocadillo que contiene 150 gramos de queso. Las líneas 8 y 9 muestran la manera de definir e inicializar variables quecontienen números realmente grandes (6 elevado a 100) y números realmentepequeños (2.45 elevado a –95), para estos casos utilizamos el tipo double.1 public class TiposDecimales {2 public static void main (String[] args) {3 float $PiezaPan = 0.87f;4 float $KiloQueso = 1.93f;56 float $Bocadillo = $PiezaPan + $KiloQueso * 0.15f;78 double NumeroHormigas = 6E+100;9 double DistanciaSubAtomica = 2.45E-95;1011 System.out.println($Bocadillo);12 }13 } 23.
© BOBADILLA CAPÍTULO 1: CONCEPTOS BÁSICOS, VARIABLES, TIPOS DE DATOS Y OPERADORES 131.3.5 Tipo booleano El tipo de datos lógico (booleano) nos permite declarar y definir variablescuyo contenido es binario. Sus únicos valores posibles son true (verdadero) y false(falso). Estas variables resultan especialmente útiles para definir condiciones lógicasaplicables al control de flujo de los programas, por ejemplo: si (Encontrado) haceruna cosa, en caso contrario hacer otra, siendo Encontrado una variable de tipoboolean que se modifica a lo largo del programa. En el siguiente ejemplo (TipoBooleano) se utilizan diversas variables de estetipo. En la línea 3 se definen e inicializan (a true y false) dos variables booleanas. Enla línea 5 se establece el contenido de una variable Triste como el contrario (negado)de la variable Contento , para ello se emplea el operador ! que detallaremos másadelante.1 public class TipoBooleano {2 public static void main (String[] args) {3 boolean Contento = true, MenorDeEdad = false;45 boolean Triste = !Contento;67 System.out.println(Triste);8 }9 } 24.
14 JAVA A TRAVÉS DE EJEMPLOS © JESÚS BOBADILLA SANCHO (JBOBI@EUI.UPM.ES)1.3.6 Tipo carácter En Java tenemos la posibilidad de utilizar variables de tipo carácter, capacesde contener, cada variable, un carácter (‘A’, ‘B’, ‘a’, ‘*‘, ‘8’, etc.). En la línea 2 dela clase TipoCaracter se declaran las variables AMayuscula y AMinuscula , en dondeintroducimos los valores ‘A’ y ‘a’. La línea 4 define la variable Bmayuscula , introduciendo el valor siguiente alde Amayuscula, para ello hay que realizar una conversión de tipos que nos sirve parailustrar los conceptos que justamente se explican en el apartado siguiente. En la línea6 se imprime una nueva línea y en la 7 el carácter ‘B’.1 public class TipoCaracter {2 public static void main (String[] args) {3 char AMayuscula = A, AMinuscula = a;4 char BMayuscula = (char) (AMayuscula + 1);56 System.out.println(n);7 System.out.println(BMayuscula);8 }9 } También existe la posibilidad de utilizar caracteres que no podemosconseguir con facilidad en nuestro teclado, para ello se utiliza la secuencia de“escape”: . Podemos, de esta manera, definir cualquier carácter de codificación“unicode” (codificación más extensa que ASCII) de la siguiente manera: ‘uxxxx’,donde las equis se sustituyen por el valor numérico en hexadecimal del carácter. Porejemplo ‘u0041’ se corresponde con la A mayúscula. Otros caracteres especiales son: b espacio hacia atrás n nueva línea r retorno de carro t tabulador 25.
© BOBADILLA CAPÍTULO 1: CONCEPTOS BÁSICOS, VARIABLES, TIPOS DE DATOS Y OPERADORES 151.3.7 Conversión explícita de tipos (Casting) Resulta muy habitual que en los programas nos encontremos con lanecesidad de mezclar tipos de datos, por ejemplo al trabajar con una bibliotecamatemática que obliga a utilizar tipos de datos double , cuando nosotros las variableslas tenemos de tipo float; o más sencillo todavía, al intentar sumar un 1 (por defectoint) a una variable de tipo short. Java, en algunos casos, realiza una conversiónimplícita de datos, sin embargo, por regla general, nos veremos obligados aprogramar conversiones explícitas de tipos. Para modificar el tipo de un valor, basta con indicar el nuevo tipo entreparéntesis antes del valor, por ejemplo: (byte ) 1 → convierte el 1 (int) a byte (double) MiVariableDeTipoFloat → convierte a double una variable de tipo float (short) (VariableDeTipoByte + VariableDeTipoByte) → convierte a short el resultado de sumar dos variables de tipo byte. Obsérvese que al sumarse dos variables de tipo byte, el resultado puede que no “quepa” en otra variable de tipo byte. En el ejemplo siguiente: Casting, se realizan dos conversiones explícitas detipo: la primera en la línea 4, donde al sumarse EdadJuan (byte) a 1 (int) el resultadoes int y por lo tanto lo debemos convertir al tipo de la variable EdadPedro (byte ); eneste caso debemos estar muy seguros de que EdadJuan es distinto a 127 (límite deltipo byte). En la línea 11 convertimos a short, debido a que la operación de sumatrabaja con el tipo (int) y por lo tanto realiza una conversión implícita de short a inten las variables SueldoBase y Complementos. El casting que realizamos nosconvierte de int (resultado de la suma) a short (tipo de la variable SueldoTotal).1 public class Casting {2 public static void main (String[] args) {3 byte EdadJuan = 20;4 byte EdadPedro = (byte) (EdadJuan + 1);56 short SueldoBase = 1980;7 short Complementos = 400;89 short SueldoTotal;1011 SueldoTotal = (short) (SueldoBase + Complementos);1213 System.out.println(SueldoTotal);14 }15 } 26.
16 JAVA A TRAVÉS DE EJEMPLOS © JESÚS BOBADILLA SANCHO (JBOBI@EUI.UPM.ES) A menudo, en los programas escritos en Java se utiliza intensivamente eltipo int, cuando, en principio, sería más adecuado hacer uso de otros tipos que seajusten mejor en tamaño a la naturaleza de los datos. La razón es evitar operacionesde conversión explicita de tipos.1.4 OPERADORES1.4.1 Introducción Los operadores nos permiten realizar operaciones sobre los operandosestudiados en el apartado anterior. Existen operadores unarios y binarios; un ejemplode operador unario que ya hemos utilizado es la negación lógica (!), lo vimos alexplicar el tipo de datos booleano y lo empleamos en la instrucción: boolean Triste= !Contento; donde el operador negación se aplica a un único operando (la variableContento). El ejemplo de operador binario que más hemos utilizado es la suma, quese aplica sobre dos operandos. Los operadores tienen unas reglas de precedencia que resulta importantetener en cuenta. En el apartado anterior, calculábamos el precio de un bocadillo de lasiguiente manera: float $Bocadillo = $PiezaPan + $KiloQueso * 0.15f; en estecaso utilizamos dos operadores binarios: la suma (+) y la multiplicación (*). Eloperador de multiplicación tiene mayor precedencia que el de suma, por lo que, deforma correcta, primero se obtiene el precio del queso y luego se realiza la suma delpan más el queso. Si el operador de suma se hubiera aplicado primero, se habríasumado $PiezaPan + $KiloQueso y, posteriormente, el resultado se habríamultiplicado por 0.15f, lo que nos proporcionaría un resultado incorrecto. Cuandoexisten varios operadores con la misma precedencia, se aplican de izquierda aderecha. La precedencia de los operadores se puede variar usando los paréntesis. Lasoperaciones que se encuentren entre paréntesis se realizan primero. En el ejemplodel bocadillo, si suponemos que ya contábamos con 0.1f kilos de queso, el nuevoprecio lo podemos obtener de la siguiente manera: float $Bocadillo = $PiezaPan +$KiloQueso * (0.15f-0.1f); primero se realizará la resta, después la multiplicación ypor último la suma. Los operadores pueden ser clasificados atendiendo al tipo de operandossobre los que actúan, de esta manera realizaremos una breve descripción de losoperadores aritméticos, lógicos y de comparación, obviando a los operadores de bitsque se utilizan con muy poca frecuencia. 27.
© BOBADILLA CAPÍTULO 1: CONCEPTOS BÁSICOS, VARIABLES, TIPOS DE DATOS Y OPERADORES 171.4.2 Operadores aritméticos Los operadores aritméticos más comunes son la suma (+) , resta (-),multiplicación (*) y división (/) binarios, aunque también se utilizan los operadoresunarios (+) y (-), y el operador binario que obtiene el módulo de una división (%).Finalmente, disponemos de operadores aritméticos de preincremento,postincremento, predecremento y postdecremento, que permiten acortar el tamañode ciertas instrucciones y facilitar la optimización de código por parte delcompilador. Operación sintaxis significado Preincremento ++Variable; Variable = Variable + 1; (antes de asignación) Postincremento Variable++; Variable = Variable + 1; (después de asignación) Predecremento --Variable; Variable = Variable – 1; (antes de asignación) Postdecremento Variable--; Variable = Variable – 1; (después de asignación) Para ilustrar los conceptos expuestos se proporciona la claseOperadoresAritmeticos. La línea 3 hace uso de la multiplicación y suma binarios,con resultado 7.2, mostrado en la línea 16. En la línea 4, primero actúa el operadorunario (-), después el operador binario (/) y por último la suma; el resultado,mostrado en la línea 17 es –2. Las líneas de código 5 y 6 muestran, respectivamente,la división y resto enteros, obteniéndose resultados 5 y 1 en las líneas 18 y 19. Las líneas 8 a 14 del código utilizan los operadores de pre/postincremento/decremento. A la variable PostIncremento de la línea 8 se le asigna elvalor 9, debido a que primero se realiza la asignación PostIncremento = Nueve yposteriormente la operación de postincremento. La variable PreIncremento (en lalínea 10) albergará el valor 10, puesto que primero se realiza el preincremento ydespués la asignación. Como cabe esperar, la variable PostDecremento recibe elvalor 9 y la variable PreDecremento el valor 8.1 public class OperadoresAritmeticos {2 public static void main (String[] args) {3 float Impuesto = 2.2f * 1.0f + 5.0f;4 int Impuesto2 = -8 + 12 / 2;5 int Cociente = 16 / 3;6 int Resto = 16 % 3;7 int Nueve = 9;8 int PostIncremento = Nueve++;9 Nueve = 9;10 int PreIncremento = ++Nueve;11 Nueve = 9;12 int PostDecremento = Nueve--;13 Nueve = 9;14 int PreDecremento = --Nueve;15 28.
18 JAVA A TRAVÉS DE EJEMPLOS © JESÚS BOBADILLA SANCHO (JBOBI@EUI.UPM.ES)16 System.out.println(Impuesto);17 System.out.println(Impuesto2);18 System.out.println(Cociente);19 System.out.println(Resto);20 System.out.println(PostIncremento);21 System.out.println(PreIncremento);22 System.out.println(PostDecremento);23 System.out.println(PreDecremento);24 }25 }1.4.3 Operadores lógicos Los operadores lógicos nos permiten combinar operandos booleanos,obteniendo, así mismo, resultados booleanos. Los operandos lógicos y sussignificados son: Operador Sintaxis Ejemplo Funcionamiento Negación ! Calor = !Frio ! false true true false Y && Oportunidad = Bueno && && false true Bonito && Barato false 0 0 true 0 1 O || Mojado = Llueve || Riego || false true false 0 1 true 1 1 En la clase OperadoresLogicos se programan las operaciones incluidas en lacolumna “Ejemplo” de la tabla anterior. El resultado en todos los casos es: true.1 public class OperadoresLogicos {2 public static void main (String[] args) {3 boolean Calor, Frio = false, Oportunidad, Bueno = true,4 Bonito = true, Barato = true, Llueve = true, 29.
© BOBADILLA CAPÍTULO 1: CONCEPTOS BÁSICOS, VARIABLES, TIPOS DE DATOS Y OPERADORES 195 Riego = false;67 Oportunidad = Bueno && Bonito && Barato;89 System.out.println(!Frio);10 System.out.println(Oportunidad);11 System.out.println(Llueve || Riego);12 }13 }1.4.4 Operadores de comparación Los operadores de comparación se utilizan frecuentemente para dirigir laevolución del flujo de control en los programas. A continuación se proporciona unatabla en la que se definen estos operadores: Operador Sintaxis Ejemplo Menor < (EdadJuan < 18) Menor o igual <= (EdadJuan <= EdadPedro) Mayor > (Hipotenusa > 8.0f * 6.2f + 5.7f) Mayor o igual >= (Cateto1 >= Cateto2) Igual == (Contador == 8) Distinto != (Contador != 8) Instancia de instanceof (Valor instanceof float) El operador instanceof nos indica si una variable pertenece un tipo dado(siendo el tipo una clase o array). Las clases y arrays se explicarán más adelante.Enel ejemplo siguiente se hace uso de las comparaciones mostradas en la tabla. Todoslos resultados que se muestran en las líneas 6 a 11 son true, salvo la 10 que es false.1 public class OperadoresComparacion {2 public static void main (String[] args) {3 int EdadJuan = 6, EdadPedro = 21, Contador = 14;4 float Hipotenusa = 105.6f, Cateto1 = 13.2f,5 Cateto2 = 5.7f;67 System.out.println(EdadJuan < 18);8 System.out.println(EdadJuan <= EdadPedro);9 System.out.println(Hipotenusa > 8.0f * 6.2f + 5.7f);10 System.out.println(Cateto1 >= Cateto2);11 System.out.println(Contador == 8);12 System.out.println(Contador != 8);1314 }15 } 30.
20 JAVA A TRAVÉS DE EJEMPLOS © JESÚS BOBADILLA SANCHO (JBOBI@EUI.UPM.ES) 31.
CAPÍTULO 2 ESTRUCTURAS DE CONTROL2.1 EL BUCLE FOR Hasta ahora, todos los programas que hemos visto son estrictamentesecuenciales, es decir, a la ejecución de una instrucción inexorablemente le sigue laejecución de la siguiente instrucción en secuencia. Esta situación es excesivamenterestrictiva, puesto que lo habitual es que surja la necesidad de variar el flujo decontrol del programa para tomar decisiones y/o repetir cómputos. En la mayor parte de los lenguajes de programación existe una serie deinstrucciones que permiten variar la secuencialidad del flujo de control. En Java laspodemos dividir en el grupo de instrucciones condicionales, el grupo deinstrucciones repetitivas y las llamadas a métodos. El bucle for que se explica eneste apartado pertenece al grupo de instrucciones repetitivas.2.1.1 Sintaxis Cuando deseamos ejecutar un grupo de instrucciones un númerodeterminado de veces, la instrucción for es la que mejor se adapta a esta tarea. Lasintaxis de esta instrucción es: for (inicialización; condición de continuidad; expresión de variación) { Instrucciones a ejecutar de forma repetitiva } La semántica (significado) de la instrucción es la siguiente: se inicializa unavariable (inicialización), se evalúa la condición de continuidad y, si se cumple, seejecutan las instrucciones situadas entre las llaves, finalmente se ejecuta la expresión 32.
22 JAVA A TRAVÉS DE EJEMPLOS © JESÚS BOBADILLA SANCHO (JBOBI@EUI.UPM.ES)de variación y se repite el ciclo hasta que la condición de continuidad se evalúacomo false. Este proceso se puede entender mucho mejor con una serie de ejemplos:2.1.2 Ejemplos de aprendizaje1 public class BucleFor1 {2 public static void main (String[] args) {3 int i;4 for (i=1;i<=4;i=i+1) {5 System.out.println(i);6 }7 }8 } En el ejemplo anterior (BucleFor1) se declara una varia ble de tipo int en lalínea 3, que se utiliza en la línea 4 (for). El bucle for contiene sus tres seccionesobligatorias: • Inicialización: i=1 • Condición de continuidad: i<=4 • Expresión de incremento: i=i+1 De esta manera el bucle se ejecuta de la siguiente forma: Primera iteración i almacena el valor 1 i<=4 se evalúa como true Se imprime: 1 Segunda iteración i almacena el valor 2 i<=4 se evalúa como true Se imprime: 2 Tercera iteración i almacena el valor 3 i<=4 se evalúa como true Se imprime: 3 Cuarta iteración i almacena el valor 4 i<=4 se evalúa como true Se imprime: 4 Finalización i almacena el valor 5 i<=4 se evalúa como false ---------------- En el ejemplo anterior podemos cambiar, si lo deseamos, las líneas decódigo 3 y 4 de la siguiente manera: for (int i=1; i<=4; i++); en este caso declaramosla variable i dentro del bucle y utilizamos el operador de postincremento. Tambiénpodemos prescindir de las llaves, puesto que el bloque de instrucciones que seejecutan repetitivamente, en este caso, se compone de una única instrucción. 33.
© JESÚS BOBADILLA SANCHO (JBOBI@EUI.UPM.ES) CAPÍTULO 2: ESTRUCTURAS DE CONTROL 23 La expresión de variación puede definirse de cualquier manera que nos seaútil. Por ejemplo, si deseamos imprimir los 10 primeros números impares negativos,podemos programar el siguiente bucle:1 public class BucleFor2 {2 public static void main (String[] args) {3 for (int i=-1;i>-20;i=i-2)4 System.out.println(i);5 }6 } Primera iteración i almacena el valor -1 i>-20 se evalúa como true Se imprime: -1 Segunda iteración i almacena el valor -3 i>-20 se evalúa como true Se imprime: -3 .................... ....................... ............................ ............... Décima iteración i almacena el valor -19 i>-20 se evalúa como true Se imprime: -19 Finalización i almacena el valor -21 i>-20 se evalúa como ---------------- false Es habitual, en programación, utilizar en la medida de lo posible buclessencillos, aunque esto conlleve que las instrucciones interiores al bucle contenganexpresiones un poco más complejas. Los bucles sencillos (secuenciales) facilitan ladepuración del código cuando existen errores en los programas. El ejemploBucleFor2 puede ser codificado de la siguiente manera:1 public class BucleFor3 {2 public static void main (String[] args) {3 for (int i=1;i<=10;i++)4 System.out.println(1-i*2);5 }6 } Otra posible solución es:1 public class BucleFor4 {2 public static void main (String[] args) {3 int ImparNegativo = -1;4 for (int i=0;i<=9;i++){5 System.out.println(ImparNegativo);6 ImparNegativo = ImparNegativo - 2;7 }8 }9 } 34.
24 JAVA A TRAVÉS DE EJEMPLOS © JESÚS BOBADILLA SANCHO (JBOBI@EUI.UPM.ES) En este caso no podemos prescindir de las llaves de comienzo y final (llavesdelimitadoras) de bloque, puesto que si lo hiciéramos sólo se ejecutaríarepetitivamente la instrucción 5. La instrucción 6 se ejecutaría una sola vez, alacabar el bucle.2.1.3 Situaciones erróneas En este apartado vamos a ilustrar una serie de actuaciones erróneas que sonmuy habituales entre las personas que empiezan a programar. Resulta especialmenteconveniente prestar atención en este apartado para evitar, en la medida de lo posible,codificar los programas con errores. La primera situación que vamos a analizar son los bucles infinitos (productosiempre de un error en la programación). En el siguiente ejemplo (BucleFor5) seproduce esta situación, debido a que la condición de continuidad del bucle nunca seevalúa como false. Analizando el programa, llegamos fácilmente a la conclusión deque la variable i albergará únicamente valores pares positivos, por lo que lacondición de continuidad i!=21 nunca se evaluará como false y por lo tanto nunca sesaldrá del bucle.1 public class BucleFor5 {2 public static void main (String[] args) {3 for (int i=0;i!=21;i=i+2)4 System.out.println(i);5 }6 } Para cortar la ejecución de un programa basta con pulsar la combinación deteclas Ctrl.+C con la consola de MS-DOS activa (donde se ejecuta el programa). Latecla Ctrl. se debe pulsar primero, y manteniendo esta tecla pulsada presionar latecla C. El siguiente programa es correcto. Imprime los primeros 20 números enterospositivos:1 public class BucleFor6 {2 public static void main (String[] args) {3 for (int i=1;i!=21;i=i+1)4 System.out.println(i);5 }6 } 35.
© JESÚS BOBADILLA SANCHO (JBOBI@EUI.UPM.ES) CAPÍTULO 2: ESTRUCTURAS DE CONTROL 25 En BucleFor6 la condición de continuidad es correcta; la iteración seproduce para i=1, 2, 3, ..., 20. Con i valiendo 21, la condición se evalúa como false(21!=21 es false). Si pusiéramos como condición de finalización i < 21, la semánticadel programa no variaría, sin embargo, i>20, por ejemplo, nos sacaría del bucle deforma inmediata, puesto que en la primera iteración la condición de continuidad seevaluaría como false. Aquí tenemos otro ejemplo típico de programación errónea: unbucle for cuya condición de evaluación, mal programada, nos saca del bucle en laprimera iteración. for (int i=1;i>20;i=i+1) El siguiente programa (BucleFor7) contiene un error muy común y muydifícil de detectar. El problema reside en haber mezclado la expresión depostincremento (i++) con la de asignación (i=i+1), obteniendo la expresión,errónea, i=i++.1 public class BucleFor7 {2 public static void main (String[] args) {3 for (int i=1;i!=21;i=i++)4 System.out.println(i);5 }6 } El programa codificado en la clase BucleFor8 realiza la suma de los 1000primeros números naturales (1+2+3+4+ .... +1000), imprimiendo por cada suma elresultado parcial obtenido. Este programa está correctamente codificado.1 public class BucleFor8 {2 public static void main (String[] args) {3 int Suma = 0;4 for (int i=1;i<=1000;i++) {5 Suma = Suma + i;6 System.out.println(Suma);7 }8 }9 } Las instrucciones que se repiten (1000 veces) son las que se encuentranentre los delimitadores { } asociados a la instrucción repetitiva for; por ello tanto lainstrucción 5 como la 6 se ejecutan 1000 veces. En cada vuelta del bucle se añade elvalor de i (1,2,3,4, ..., 1000) al resultado de la suma anterior (guardado en la variableSuma). La evolución de las variables es la siguiente: Primera i almacena el Suma almacena i<=1000 se evalúa Se imprime: 1 iteración valor 1 el valor 1 como true 36.
26 JAVA A TRAVÉS DE EJEMPLOS © JESÚS BOBADILLA SANCHO (JBOBI@EUI.UPM.ES) Segunda i almacena el Suma almacena i<=1000 se evalúa Se imprime: 3 iteración valor 2 el valor 3 como true Tercera i almacena el Suma almacena i<=1000 se evalúa Se imprime: 6 iteración valor 3 el valor 6 como true .................... ............... ....................... ............................ Iteración 1000 i almacena el Suma almacena i<=1000 se evalúa Se imprime: valor 1000 el valor 500500 como true 500500 Finalización i almacena el ---------------- i<=1000 se evalúa ---------------- valor 1001 ----------- como false Si en el programa anterior olvidáramos las llaves delimitadoras del ámbito(alcance) del bucle for, sólo se ejecutaría dentro del bucle la línea 5. En este casoobtenemos el mismo resultado que en el ejemplo anterior, pero sin la impresión delos resultados parciales de las sumas. La instrucción 6 se ejecuta al terminar el bucley nos imprime únicamente el resultado final.1 public class BucleFor9 {2 public static void main (String[] args) {3 int Suma = 0;4 for (int i=1;i<=1000;i++)5 Suma = Suma + i;6 System.out.println(Suma);7 }8 } Omitir las llaves de un bucle es un error habitual cuando se comienza aprogramar en Java, y normalmente las consecuencias son mucho peores que lasocurridas en el ejemplo anterior.2.1.4 Ejemplos de resolución de problemasFactorial de un número El primer ejemplo que se propone en esta sección es hallar el factorial de unnúmero. El valor factorial se consigue de la siguiente manera: Factorial de k (k!) = k * (k-1) * (k-2) * ... * 2 * 1 Ejemplo: 4! = 4 * 3 * 2 * 1 = 24 Solución: 37.
© JESÚS BOBADILLA SANCHO (JBOBI@EUI.UPM.ES) CAPÍTULO 2: ESTRUCTURAS DE CONTROL 271 public class Factorial {2 public static void main (String[] args) {3 int Numero = 6;4 int Factorial = 1;5 for (int i=2;i<=Numero;i++)6 Factorial = Factorial * i;7 System.out.println(Factorial);8 }9 } El valor del que queremos obtener el factorial lo almacenamos en la variableNumero (línea 3), después inicializamos la variable Factorial a 1, que nos servirá deacumulador. El bucle for comienza en 2, aumenta secuencialmente y termina en elvalor almacenado en Numero, de esta manera conseguimos pasar por la secuencia: 2,3, 4, 5, 6, que son los valores que debemos multiplicar (el 1, realmente no esnecesario). En la línea 6 acumulamos los valores parciales de la multiplicación de lasecuencia (2,3,4,5,6). La línea 7, ya fuera del bucle, nos imprime el resultado (720). Para hallar el factorial de cualquier otro número, basta con variar el valorcon el que inicializamos la variable Numero, en la línea 6. Obsérvese que el factorialde 1 (que es cero) no se saca con este método, y sobre todo, que si el valor deNumero es muy grande, podemos desbordar el rango del tipo int, por lo que seríaconveniente emplear el tipo long.Problema de logística Supongamos que una importante empresa de electrodomésticos nos contratapara resolver problemas de logística. El primer caso práctico que nos plantean es elsiguiente: En las grandes ciudades el precio del suelo es muy caro, por lo que compraro alquilar grandes superficies de almacenamiento de electrodomésticos resultaprohibitivo en el centro de la ciudad. La solución es alejarse del núcleo urbano, sinembargo, cuanto más nos alejamos, más nos cuesta el precio de distribución quecada día hay que abonar a los transportistas que nos trasladan los electrodomésticosde la periferia al centro (donde se realizan la mayoría de las compras). La estrategia que adoptaremos es la siguiente: 38.
28 JAVA A TRAVÉS DE EJEMPLOS © JESÚS BOBADILLA SANCHO (JBOBI@EUI.UPM.ES) 1 Adquirir un almacén pequeño en el centro de la ciudad (para 200 electrodomésticos, por término medio). 2 Adquirir almacenes en anillos concéntricos de 5 kilómetros a partir del centro de la ciudad, cada almacén podrá contener un stock del doble de electrodomésticos que el almacén anterior (es decir, de 400 electrodomésticos a 5 Km. del núcleo urbano, de 800 electrodomésticos a 10 kilómetros, etc.). Se pide: indicar a cuantos kilómetros se encontrará el último almacén en unaciudad que requiere una capacidad total de 100000 electrodomésticos en stock. Los100000 electrodomésticos estarán repartidos entre todos los almacenes adquiridos. Solución:1 public class Logistica {2 public static void main (String[] args) {3 int CapacidadAlmacen = 200;4 int CapacidadTotal = CapacidadAlmacen;5 for (int i=2;i<=10;i++) {6 CapacidadAlmacen = CapacidadAlmacen * 2;7 CapacidadTotal = CapacidadTotal + CapacidadAlmacen;8 System.out.println(i+": "+CapacidadTotal);9 }10 }11 } En la línea 3 establecemos la capacidad del primer almacén(CapacidadAlmacen) a 200, en la línea 4 establecemos la capacidad total(CapacidadTotal) que por ahora tenemos como la capacidad del primer almacén (eldel centro urbano). La línea 5 codifica un bucle que itera 10 veces: esperamos quecon 10 almacenes consigamos la capacidad total de 100000 electrodomésticos, si nofuera así deberíamos aumentar el número de iteraciones. La línea 6 actualiza la capacidad del siguiente almacén como el doble de lacapacidad del almacén actual. La línea 7 acumula en la variable CapacidadTotal elnúmero de electrodomésticos que sumaban l s almacenes anteriores con los que opuede albergar el almacén actual. La línea 8 nos imprime los resultados parciales,obsérvese que podemos imprimir varias variables en la misma línea. El resultado de la ejecución del programa se muestra en la siguiente ventana: 39.
© JESÚS BOBADILLA SANCHO (JBOBI@EUI.UPM.ES) CAPÍTULO 2: ESTRUCTURAS DE CONTROL 29 Se puede observar como con 9 almacenes (incluido el del centro urbano) sealcanza la capacidad acumulada de 100000 electrodomésticos (concretamente102200); por lo tanto hemos tenido que comprar 8 almacenes fuera del centrourbano, situándose el último a 8*5 = 40 kilómetros de la ciudad. Para realizar este ejercicio hubiera sido mucho más elegante emplear unaestructura de control de flujo en bucle que nos permitiera iterar mientras (o hasta)que se cumpla una condición determinada: (que CapacidadTotal >=100000). Elbucle for no nos resuelve esta situación adecuadamente, puesto que está diseñadopara indicar a priori el número de iteraciones, aunque tampoco resulta imposibleutilizarlo de otra manera:1 public class Logistica2 {2 public static void main (String[] args) {3 int CapacidadAlmacen = 200;4 int CapacidadTotal = CapacidadAlmacen;5 int i;6 for (i=2;CapacidadTotal<100000;i++) {7 CapacidadAlmacen = CapacidadAlmacen * 2;8 CapacidadTotal = CapacidadTotal + CapacidadAlmacen;9 }10 System.out.println(i+": "+CapacidadTotal);11 }12 } En cualquier caso, para resolver este ejercicio, resulta más apropiado utilizarlas estructuras de control que se explican en el siguiente apartado.2.2 EL BUCLE WHILE El bucle while nos permite repetir la ejecución de una serie de instruccionesmientras que se cumpla una condición de continuidad. Su uso resulta recomendablecuando no conocemos a priori el número de iteraciones que debemos realizar. 40.
30 JAVA A TRAVÉS DE EJEMPLOS © JESÚS BOBADILLA SANCHO (JBOBI@EUI.UPM.ES)2.2.1 Sintaxis El bucle while tiene dos posibles sintaxis: while (condición de continuidad) { Instrucciones a ejecutar de forma repetitiva } do { Instrucciones a ejecutar de forma repetitiva } while (condición de continuidad); En ambos casos se itera mientras que la “condición de continuidad” secumpla, abandonándose el bucle cuando la condición se evalúa como false. En elprimer caso puede ocurrir que las instrucciones interiores del bucle nunca seejecuten (si la primera vez que se evalúa la condición resulta false); en el segundocaso las instrucciones interiores al bucle se ejecutan al menos una vez.2.2.2 Ejemplos de aprendizaje En el siguiente ejemplo se muestra una implementación muy sencilla delbucle while en la que se pretende imprimir los números 1, 2, 3 y 4. Puesto queconocemos a priori el número de iteraciones sería más adecuado utilizar un buclefor, pero se ha escogido este ejemplo sencillo para mostrar una primeraimplementación del bucle while.1 public class BucleWhile1 {2 public static void main (String[] args) {3 int i=1;4 while (i<=4) {5 System.out.println(i);6 i++;7 }89 }10 } En BucleWhile1 se declara una variable de tipo int en la línea 3 y seinicializa a 1; esta variable actuará como contador de iteraciones en el bucle. En lalínea 4 se establece la condición de continuidad del bucle (se itera mientras quei<=4). La línea 5 se encarga de imprimir el valor del índice y la línea 6 de 41.
© JESÚS BOBADILLA SANCHO (JBOBI@EUI.UPM.ES) CAPÍTULO 2: ESTRUCTURAS DE CONTROL 31incrementarlo. Nótese como se están codificando las distintas expresiones ycondiciones del bucle for: for (i=1; i<=4;i++), en las líneas 3, 4 y 6. Un error muy frecuente cuando se codifica un bucle while es olvidarincrementar el contador (línea 6), generando un bucle infinito. En nuestro ejemplotambién crearíamos un bucle infinito se olvidáramos las llaves delimitadoras d elámbito del bucle. Detalle de la ejecución de BucleWhile1: Antes del while i almacena el valor 1 Primera iteración i<=4 se evalúa como true Se imprime: 1 i almacena el valor 2 Segunda iteración i<=4 se evalúa como true Se imprime: 2 i almacena el valor 3 Tercera iteración i<=4 se evalúa como true Se imprime: 3 i almacena el valor 4 Cuarta iteración i<=4 se evalúa como true Se imprime: 4 i almacena el valor 5 Finalización i<=4 se evalúa como false ----------------- ---------------- A continuación se muestra la forma alternativa de utilizar un bucle while: do{ } while(condición); la semántica en este ejemplo es la misma que en el anterior (seimprimen los valores 1 a 4). El detalle de la ejecución no varía respecto a lamostrada en BucleWhile1, salvo que la condición de continuidad se evalúa al finalen lugar de al comienzo del bucle.1 public class BucleWhile2 {2 public static void main (String[] args) {3 int i=1;4 do {5 System.out.println(i);6 i++;7 } while (i<=4);8 }9 } Ahora vamos a resolver la siguiente cuestión: ¿Cuántos números naturales(1, 2, 3, 4...) debemos sumar en secuencia para obtener al menos un valor de100000?, es decir: ¿hasta qué valor llegará el sumatorio 1+2+3+4+5+..... para que lasuma alcance al valor 100000? Este problema lo podemos resolver de forma muy simple haciendo uso delbucle while:1 public class BucleWhile3 {2 public static void main (String[] args) {3 int Suma=0;4 int i=0;5 do { 42.
32 JAVA A TRAVÉS DE EJEMPLOS © JESÚS BOBADILLA SANCHO (JBOBI@EUI.UPM.ES)6 i++;7 Suma = Suma + i;8 } while (Suma<100000);9 System.out.println(i);10 }11 } En la línea 3 se declara e inicializa el acumulador Suma al valor 0 y en lalínea 4 el contador i al valor 0. En la línea 6 se incrementa i y en la línea 7 seacumula el valor del contador sobre la variable Suma. Las iteraciones continúanmientras Suma<100000 (línea 8). Detalle de la ejecución de BucleWhile3: Antes del while i almacena el Suma almacena el valor 0 valor 0 Primera i almacena el Suma almacena el Suma <100000 se evalúa iteración valor 1 valor 1 como true Segunda i almacena el Suma almacena el Suma <100000 se evalúa iteración valor 2 valor 3 como true .......................... ............................. .................................. ............................................. .... ..... Iteración 447 i almacena el Suma almacena el Suma <100000 se evalúa valor 447 valor 100128 como false2.2.3 Ejemplos de resolución de problemasDeterminación de si un número es primo Utilizando un algoritmo muy sencillo aunque poco eficaz, podemos saber siun número es primo de la siguiente manera: dividimos el número entre todos losanteriores (salvo el 1) y si no es divisible entre ninguno, entonces es primo. Unaposible implementación de este algoritmo es:1 public class Primo {2 public static void main (String[] args) {3 int PosiblePrimo = 17;4 int Divisor = 2;5 boolean Primo = true;67 do {8 Primo = (PosiblePrimo % Divisor)!=0;9 Divisor++; 43.
© JESÚS BOBADILLA SANCHO (JBOBI@EUI.UPM.ES) CAPÍTULO 2: ESTRUCTURAS DE CONTROL 3310 } while(Divisor<PosiblePrimo && Primo);11 System.out.println(Primo);12 }13 } En la línea 3 declaramos y definimos el valor del número del que deseamossaber si es primo. En la línea 4 inicializamos una variable Divisor a 2, éste será elcontador por el que se irá dividiendo sucesivamente nuestro PosiblePrimo. En lalínea 8 determinamos si PosiblePrimo es divisible entre Divisor, para elloobtenemos su módulo (operación %) y lo comparamos con 0, si no es divisible, porahora el número puede ser primo. Vamos incrementando Divisor (en la línea 9) ycontinuamos el bucle (línea 10) mientras que Divisor sea menor que PosiblePrimo yPrimo nos indique que por ahora el número puede ser primo. Cuando se sale del bucle (línea 11) o bien Divisor ha alcanzado aPosiblePrimo, en cuyo caso el número es primo (Primo es true), o bien la variablePrimo ha tomado el valor false, en cuyo caso PosiblePrimo no es un número primo. Detalle de la ejecución de BucleWhile3: Antes del while Primo almacena Divisor almacena el el valor true valor 2 Primera Primo almacena Divisor almacena el La condición se evalúa iteración el valor true valor 3 como true Segunda Primo almacena Divisor almacena el La condición se evalúa iteración el valor true valor 4 como true .......................... ............................. ...................................... ......................................... ......... Iteración 15 Primo almacena Divisor almacena el La condición se evalúa el valor true valor 17 como falseProblema de logística El problema que aquí se plantea ha sido resuelto en la lección anteriorhaciendo uso del bucle for, la solución utilizando el bucle while es muy parecida ymucho más apropiada: supongamos que una importante empresa deelectrodomésticos nos contrata para resolver problemas de logística. El primer casopráctico que nos plantean es el siguiente: En las grandes ciudades el precio del suelo es muy caro, por lo que compraro alquilar grandes superficies de almacenamiento de electrodomésticos resultaprohibitivo en el centro de la ciudad. La solución es alejarse del núcleo urbano, sin 44.
34 JAVA A TRAVÉS DE EJEMPLOS © JESÚS BOBADILLA SANCHO (JBOBI@EUI.UPM.ES)embargo, cuanto más nos aleja mos, más nos cuesta el precio de distribución quecada día hay que abonar a los transportistas que nos trasladan los electrodomésticosde la periferia al centro (donde se realizan la mayoría de las compras). La estrategia que adoptaremos es la siguiente: 1 Adquirir un almacén pequeño en el centro de la ciudad (para 200 electrodomésticos, por término medio). 2 Adquirir almacenes en anillos concéntricos de 5 kilómetros a partir del centro de la ciudad, cada almacén podrá contener un stock del doble de electrodomésticos que el almacén anterior (es decir, de 400 electrodomésticos a 5 Km. del núcleo urbano, de 800 electrodomésticos a 10 kilómetros, etc.). Se pide: indicar a cuantos kilómetros se encontrará el último almacén en unaciudad que requiere una capacidad total de 100000 electrodomésticos en stock. Los100000 electrodomésticos estarán repartidos entre todos los almacenes adquiridos. Solución:1 public class LogisticaWhile {2 public static void main (String[] args) {3 int CapacidadAlmacen = 200, Km = 0;4 int CapacidadTotal = CapacidadAlmacen;5 do {6 CapacidadAlmacen = CapacidadAlmacen * 2;7 CapacidadTotal = CapacidadTotal + CapacidadAlmacen;8 Km = Km +5;9 } while(CapacidadTotal<100000);10 System.out.println(Km+": "+CapacidadTotal);11 }12 } En la línea 3 establecemos la capacidad del primer almacén(CapacidadAlmacen) a 200 y los kilómetros de distancia (Km) a 0, en la línea 4establecemos la capacidad total (CapacidadTotal) que por ahora tenemos como lacapacidad del primer almacén (el del centro urbano). Las líneas 5 y 9 codifican unbucle que itera mientras la capacidad acumulada (CapacidadTotal) sea menor que100000. La línea 6 actualiza la capacidad del siguiente almacén como el doble de lacapacidad del almacén actual. La línea 7 acumula en la variable CapacidadTotal elnúmero de electrodomésticos que sumaban los almacenes anteriores con los quepuede albergar el almacén actual. La línea 8 actualiza los kilómetros a los que seencuentra el primer almacén. Recommended
Case study la business intelligence applicata al settore bancario
actarusboy

References: resolución 
 resolución 
 resolución 
 resolución 
 resolución 
 resolución