PROGRAMACIÓN EN JAVA 2
Serie Schaum
Antonio José Reinoso Peinado , Baltasar Fenández Manjón , Gabriel Huecas Férnandez-Toribio , Jesús Allende Sánchez , Pilar Moreno Díaz y Ricardo Sosa Sánchez-Cortés
Editorial: McGraw-Hill
Edición: 1
Fecha Publicación: 2016
ISBN: 9788448145910
ISBN ebook: 9788448178604
Páginas: 426
Grado: Universitario
Área: Informática
Sección: Lenguajes y Metodología de la Programación
Idioma: Español
Etiquetas: Descatalogado, Schaum
Tweet
Edición: 1
Fecha Publicación: 2016
ISBN: 9788448145910
ISBN ebook: 9788448178604
Páginas: 426
Grado: Universitario
Área: Informática
Sección: Lenguajes y Metodología de la Programación
Idioma: Español
Etiquetas: Descatalogado, Schaum
Tweet
CAPÍTULO 0 ¿Qué es Java?
CAPÍTULO 1 Introducción a la programación ......................................... 9
1.1 Estructura de un programa .................................................................... 9
1.2 Identificadores ....................................................................................... 10
1.3 Tipos, variables y valores ..................................................................... 11
1.4 Expresiones ........................................................................................... 13
1.5 Conversiones de tipo ............................................................................. 15
1.6 Enumerados........................................................................................... 15
1.7 Petición de valores primitivos al usuario .............................................. 16
Problemas resueltos ........................................................................................... 17
CAPÍTULO 2 Clases y objetos .............................................................. 35
2.1 Estructura de una clase ......................................................................... 35
2.2 Atributos ............................................................................................... 36
2.3 Métodos ................................................................................................ 37
2.4 Constructores ........................................................................................ 38
Problemas resueltos ........................................................................................... 41
CAPÍTULO 3 Ampliación de clases ....................................................... 67
3.1 Elementos de clase (static) .................................................................... 67
3.1.1 Valor inicial de atributos de clase ............................................ 68
3.2 Derechos de acceso ............................................................................... 68
CONTENIDO
vii
viii Contenido
3.3 Paquetes ................................................................................................ 69
3.3.1 Uso ........................................................................................... 69
3.3.2 Nombres................................................................................... 69
3.4 Clases internas ...................................................................................... 70
3.5 Importación estática de clases ............................................................... 71
3.6 Clases predefinidas ............................................................................... 72
3.6.1 Envoltorios ............................................................................... 72
3.6.2 Math ........................................................................................ 74
3.6.3 String ....................................................................................... 74
Problemas resueltos ........................................................................................... 75
CAPÍTULO 4 Estructuras de control ..................................................... 95
4.1 Estructuras de selección ........................................................................ 95
4.1.1 Estructura if ............................................................................. 95
4.1.2 Estructura if-else ...................................................................... 95
4.1.3 Operador condicional ............................................................... 96
4.1.4 Estructura switch ..................................................................... 96
4.2 Estructuras de repetición ....................................................................... 97
4.2.1 Estructura while ....................................................................... 97
4.2.2 Estructura do-while .................................................................. 98
4.2.3 Estructura for ........................................................................... 99
4.2.4 Uso de las estructuras de repetición ......................................... 100
4.3 Estructuras de salto ............................................................................... 100
4.3.1 Sentencia break ........................................................................ 100
4.3.2 Sentencia continue ................................................................... 100
4.4 Excepciones .......................................................................................... 100
4.4.1 Captura .................................................................................... 100
4.4.2 Delegación ............................................................................... 102
4.4.3 Definición de excepciones de usuario ...................................... 102
4.4.4 Lanzamiento de excepciones de usuario y redefinición ............ 102
4.5 Aserciones ............................................................................................. 103
4.5.1 Aserciones como comprobación de invariantes ........................ 103
4.5.2 Aserciones como precondiciones ............................................. 103
4.5.3 Aserciones como postcondiciones ............................................ 104
4.5.4 Aserciones como invariantes .................................................... 104
Problemas resueltos ........................................................................................... 105
CAPÍTULO 5 Extensión de clases ......................................................... 147
5.1 Composición ......................................................................................... 147
5.2 Herencia ................................................................................................ 148
5.3 Compatibilidad de tipos ........................................................................ 149
5.4 Ámbitos y visibilidad ............................................................................ 149
5.5 Sobreescritura ....................................................................................... 150
5.6 Constructores ........................................................................................ 150
5.7 Polimorfismo ......................................................................................... 151
5.8 Herencia forzada y clases abstractas .................................................... 152
Problemas resueltos ........................................................................................... 153
CAPÍTULO 6 Estructuras de almacenamiento ....................................... 185
6.1 Arrays ................................................................................................... 185
6.1.1 Declaración .............................................................................. 185
Contenido ix
6.1.2 Creación ................................................................................... 185
6.1.3 Inicialización estática ............................................................... 186
6.1.4 Acceso a los valores ................................................................. 186
6.1.5 Tamano de un array ................................................................. 186
6.2 Arrays multidimensionales .................................................................... 186
6.2.1 Declaración y creación ............................................................. 186
6.2.2 Acceso...................................................................................... 187
6.2.3 Tamano de un array ................................................................. 187
6.2.4 Array de dos dimensiones no rectangulares ............................. 187
6.3 API de manejo de arrays ....................................................................... 187
6.3.1 Uso con arrays de tipos primitivos........................................... 187
6.3.2 Uso con arrays de objetos ........................................................ 188
6.4 Colecciones ........................................................................................... 189
6.4.1 ArrayList y LinkedList ............................................................ 190
6.4.2 HashSet y TreeSet .................................................................... 190
Problemas resueltos ........................................................................................... 193
CAPÍTULO 7 Entrada y salida ............................................................... 229
7.1 Concepto de flujo en Java ..................................................................... 229
7.2 Tipos de flujos ....................................................................................... 229
7.3 Leer y escribir en un archivo ................................................................. 230
7.4 Filtros .................................................................................................... 232
7.5 Entrada desde teclado ............................................................................ 233
7.6 La clase File .......................................................................................... 234
7.7 Archivos de acceso aleatorio ................................................................. 235
7.8 Lectura y escritura de objetos ............................................................... 236
Problemas resueltos ........................................................................................... 238
CAPÍTULO 8 Interfaces ........................................................................ 275
8.1 Definición y uso de interfaces ............................................................... 275
Problemas resueltos ........................................................................................... 278
CAPÍTULO 9 Genéricos ........................................................................ 301
9.1 Genéricos .............................................................................................. 301
9.2 Definición de genéricos ......................................................................... 301
9.3 Herencia de genéricos y conversión de tipos ......................................... 302
9.4 Comodines............................................................................................. 302
9.5 Métodos genéricos................................................................................. 303
Problemas resueltos ........................................................................................... 305
CAPÍTULO 10 Interfaces gráficas de usuario con Swing .......................... 321
10.1 Creación de una interfaz gráfica ........................................................... 321
10.2 Tratamiento de eventos: El modelo de delegación ................................. 321
10.2.1 Eventos, objetos fuente y objetos oyente ................................ 322
10.3 Jerarquía y tipos de eventos .................................................................. 322
10.4 Clases oyentes y adaptadoras de eventos .............................................. 322
10.5 Contenedores y componentes en Java ................................................... 323
10.6 Componentes gráficos: Jerarquía y tipos .............................................. 323
10.6.1 Clases básicas .......................................................................... 324
10.6.2 Contenedores de alto nivel ....................................................... 324
10.6.3 Cuadros de diálogo estándar .................................................... 324
x Contenido
10.6.4 Contenedores intermedios ........................................................ 326
10.6.5 Componentes atómicos ............................................................ 327
10.6.6 Otras clases gráficas de Swing ................................................ 331
10.7 Administradores de disposición o diseno (layout managers) ................. 331
10.7.1 FlowLayout .............................................................................. 331
10.7.2 BoxLayout ............................................................................... 331
10.7.3 BorderLayout ........................................................................... 332
10.7.4 CardLayout .............................................................................. 332
10.7.5 GridLayout .............................................................................. 332
10.7.6 GridBagLayout ........................................................................ 332
Problemas resueltos ........................................................................................... 333
CAPÍTULO 11 Applets ........................................................................... 381
11.1 Entorno y ciclo de vida de una applet ................................................... 381
11.2 Creación de una applet .......................................................................... 381
11.3 Clases Applet y JApplet ........................................................................ 382
11.4 HTML, XHTML y las applets: la marca
y la marca
Problemas resueltos ........................................................................................... 386
APÉNDICE A Documentación del código ............................................... 397
A.1 Etiquetas y posición .............................................................................. 398
A.2 Uso de las etiquetas ............................................................................... 398
A.3 Orden de las etiquetas ........................................................................... 400
A.4 Ejemplo de documentación de una clase ............................................... 400
APÉNDICE B Convenios de programación en Java .................................. 405
B.1 Estructura de un archivo fuente en Java ............................................... 405
B.2 Sangrado y tamano de las líneas ........................................................... 406
B.3 Comentarios .......................................................................................... 407
B.4 Declaraciones ........................................................................................ 408
B.5 Espacio en blanco ................................................................................. 408
B.6 Sentencias ............................................................................................. 409
B.7 Elección de nombres ............................................................................. 411
B.8 Prácticas de diseño ................................................................................ 412
*La edición digital no incluye códigos de acceso a material adicional o programas mencionados en el libro.
Se trata de un libro de ejercicios de programación en Java 2 diseñado para complementar a los libros de teoría de que ya disponemos siguiendo el método didáctico de la serie Schaum. La filosofía de elaboración del libro será mantener, por una parte, el espíritu de los libros de la colección a la que se incorpora y por otra, servir de material de aprendizaje progresivo para el alumno. No debe ser un libro donde se demuestren usos sofisticados del lenguaje ni programas complejos y difíciles de seguir. Cada tema tendrá un muy breve resumen de los elementos del lenguaje sobre los que se van a realizar los ejercicios del tema. A continuación, se propondrán y resolverán un conjunto de ejercicios de resolución básica; posteriormente, se propondrán problemas de dificultad creciente que vayan incorporando de forma combinada varios de los aspectos del tema, y para terminar, se elaborarán un conjunto de ejercicios que incorporen adicionalmente elementos de capítulos anteriores y permitan la realización de ejercicios más completos. Trata la versión 5.0 de Java 2, así como las anteriores
Ingeniero en Informática
Dpto. de Electrónica y Sistemas
Universidad Alfonso X El Sabio
Baltasar Fenández Manjón
Dr. en Ciencias Físicas
Dpto. de Ingeniería del Software e Inteligencia Artificial
Facultad de Informática
Universidad Complutense de Madrid
Gabriel Huecas Férnandez-Toribio
Dr. Ingeniero de Telecomunicación Dpto. Ingeniería de Sistemas Telemáticos Universidad Politécnica de Madrid
Jesús Allende Sánchez
Dr. Ingeniero de Telecomunicación Dpto. de Ingenierías TIC Universidad Alfonso X El Sabio
Pilar Moreno Díaz
Licenciada en Matemáticas Dpto. de Ingenierías TIC Universidad Alfonso X El Sabio
Ricardo Sosa Sánchez-Cortés
Ingeniero en Informática
Dpto. de Electrónica y Sistemas
Universidad Alfonso X El Sabio
