Publicado el 19 de Junio del 2019
1.185 visualizaciones desde el 19 de Junio del 2019
2,6 MB
274 paginas
Creado hace 13a (22/10/2010)
Fundamentos de la
programación en JAVA
Departamento de Formación
Ingeniería de Software Avanzado
03/03/2010
Contenido
1.
¿Qué es Java? ........................................................................................................... 1
1.1. Características de Java ....................................................................................... 4
1.1.1.
El software Development Kit de Java ......................................................... 6
1.2. El software Development Kit de Java ................................................................ 7
1.3. Versiones de Java ............................................................................................... 8
1.4.
Instalación y configuración del Kit J2SE ........................................................... 10
1.5. El API del SDK ................................................................................................... 13
1.6. Como compilar archivos .................................................................................. 14
1.7. El Classpath ...................................................................................................... 15
1.8. Ejecución de programas en Java ...................................................................... 16
1.9. Empaquetar clases (JAR) .................................................................................. 17
1.9.1
Crear un fichero JAR ................................................................................. 17
1.9.2
Listar un fichero JAR ................................................................................. 18
1.9.3 Modificar un fichero JAR .......................................................................... 18
1.9.4
Como ejecutar un JAR ............................................................................... 19
1.9.5
El fichero MANIFIESTO ............................................................................. 19
2. Programación Orientada a Objetos ........................................................................ 21
2.1 Objeto .............................................................................................................. 22
2.2
Clase ................................................................................................................. 24
2.3 Mensajes .......................................................................................................... 25
2.4 Herencia ........................................................................................................... 26
2.5
Polimorfismo .................................................................................................... 27
3. Preparando el entorno ........................................................................................... 28
3.1. Mi primera clase .............................................................................................. 28
3.2. Convenciones y nomenclatura en la programación Java ................................ 30
4.
Sintaxis del lenguaje ............................................................................................... 31
4.1.
Identificadores ................................................................................................. 31
4.2. Palabras clave .................................................................................................. 32
4.3. Comentarios ..................................................................................................... 32
i
4.3.1
Formato JavaDoc ...................................................................................... 33
4.3.2
La herramienta JavaDoc ........................................................................... 35
4.4. Tipos de datos .................................................................................................. 36
4.4.1
El recolector de basura “Garbage Collector” ........................................... 37
Finalización de los objetos .................................................................................. 39
4.4.2
Stack y Heap ............................................................................................. 40
Stack .................................................................................................................... 40
Heap .................................................................................................................... 40
Cómo interactúan el Stack y el Heap .................................................................. 41
4.4.3
Tipo primitivo entero ................................................................................ 42
4.4.4
Tipo primitivo coma flotante .................................................................... 42
4.4.5
Tipo primitivo boolean ............................................................................. 42
4.4.6
Secuencias de escape ............................................................................... 43
4.4.7
Literales .................................................................................................... 43
4.4.8
Variables ................................................................................................... 45
Declaración de una variable ............................................................................... 45
Asignación ........................................................................................................... 45
Ámbito de las variables ...................................................................................... 46
4.5. Conversiones .................................................................................................... 47
4.5.1
Conversiones implícitas ............................................................................ 47
4.5.2
Conversiones explícitas ............................................................................ 48
4.6. Constantes ....................................................................................................... 48
4.7. Expresiones ...................................................................................................... 49
4.8. Operadores ...................................................................................................... 49
4.8.1 Operadores sobre enteros ....................................................................... 50
4.8.2 Operadores sobre reales .......................................................................... 51
4.8.3
Booleanos ................................................................................................. 51
4.8.4
Asignación ................................................................................................. 52
4.8.5
Procedencia de los operadores ................................................................ 52
4.9.
Instrucciones de control .................................................................................. 53
4.9.1.
if-else ........................................................................................................ 53
4.9.2.
switch ........................................................................................................ 54
ii
4.9.3.
for ............................................................................................................. 55
Bucle for mejorado ............................................................................................. 56
4.9.4. while ......................................................................................................... 57
4.9.5. do-while .................................................................................................... 57
4.9.6.
Salida forzada de un bucle ........................................................................ 58
break ................................................................................................................... 58
continue .............................................................................................................. 58
etiquetas ............................................................................................................. 59
4.10. El método main() ............................................................................................. 60
4.11. Arrays ............................................................................................................... 61
4.11.1.
Declaración ........................................................................................... 61
4.11.2.
Dimensionado de un array .................................................................... 61
4.11.3.
Acceso a los elementos de un array ..................................................... 62
4.11.4.
Paso de un array como argumento de llamada a un método .............. 63
4.11.5.
Recorrido de arrays con for-each. Enhanced for Loop ......................... 64
4.11.6.
Arrays multidimensionales ................................................................... 66
4.11.7.
Recorrido de un array multidimensionales .......................................... 66
4.11.8.
Arrays multidimensionales irregulares ................................................. 67
4.11.9.
Arrays de objetos .................................................................................. 67
4.12. Tipos Enumerados............................................................................................ 68
4.12.1.
Definición de un tipo enumerado ......................................................... 68
4.12.2.
Clase Enumeración ................................................................................ 69
Construc
Comentarios de: Fundamentos de la programación en JAVA (0)
No hay comentarios