Documentos  Computadoras  Programación

Aprende Java Con

Ejercicios - Sanchez Luis
Jose
Mostrar el título completo

Cargado por albertozapata

 100% (1) · 344 vistas · 238 páginas

Información del documento 

Título original
Aprende Java Con Ejercicios -- Sanchez Luis Jose
Descargar ahora 
Derechos de autor
© © All Rights Reserved

Formatos disponibles
PDF, TXT o lea en línea desde Scribd

Compartir este documento

Facebook Twitter


Correo electrónico

¿Le pareció útil este documento?

¿Este contenido es inapropiado? Denunciar este documento

En la que confían más de 1 millón de miembros

Prueba Scribd GRATIS durante 30 días para acceder

a más de 125 millones de títulos sin anuncios ni
interrupciones.

Comenzar prueba gratis

Puede cancelar en cualquier momento.

Índice general

Sobre este libro   . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .   i

Sobre el autor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .   ii
Centros en los que se usa este libro  . . . . . . . . . . . . . . . . . . . . . . . . .   iii
Introducción  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .   iv
Instalación y configuración del entorno de programación Java   . . . . . . .   v
1. ¡Hola mundo! - Salida de datos por pantalla   . . . . . . . . . . . . . . . . .   1
1.1 ¡Hola mundo! - Mi primer programa . . . . . . . . . . . . . . .. . . . ... .. . 1
1.2 Coloreado de texto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 6
2. Variables  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .   8
2.1 Definición y tipos de variables . . . . . . . . . . . . . . . . . . . . . . . . . . .. . 8
2.1.1 Enteros (int y  long) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . 9
2.1.2 Números decimales (double  y  float) . . . . . . . . . . . . . . . . . . . .. . 9
2.1.3 Cadenas de caracteres (String) . . . . . . . . . . . . . . . . . . . . . . . . 10
2.2 Operadores artiméticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.3 Asignación de valores a variables . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.4 Conversión de tipos (casting ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.5 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3. Lectura de datos desde teclado . . . . . . . . . . . . . . . . . . . . . . . . . .   16
3.1 Lectura de texto . . . . .... .... . . . . . ... .... .... . . . . . . .. . 16
3.2 Lectura de números . . . ... ... .. . . . . .. ... ... ... . . . . . . ... 17
3.3 La clase  Scanner . . . . . . . . . . . . .. . . . . . . . . . . . . . .. . . . . . . . . . 18
3.4 Ejercicios . . . . . . . . . . . . . .. . . . . . . . . . . . . .. . . . . . . . . . . . . 22
4. Sentencia condicional (if  y  switch) . . . . . . . . . . . . . . . . . . . . . . . .   25
4.1 Sentencia  if   . . . . . . . . . . . . . . . . . . .. . . . .. . . . .. . . . . . . . .. 25
4.2 Operadores de comparación . . . . . . . .. .. ... .. ... ... . . . . .. . 28
4.3 Operadores lógicos . . . . . . . . . . . . . ... .... .... .... . . . . ... 29
4.4 Sentencia  switch (selección múltiple) . . . . .. .. .. .. .. .. .. . . . . .. . 31
4.5 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . 35

ÍNDICE GENERAL

5. Bucles  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .   39
5.1 Bucle  for   . . . . . . . . .. . . . .. . . . .. . . . . . . . .. . . . .. . . . . . . . 39
5.2 Bucle  while   . . . . . . . .. . . . .. . . . .. . . . . . . . .. . . . .. . . . . . . . 40
5.3 Bucle  do-while   . . . . . . . . .. . . .. . . . . . . . . .. . . . .. . . .. . . . . . 41
5.4 Ejercicios . . . . . . . . . . . . . .. . . . . . . . . . . . . .. . . . . . . . . . . . . 44
6. Números aleatorios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .   51
6.1 Generación de números aleatorios con y sin decimales . . . . . . . . . . . . . . 51
6.2 Generación de palabras de forma aleatoria de un conjunto dado . . . . . . . . 55
6.3 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
7. Arrays  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .   62
7.1 Arrays de una dimensión . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
7.2 Arrays bidimensionales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
7.3 Recorrer arrays con for  al estilo  foreach   . . . . . . . . . . . . . . . . . . . . . . . 70
7.4 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
7.4.1 Arrays de una dimensión . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
7.4.2 Arrays bidimensionales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
8. Funciones   . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .   80
8.1 Implementando funciones para reutilizar código . . . . . . . . . . . . . . . . . . 80
8.2 Comentarios de funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
8.3 Creación de bibliotecas de rutinas mediante paquetes . . . . . . . . . . . . . . 83
8.4 Ámbito de las variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
8.5 Paso de parámetros por valor y por referencia . . . . . . . . . . . . . . . . . . . 87
8.6 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
9. Programación orientada a objetos . . . . . . . . . . . . . . . . . . . . . . . .   95
9.1 Clases y objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
9.2 Encapsulamiento y ocultación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
9.3 Métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
9.3.1 Creí haber visto un lindo gatito . . . . . . . . . . . . . . . . . . . . . . . . 97
9.3.2 Métodos getter  y  setter    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
9.3.3 Método toString   . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
9.4 Ámbito/visibilidad de los elementos de una clase -  public,  protected y  private   . 107
9.5 Herencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
9.5.1 Sobrecarga de métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
9.6 Atributos y métodos de clase ( static) . . . . . . . . . . . . . . . . . . . . . . . . . 114
9.7 Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
9.8 Arrays de objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
9.9 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
9.9.1 Conceptos de POO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
9.9.2 POO en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
9.9.3 Arrays de objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
10.Colecciones y diccionarios   . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133

ÍNDICE GENERAL

10.1 Colecciones: la clase  ArrayList   . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133

10.1.1Principales métodos de  ArrayList   . . . . . . . . . . . . . . . . . . . . . . . 133
10.1.2Definición de un   ArrayList  e inserción, borrado y modificación de sus
elementos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
10.1.3 ArrayList de objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
10.1.4Ordenación de un  ArrayList   . . . . . . . . . . . . . . . . . . . . . . . . . . 142
10.2 Diccionarios: la clase  HashMap   . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
10.2.1Principales métodos de  HashMap   . . . . . . . . . . . . . . . . . . . . . . . . 146
10.2.2Definición de un  HasMap e inserción, borrado y modificación de entradas 147
10.3 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
11.Ficheros de texto y paso de parámetros por línea de comandos  . . . . 155
11.1 Lectura de un fichero de texto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
11.2 Escritura sobre un fichero de texto . . . . . . . . . . . . . . . . . . . . . . . . . . 159
11.3 Lectura y escritura combinadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
11.4 Otras operaciones sobre ficheros . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
11.5 Paso de argumentos por línea de comandos . . . . . . . . . . . . . . . . . . . . 163
11.6 Combinación de ficheros y paso de argumentos . . . . . . . . . . . . . . . . . . 166
11.7 Procesamiento de archivos de texto . . . . . . . . . . . . . . . . . . . . . . . . . 168
11.8 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
12.Aplicaciones web en Java (JSP)   . . . . . . . . . . . . . . . . . . . . . . . .. . 173
12.1 Hola Mundo en JSP . . . . . . . . . . . . .. .. .. .. .. .. .. . . . . .. .. . 173
12.2 Mezclando Java con HTML . . . . . . . . .. .. .. .. .. .. .. . . . . .. .. . 175
12.3 Recogida de datos en JSP . . . . . . . . . .. .. . .. .. . .. .. . . . .. .. .. 179
12.4 POO en JSP . . . . . . . . . . . . . . . . . . ... ... ... .. .. . . . ... ... 183
12.5 Ejercicios . . . . . . . . . . . . . . . . . . .. ... ... ... ... . . . .. ... . 188
13.Acceso a bases de datos   . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . 192
13.1 Socios de un club de baloncesto . . . . . . . .. .. .. . .. .. .. . .. .. .. 192
13.2 Preparación del proyecto de ejemplo . . . . . . . . . . . . . . . . . . . . . . . . 195
13.2.1Activar la conexión a MySQL . . . . . . . . . . . . . . . . . . . . . . . . . . 195
13.2.2Incluir la librería MySQL JDBC . . . . . . . . . . . . . . . . . . . . . . . . . 197
13.3 Listado de socios . . . . . . . . . . . . . . . . .. .. .. .. .. .. .. .. .. .. . 197
13.4 Alta . . . . . . . . . . . . . . . . . . . . . . . . .... .... .... .... .... . 200
13.5 Borrado . . . . . . . . . . . . . . . . . . . . . ... .... .... .... .... .. 202
13.6 CRUD completo con Bootstrap . . . . . . . . .. .. .. . .. .. .. . .. .. . . 205
13.7 Ejercicios . . . . . . . . . . . . . . . . . . . . ... ... ... ... ... .. ... . 207
Apéndice A. Ejercicios de ampliación   . . . . . . . . . . . . . . . . . . . . . . . . 213
Apéndice B. Entorno de Desarrollo Integrado Netbeans . . . . . . . . . . . . 216
Descarga e instalación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
Configuración . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
Creación de un proyecto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
Depuración . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221

ÍNDICE GENERAL

Apéndice C. Caracteres especiales  . . . . . . . . . . . . . . . . . . . . . . . . . . 224

Líneas para tablas . . . . . . . . . . . . . . .. .. .. .. .. .. .. . . . . .. .. 224
Bloques . . . . . . . . . . . . . . . . . . . . .. .... .... .... . . . . .... 224
Figuras de ajedrez . . . . . . . . . . . . . . . .. .. .. .. .. .. .. . . .. .. . 224
Círculos . . . . . . . . . . . . . . . . . . . . .... .... .... ... . . ... .. 224
Flechas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224
Números en círculos . . . . . . . . . . . . .. .. .. .. .. .. .. . . . . .. .. 224
Dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224
Fichas de dominó . . . . . . . . . . . . . . .. .. .. .. .. .. .. . . . . .. .. 224
Cartas . . . . . . . . . . . . . . . . . . . . . .... .... .... ... . . ... .. 225
Caras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
Horóscopo . . . . . . . . . . . . . . . . . . .. .... .... .... . . . . .... 225
Miscelánea . . . . . . . . . . . . . . . . . . .. .... .... .... . . . . .... 225

Sobre este libro

“Aprende Java con Ejercicios”   es un manual práctico para aprender a programar en
 Java desde cero.
No es necesario tener conocimientos previos de programación. La dificultad del libro
es gradual, empieza con conceptos muy básicos y ejercicios muy sencillos y va
aumentando en complejidad y dificultad a medida que avanzan los capítulos.
La práctica hace al maestro. Como de verdad se aprende a programar es programando
desde el principio y esa es la filosofía que sigue este libro. En cada capítulo se explican
una serie de conceptos de programación y se ilustran con ejemplos. Al final de cada
uno de los capítulos se plantean ejercicios de diferente dificultad.
Este libro contiene más de 200 ejercicios. Tanto las soluciones a los ejercicios como los
ejemplos están disponibles en GitHub: https://github.com/LuisJoseSanchez/aprende-java-
con-ejercicios y tanto los unos como los otros siguen los estándares de programación
de Google para el código fuente escrito en el lenguaje de programación Java1 .
“Aprende Java con Ejercicios”  es un libro hecho casi a medida de la asignatura “Progra-
mación”  que forma parte del currículo del primer curso de los ciclos formativos DAW
(Desarrollo de Aplicaciones Web) y DAM (Desarrollo de Aplicaciones Multiplataforma)
pero igualmente puede ser utilizado por estudiantes de Ingeniería Informática, Ingenie-
ría de Telecomunicaciones o Ciencias Matemáticas en la asignatura de “Programación” 
de los primeros cursos.
Si tienes alguna duda o quieres hacer algún comentario en relación a este libro, tienes
a tu disposición el grupo de Google https://groups.google.com/d/forum/aprende-java-con-
ejercicios. Cualquier sugerencia para mejorar este manual será bienvenida.
1
http://google-styleguide.googlecode.com/svn/trunk/javaguide.html

Sobre el autor
Luis José Sánchez González es Ingeniero Técnico en Informática de Gestión por la
Universidad de Málaga (España) y funcionario de carrera de la Junta de Andalucía
desde 1998. En su trabajo de profesor de Informática combina sus dos pasiones: la
enseñanza y la programación.
En el momento de publicar este libro, es profesor del I.E.S. Campanillas (Málaga) e
imparte clases en el Ciclo Superior de Desarrollo de Aplicaciones Web .
Puedes ponerte en contacto con el autor mediante la dirección de correo electró-
nico [email protected] o mediante LinkedIn (https://es.linkedin.com/pub/luis-josé-
sánchez/86/b08/34).

ii

Centros en los que se usa este libro

• IES Campanillas, Málaga (España)
• IES Polígono Sur, Sevilla (España)
• IES Murgi, El Ejido - Almería (España)
• IES Punta del Verde, Sevilla (España)

Si eres profesor y utilizas este libro para enseñar Java, pídele al autor que añada en
esta sección el nombre de tu centro educativo o empresa, escribiendo un correo a la
dirección [email protected] indicando la localidad y el país del centro.

iii

Introducción
 Java es un lenguaje de programación; es de hecho, desde hace más de 10 años, el
lenguaje de programación más utilizado en el mundo según el índice PYPL2 (PopularitY
of Programming Language index).
Los ordenadores no entienden - por ahora - el español, ni el inglés, ni ningún otro
idioma natural. De una forma muy simplificada podríamos decir que un lenguaje de
programación es un idioma que entiende el ordenador3 . Cualquier aplicación - proce-
sador de textos, navegador, programa de retoque fotográfico, etc. - está compuesta de
una serie de instrucciones convenientemente empaquetadas en ficheros que le dicen
al ordenador de una manera muy precisa qué tiene que hacer en cada momento.
 Java es un lenguaje de programación estructurado y, como tal, hace uso de variables,
sentencias condicionales, bucles, funciones… Java es también un lenguaje de progra-
mación orientado a objetos y, por consiguiente, permite definir clases con sus métodos
correspondientes y crear instancias de esas clases. Java no es un lenguaje de marcas
como HTML o XML aunque puede interactuar muy bien con ellos4 .
Las aplicaciones Java se suelen compilar a bytecode, que es independiente del sistema
operativo, no a binario que sí depende del sistema operativo. De esta forma, el
bytecode  generado al compilar un programa escrito en Java debería funcionar en
cualquier sistema operativo que tenga instalada una máquina virtual de java (JVM).
Cualquier editor simple como   Nano  o   GEdit  es suficiente para escribir código en
 Java aunque se recomiendan IDEs5 como NetBeans o Eclipse ya que tienen algunas
características que facilitan mucho la programación como el chequeo de errores
mientras se escribe, el autocompletado de nombres de variables y funciones y mucho
más.
2
http://pypl.github.io/PYPL.html
3
En realidad un ordenador no entiende directamente los lenguajes de programación como Java, C, Ruby, etc. Mediante una
herramienta que se llama compilador o traductor según el caso, lo que hay escrito en cualquiera de estos lenguajes se convierte
en código máquina - secuencias de unos y ceros - que es el único lenguaje que de verdad entiende el ordenador.
4
El lector deberá tener unos conocimientos básicos de HTML para entender bien y sacar provecho del capítulo relativo a JSP
de este mismo libro. Una web excelente para aprender HTML es  http://w3schools.com
5
IDE: Integrated Development Enviroment (Entorno de Desarrollo Integrado)

iv

Instalación y configuración del entorno de

programación Java
 Todos los ejemplos que contiene este libro así como las soluciones a los ejercicios
se han escrito sobre  Linux, en concreto sobre  Ubuntu ( http://www.ubuntu.com/ ). No
obstante, todo el código debería compilar y funcionar sin ningún problema en cualquier
otra plataforma.
El software necesario para seguir este manual es el siguiente6 :

OpenJDK
El Open Java Development Kit (OpenJDK) contiene una serie de componentes
que permiten desarrollar y ejecutar aplicaciones escritas en Java. Incluye la má-
quina virtual de Java (JVM) que permite ejecutar  bytecode. Como mencionamos
en el apartado Introducción, el   bytecode  es el ejecutable en Java. El  OpenJDK 
también incluye el compilador   javac que permite compilar el código fuente para
generar el   bytecode. En   Ubuntu, basta ejecutar una línea en la ventana de
terminal para instalar el OpenJDK :
 $   sudo apt-get install openjdk-8-jdk

Para los sitemas operativos  Mac OS X y  Windows, se encuentran disponibles

para su descarga los archivos de instalación del OpenJDK  en la página Unofficial
OpenJDK installers for Windows, Linux and Mac OS X7 . Otra opción consiste en
utilizar el  JDK   oficial de Oracle, que se puede descargar en el apartado  Java SE
Development Kit 8 - Downloads8 de la web de esta misma empresa. No vamos a
explicar las diferencias entre el  OpenJDK  y el  JDK   ya que se escapa al ámbito
de este libro. A efectos prácticos, todos los ejemplos contenidos en este manual
funcionan tanto con en el  OpenJDK  como con el  JDK  y los ejercicios se pueden
realizar sin problema sea cual sea el kit de desarrollo instalado.
Editor de textos simple
Para seguir este manual recomendamos utilizar al principio un editor de textos
sencillo para probar los primeros programas y realizar los primeros ejercicios,
compilando en línea de comandos. De esta manera, el lector se va familiarizando
con el proceso de edición de código, compilación y ejecución y va entendiendo lo
que sucede en cada paso. En Ubuntu viene instalado por defecto el editor GEdit,
el sistema operativo Mac OS X viene con TextEdit y en Windows podemos usar
el programa Bloc de notas.
6
En la página  http://helloworldcollection.de/  se muestra el programa  Hola mundo  escrito en más de 400 lenguajes de
programación.
7
https://github.com/alexkasko/openjdk-unofficial-builds
8
http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html

En la que confían más de 1 millón de miembros

Prueba Scribd GRATIS durante 30 días para acceder

a más de 125 millones de títulos sin anuncios ni
interrupciones.

Comenzar prueba gratis

Puede cancelar en cualquier momento.

Instalación y configuración del entorno de programación Java   vi

Geany
Una vez que el lector ha superado la barrera de escribir sus primeros programas,
recomendamos utilizar el entorno de programación Geany (por ejemplo a partir
del capítulo 2). Se trata de un IDE muy ligero que permite realizar aplicaciones
sencillas con rapidez. Mediante   Geany  se puede escribir el código, chequear
si contiene errores, compilar y ejecutar el   bytecode  generado. Para programas
pequeños - por ej. calcular la media de varios números - es recomendable utilizar
Geany en lugar de un IDE más complejo como  Netbeans. Mientras con  Geany
da tiempo a escribir el código, compilar y ejecutar,  Netbeans  todavía estaría
arrancando.
Instalación de Geany (y los  plugins adicionales) en Ubuntu:
 $   sudo apt-get install geany
 $   sudo apt-get install geany-plugins

En la sección de descargas de la página oficial de Geany 9 se encuentran los

ficheros de instalación de este programa tanto para   Mac OS X   como para
Windows.
Una vez instalado  Geany es conveniente realizar algunos ajustes en la configu-
ración. Presiona  Control + Alt + P para abrir la ventana de preferencias. Haz
clic en la pestaña Editor y luego en la pestaña Sangría. Establece las opciones
tal y como se indican a continuación.
9
http://www.geany.org/Download/Releases

Instalación y configuración del entorno de programación Java   vii

Figura 0.1: Configuración de Geany (sangría)

 También es recomendable marcar las casillas Mostrar guías de sangría y Mostrar

números de línea. Estas opciones se activan en la pestaña Mostrar.

Instalación y configuración del entorno de programación Java   viii

coloreadodetexto

•Kuestravaria
General
CaracterísticasSangriaCompletadosMostrar
@authorLuis
Incectaz Mostrar

2invertirloscoloresderesaltadodesintaxis
EpublicclassColo
Mostraroulasdesanona
publicstatic ArChIVOS

Stringrojo Herramientas carenoes

stringverde
Stringnaranj Plantillas Mascarnumerosdelinea

Stringazul YMuestraemargendemarcas
Stringmorado
Detieneeldesolazamientohaciaabaocuandosealcanzalaóltimalinea
Stringblanco
System.out.pi Marcadordelineaslargas

System.out.pr @Activado
System.out.pe
Tipo: ©Fondo
System.out.pi
Colmos Bo

Espaciosvircuales
10•

ODeshabiRado
,lobaraseleconesrectangulares

)Semore

Avuda Aplicar Cancolar ACOGEST

Figura 0.2: Configuración de Geany (guías de sangría y números de línea)

Netbeans
Cuando las aplicaciones a desarrollar son más complejas y, sobre todo, cuando
éstas constan de varios ficheros, se recomienda utilizar Netbeans de la empresa
Oracle. En el capítulo 9, el lector ya podría sacarle mucho partido al uso de este
IDE. Se trata de un entorno integrado muy potente y muy usado a nivel profesional
que incluye el autocompletado de sintaxis y permite una depuración avanzada
paso a paso.  Netbeans se puede descargar de forma gratuita y para cualquier
plataforma desde https://netbeans.org/downloads/.
Después de la instalación de   Netbeans, procedemos a configurar el editor.
Para ello seleccionamos  Herramientas  →  Opciones  →  Editor. A continuación
seleccionamos la pestaña Formato y en el menú desplegable correspondiente al
lenguaje de programación seleccionamos Java. La configuración debería quedar
como se indica en la imagen.

Instalación y configuración del entorno de programación Java   ix

Figura 0.3: Configuración de Netbeans

Es muy importante que los editores/IDEs que se utilicen para esribir código
en Java se configuren adecuadamente. Hemos visto cómo configurar  Geany
y   Netbeans, pero si el lector decide utilizar otras herramientas deberá
configurarlas igualmente. En definitiva, la configuración/preferencias de las
herramientas que se utilicen deben establecerse de tal forma que se cumplan
estos requisitos:

• La tecla   TAB   debe insertar espacios, no debe insertar el carácter de

tabulación.
• La indentación debe ser de 2 caracteres (por defecto suele estar a 4).
• La condificación de caracteres debe ser UTF-8.

1. ¡Hola mundo! - Salida de datos por pantalla

1.1 ¡Hola mundo! - Mi primer programa
El primer programa que aprende a hacer cualquier aspirante a programador es un Hola
mundo 1 . Es seguramente el programa más sencillo que se puede escribir. Se trata de
un programa muestra el mensaje “Hola mundo” por pantalla. Abre el programa GEdit
que, como hemos comentado en la sección Instalación y configuración del entorno de
programación Java, viene instalado por defecto en Ubuntu y teclea el siguiente código:

 /**
* Muestra por pantalla la frase "¡Hola mundo!"
*
* @author Luis J. Sánchez
*/

public class  HolaMundo   {   // Clase principal

public static  void   main(String[]   args) {
System. out.println("¡Hola mundo!");
}
}

Verás que, en principio, el texto del código no aparece en colores. El coloreado de

sintaxis es muy útil como comprobarás más adelante, sobre todo para detectar errores.
Graba el programa como   HolaMundo.java. Al grabar con la extensión   .java, ahora el
programa  GEdit  sí sabe que se trata de un programa escrito en Java y reconoce la
sintaxis de este lenguaje de forma que puede colorear los distintos elementos que
aparecen en el código.
1
En la página  http://helloworldcollection.de/  se muestra el programa  Hola mundo  escrito en más de 400 lenguajes de
programación.

¡Hola mundo! - Salida de datos por pantalla   2

HolaMundo.Java(-/Dropbox/ProyectosGit/aprende-Java-con-e].../01_Hola_mundo_Sallda_de_datos_por_pantalla)-gedit
Abrir RGuardar +Deshacer

capitulo01.mdxaHolaMundojavax

Muestraporpantallalafrase"¡Holamundo!"
*(authorLuisJ.Sanchez

7publicclassHolaMundo{//Claseprincipal
publicstaticvoidmain(String[]args){
System.out.println("¡Holamundo!");

Anchuradelapestat

Figura 1.1: Programa  Hola mundo escrito en el editor GEdit

Fíjate que el nombre que le damos al fichero es exactamente igual que la clase principal
seguido de la extensión   .java. Abre una ventana de terminal, entra en el directorio
donde se encuentra el fichero y teclea lo siguiente:

 $   javac HolaMundo.java

Este comando crea   HolaMundo.class  que es el   bytecode. Para ejecutar el programa,

teclea:

 $   java HolaMundo

¡Enhorabuena! Acabas de realizar tu primer programa en Java.

En la siguiente captura de pantalla puedes ver la ventana de terminal y los comandos
que acabamos de describir.

¡Hola mundo! - Salida de datos por pantalla   3

Figura 1.2:  HolaMundo.class es el  bytecode generado (1). El resultado del programa es una línea de texto
escrita en pantalla (2).

La instrucción que hemos utilizado para mostrar una frase por pantalla es   Sys-
tem.out.println() , colocando la frase entre paréntesis. También se puede volcar texto
por pantalla mediante System.out.print() . La única diferencia radica en que esta última
no añade un salto de línea al final, pruébalo en   HolaMundo.java  y compruébalo por ti
mismo. Si lo que quieres mostrar es una palabra o una frase, como en este ejemplo,
es importante que el texto esté entrecomillado.

• El programa propiamente dicho está dentro de lo que llamamos “clase

principal”.
• El fichero debe tener el mismo nombre que la clase principal seguido por
la extensión .java
• Los comentarios de varias líneas se colocan entre /* y */
• Los comentarios de línea se indican mediante //
• Para mostrar información por pantalla se utilizan   System.out.println()  y
System.out.print().

¡Hola mundo! - Salida de datos por pantalla   4

1.2 Coloreado de texto

Mostrar siempre texto blanco sobre fondo negro puede resultar muy aburrido. El texto
que se muestra por pantalla se puede colorear; para ello es necesario insertar unas
secuencias de caracteres - que indican el color con el que se quiere escribir - justo
antes del propio texto.
Prueba el siguiente programa y no te preocupes si todavía no lo entiendes del todo,
en el próximo capítulo se explican los diferentes tipos de datos que se pueden utilizar
en Java, entre estos tipos está la cadena de caracteres o String.

 /**
* Coloreado de texto
*
* Muestra varias palabras en el color que corresponde.
*
* @author Luis José Sánchez
*/

public class  Colores   {

public static  void   main(String[]   args) {

String rojo   =   "\033[31m";

String verde   =   "\033[32m";
String naranja   =   "\033[33m";
String azul   =   "\033[34m";
String morado   =   "\033[35m";
String blanco   =   "\033[37m";

System. out.print(naranja   +   "mandarina"   +   verde   +   " hierba");

System. out.print(naranja   +   " saltamontes"   +   rojo   +   " tomate");
System. out.print(blanco   +   " sábanas"   +   azul   +   " cielo");
System. out.print(morado   +   " nazareno"   +   azul   +   " mar");
}
}

Como puedes ver en los dos ejemplos que hemos mostrado, algunas líneas están
ligeramente desplazadas hacia la derecha, es lo que se llama sangría o indentación.
En programación es muy importante sangrar (indentar) bien porque da una idea de qué
partes del código son las que contienen a otras. En este último ejemplo tenemos un
programa que tiene unos comentarios al principio y luego la clase principal marcada
por la línea   public class Colores {. Dentro de la clase   Colores  está el   main  o bloque del
programa principal que tiene sangría por estar dentro de la definición de la clase
 Colores. A su vez, dentro del   main  hay una serie de líneas de código que igualmente
tienen sangría.

¡Hola mundo! - Salida de datos por pantalla   5

En este libro, tanto el código de los ejemplos como el de las soluciones a los
ejercicios siguen el estándar de Google para el código fuente escrito en el lenguaje de
programación Java2 , por tanto, cada vez que se aplique la sangría será exactamente
de dos espacios.

2
http://google-styleguide.googlecode.com/svn/trunk/javaguide.html

¡Hola mundo! - Salida de datos por pantalla   6

1.3 Ejercicios

Ejercicio 1
Escribe una programa que muestre tu nombre por pantalla.

Ejercicio 2
Modifica el programa anterior para que además se muestre tu dirección y
tu número de teléfono. Asegúrate de que los datos se muestran en líneas
separadas.

Ejercicio 3
Escribe un programa que muestre por pantalla 10 palabras en inglés junto
a su correspondiente traducción al castellano. Las palabras deben estar
distribuidas en dos columnas y alineadas a la izquierda. Pista: Se puede
insertar un tabulador mediante \t.

Ejercicio 4
Escribe un programa que muestre tu horario de clase. Puedes usar espacios o
tabuladores para alinear el texto.

Ejercicio 5
Modifica el programa anterior añadiendo colores. Puedes mostrar cada asig-
natura de un color diferente.

Ejercicio 6
Escribe un programa que pinte por pantalla una pirámide rellena a base de
asteriscos. La base de la pirámide debe estar formada por 9 asteriscos.

Ejercicio 7
Igual que el programa anterior, pero esta vez la pirámide estará hueca (se
debe ver únicamente el contorno hecho con asteriscos).

En la que confían más de 1 millón de miembros

Prueba Scribd GRATIS durante 30 días para acceder

a más de 125 millones de títulos sin anuncios ni
interrupciones.

Comenzar prueba gratis

Puede cancelar en cualquier momento.

¡Hola mundo! - Salida de datos por pantalla   7

Ejercicio 8
Igual que el programa anterior, pero esta vez la pirámide debe aparecer
invertida, con el vértice hacia abajo.

Ejercicio 9
Escribe un programa que pinte por pantalla alguna escena - el campo, la
habitación de una casa, un aula, etc. - o algún objeto animado o inanimado
- un coche, un gato, una taza de café, etc. Ten en cuenta que puedes utilizar
caracteres como *, +, <, #, @, etc. ¡Échale imaginación!

2. Variables
2.1 Definición y tipos de variables
Una variable es un contenedor de información. Imagina una variable como una cajita
con una etiqueta que indica su nombre, una cajita en la que se puede introducir un va-
lor. Las variables pueden almacenar valores enteros, números decimales, caracteres,
cadenas de caracteres (palabras o frases), etc. El contenido de las variables puede
cambiar durante la ejecución del programa, de ahí viene el nombre de “variable”.
 Java es un lenguaje fuertemente tipado, es decir, es necesario declarar todas las
variables que utilizará el programa, indicando siempre el nombre y el tipo de cada
una.
El nombre que se le da a una variable es muy importante; intenta usar siempre
nombres significativos que, de alguna forma, identifiquen el contenido. Por ejemplo,
si usas una variable para almacenar el volumen de una figura, una buena opción sería
llamarla  volumen; si tienes una variable que almacena la edad de una persona, lo mejor
es llamarla  edad, y así sucesivamente.
Un programa se lee y se depura mucho mejor si los nombres de las variables se han
elegido de forma inteligente.
¿Podrías averiguar qué hace la siguiente línea de código?

 x   =   vIp3   *   Weerty   -   zxc;

Ahora observa el mismo código pero con otros nombres de variables.

precioTotal   =   cantidad   *   precio   -   descuento;

Se entiende mucho mejor ¿verdad?

Escribiremos los nombres de variables en formato   lowerCamelCase. La primera letra
se escribe en minúscula y, a continuación, si se utiliza más de una palabra, cada una
de ellas empezaría con mayúscula. Por ejemplo,   edadMin es un buen nombre para una
variable que almacena la edad mínima a la que se puede acceder a un sitio web.
Observa que hemos usado una mayúscula para diferenciar dos partes (edad y Min).
Puede que en algún libro también encuentres nombres de variables con el carácter
de subrayado ( _ ) de tal forma que el nombre de la variable sería  edad_min, pero como
hemos comentado anteriormente, en este libro nos ceñimos al  estándar de Google1 ,
que exige el formato lowerCamelCase .
1
http://google-styleguide.googlecode.com/svn/trunk/javaguide.html

Variables   9

No se permiten símbolos como $, %, @, +, -, etc. Puedes usar números en los nombres

de variables pero nunca justo al principio; 5x no es un nombre válido pero  x5 sí lo es.
No se debe poner una letra mayúscula al comienzo del nombre de una variable para
no confundirla con una clase (los nombres de las clases comienzan por mayúscula).

2.1.1 Enteros (int y  long)

Las variables que van a contener números enteros se declaran con   int. Veamos un
ejemplo.

 /**
* Uso de variables enteras
*
* @author Luis J. Sánchez
*/

public class  VariablesEnteras   {

public static  void   main(String[]   args) {
int   x;   // Se declara la variable x como entera

 x   = 5;   // Se asigna el valor 5 a la variable x

System. out.println("El valor actual de mi variable es "   +   x);

 x   = 7;   // Se asigna el valor 7 a la variable x

System. out.println("y ahora es "   +   x);
}
}

Si pretendemos almacenar valores muy grandes en una variable, usaremos el tipo long
en lugar de int.

2.1.2 Números decimales ( double y  float)

Usamos los tipos   double  o   float  cuando queremos (o esperamos) almacenar números
con decimales en las variables.
Ciñéndonos al estándar de Google, no daremos por válidas definiciones de variables
como la siguiente (aunque funcionaría sin ningún problema).

 double   x,   y;

Cada variable se debe definir en una línea diferente. Lo siguiente sí sería correcto.

Variables   10

 double   x;
 double   y;

A continuación tienes un ejemplo completo.

 /**
* Uso de variables que contienen números decimales
*
* @author Luis J. Sánchez
*/

public class  VariablesConDecimales  {

public static  void   main(String[]   args) {
 double   x;   // Se declaran las variables x e y
 double   y;   // de tal forma que puedan almacenar decimales.

 x   = 7;
 y   = 25.01;

System. out.println(" x vale "   +   x);

System. out.println(" y vale "   +   y);
}
}

Como puedes ver, también se pueden almacenar números enteros en variables de tipo
double .

2.1.3 Cadenas de caracteres (String)

Las cadenas de caracteres se utilizan para almacenar palabras y frases. Todas las
cadenas de caracteres deben ir entrecomilladas.

 /**
* Uso del tipo String
*
* @author Luis J. Sánchez
*/

public class  UsoDeStrings   {

public static  void   main(String[]   args) {
String miPalabra   =   "cerveza";
String miFrase   =   "¿dónde está mi cerveza?";

System. out.println("Una palabra que uso con frecuencia: "   +   miPalabra);

Variables   11

System. out.println("Una frase que uso a veces: "   +   miFrase);

}
}

Como puedes ver, en una cadena de caracteres se pueden almacenar signos de

puntuación, espacios y letras con tildes.