El código Java, una vez compilado, puede llevarse sin modificación alguna sobre cualquier máquina, y ejecutarlo. Esto se debe a que el código se ejecuta sobre una máquina hipotética o virtual, la Java Virtual Machine, que se encarga de interpretar el código (ficheros compilados .class) y convertirlo a código particular de la CPU que se esté utilizando (siempre que se soporte dicha máquina virtual).
Aunque el resto del curso de Experto está orientado a certificaciones en el ámbito de JEE, este módulo de Java y Herramientas de Desarrollo se basa en las certificaciones para Java básico o estándar. Dichas certificaciones son dos:
- Oracle Certified Professional Java Programmer (antes SCJP - Sun Certified Java Programmer): http://education.oracle.com/pls/web_prod-plq-dad/db_pages.getpage?page_id=320
- Oracle Certified Master, Java SE 6 Developer (antes SCJD - Sun Certified Java Developper): http://education.oracle.com/pls/web_prod-plq-dad/db_pages.getpage?page_id=321
Para la primera (SCJP), se debe completar un examen. En el caso del certificado para la plataforma Java, el examen abarca los siguientes apartados generales:
- Sección 1: Declaraciones, inicializaciones y ámbitos: evalúa si el alumno es capaz de escribir código que declare clases o interfaces, utilice adecuadamente la estructura de paquetes e imports, utilice código con tipos simples, arrays, objetos estáticos, variables locales, constructores, métodos estáticos y no estáticos, sobrecarga de métodos, etc
- Sección 2: Control de flujo: uso de sentencias if, switch, bucles (for, do, while, break, continue), manejo y uso de excepciones (try-catch-finally), etc
- Sección 3: Contenidos del API: uso de wrappers básicos (Integer, Boolean, etc), entrada/salida de ficheros, serialización de objetos para E/S, formateo de datos con el paquete java.text, y parseo de cadenas mediante expresiones regulares y similares (paquetes java.util y java.util.regex)
- Sección 4: Concurrencia: manejo de hilos (mediante Thread y mediante Runnable), estados de los hilos, interbloqueos y sincronización
- Sección 5: Conceptos sobre orientación a objetos: desarrollo de código que cumpla los requerimientos de encapsulamiento, cohesión y acoplamiento entre clases (mucha cohesión, poco acoplamiento). Uso del polimorfismo y del casting. Uso de métodos sobrecargados, llamadas a la superclase, etc.
- Sección 6: Colecciones: determinar qué tipos de colecciones (listas, hashmaps, etc) utilizar en diferentes supuestos. Comparaciones y ordenaciones entre objetos de una colección, etc
- Sección 7: Fundamentos: uso correcto de los modificadores de acceso, declaraciones de paquetes, imports. Seguimiento de trazas. Manejo de referencias a objetos. Uso del recolector de basura... etc
Para la segunda (SCJD) es necesario haber obtenido antes la primera certificación (SCJP). Después, se deben superar dos pruebas: un supuesto de programación, y un examen.
La primera prueba (el supuesto de programación), consiste en escribir código para implementar una supuesta aplicación para empresa. Se evaluarán aspectos como documentación, diseño orientado a objetos, desarrollo de la interfaz gráfica, interbloqueos, etc.
La segunda prueba (el examen), es una explicación sobre el desarrollo que hayamos hecho en el supuesto de programación anterior, explicando las decisiones principales que hemos tenido que tomar, ventajas y desventajas de las mismas, y justificación de dichas decisiones, en función de los objetivos propuestos para la implementación.
Más información sobre las certificaciones en los enlaces respectivos vistos antes.
Indice del manual:
1 Introducción al lenguaje Java....................................................................................... 41.1 Java.......................................................................................................................... 4
1.2 Conceptos previos de POO...................................................................................... 5
1.3 Componentes de un programa Java......................................................................... 7
1.4 Herencia e interfaces..............................................................................................16
1.5 Hilos.......................................................................................................................19
1.6 Clases útiles........................................................................................................... 23
1.7 Estructuras de datos............................................................................................... 29
2 Ejercicios de Introducción al lenguaje Java............................................................... 31
2.1 Uso de interfaces (1 punto)....................................................................................31
2.2 Refactorización (1 punto)...................................................................................... 32
2.3 Documentación (0.5 puntos)..................................................................................32
2.4 Centro cultural (1 punto)........................................................................................32
2.5 Copia de propiedades con BeanUtils (0.5 puntos).................................................33
3 Colecciones de datos.................................................................................................. 34
3.1 Colecciones............................................................................................................34
3.2 Comparación de objetos.........................................................................................45
3.3 Polimorfismo e interfaces...................................................................................... 47
3.4 Tipos de datos básicos en las colecciones..............................................................48
4 Ejercicios de colecciones............................................................................................50
4.1 Implementaciones e interfaces (1 punto)............................................................... 50
4.2 Uso de listas (1 punto)........................................................................................... 50
5 Tratamiento de errores................................................................................................52
5.1 Introducción........................................................................................................... 52
5.2 Errores en tiempo de ejecución: Excepciones....................................................... 52
5.3 Errores en tiempo de compilación......................................................................... 57
6 Ejercicios de tratamiento de errores........................................................................... 64
6.1 Captura de excepciones (0.5 puntos)..................................................................... 64
6.2 Lanzamiento de excepciones (0.5 puntos).............................................................64
6.3 Excepciones como tipos genéricos en la aplicación filmotecas(0.5 puntos)......... 66
6.4 Excepciones anidadas en la aplicación filmotecas (1.5 puntos)............................ 66
7 Casos de prueba: JUnit............................................................................................... 68
7.1 Introducción a JUnit...............................................................................................68
7.2 Integración de JUnit en Eclipse............................................................................. 68
7.3 Un ejemplo sencillo............................................................................................... 70
7.4 Fixtures.................................................................................................................. 79
7.5 Objetos mock......................................................................................................... 81
7.6 Suites de pruebas....................................................................................................87
8 Ejercicios de JUnit......................................................................................................89
8.1 Pruebas del gestor de filmotecas (2 puntos).......................................................... 89
8.2 Desarrollo guiado por pruebas (1 punto)............................................................... 90
9 Serialización de datos.................................................................................................92
9.1 Introducción........................................................................................................... 92
9.2 Flujos de datos de entrada/salida........................................................................... 92
9.3 Entrada, salida y salida de error estándar...............................................................93
9.4 Acceso a ficheros................................................................................................... 94
9.5 Acceso a los recursos.............................................................................................95
9.6 Acceso a la red.......................................................................................................96
9.7 Codificación de datos.............................................................................................96
9.8 Serialización de objetos......................................................................................... 97
10 Ejercicios de Serialización........................................................................................99
10.1 Leer un fichero de texto (0.5 puntos)................................................................... 99
10.2 Lectura de una URL (0.5 puntos).........................................................................99
10.3 Gestión de productos (1 punto)............................................................................ 99
10.4 Guardar datos de la filmoteca (1 punto).............................................................100
11 Depuración y gestión de logs..................................................................................102
11.1 Depuración con Eclipse......................................................................................102
11.2 Gestión de logs con Log4Java............................................................................107
11.3 La librería commons-logging.............................................................................114
12 Ejercicios de depuración y logging.........................................................................118
12.1 Depuración de código (1.5 puntos).................................................................... 118
12.2 Logs al leer ficheros (1.5 puntos).......................................................................118
13 Java Database Connectivity....................................................................................120
13.1 Introducción a JDBC..........................................................................................120
13.2 Consulta a una base de datos con JDBC............................................................ 124
13.3 Restricciones y movimientos en el ResultSet.................................................... 127
13.4 Sentencias de actualización................................................................................129
13.5 Otras llamadas a la BD.......................................................................................130
13.6 Optimización de sentencias................................................................................131
13.7 Transacciones.....................................................................................................133
14 Ejercicios de Java Database Connectivity.............................................................. 136
14.1 Filmoteca en MySQL.........................................................................................136
14.2 Conectar con la base de de datos (0.5 puntos)................................................... 137
14.3 Consulta sin parámetros (0.5 puntos).................................................................137
14.4 Sentencias preparadas (0.5 puntos).................................................................... 138
14.5 Sentencias de borrado de registros (0.5 puntos).................................................138
14.6 Sentencias de inserción de registros y valores autoincrementados (0.5 puntos)138
14.7 Transacciones (0.5 puntos).................................................................................139
15 Pruebas con DBUnit............................................................................................... 140
15.1 Introducción....................................................................................................... 140
15.2 DbUnit................................................................................................................140
15.3 Prácticas recomendadas......................................................................................141
15.4 Clases e interfaces.............................................................................................. 141
15.5 Estructura en un proyecto...................................................................................142
16 Ejercicios de DbUnit...............................................................................................146
16.1 Generar el XML de DbUnit (0.5 puntos)........................................................... 146
16.2 Clase para los test de DbUnit (1 punto)............................................................. 146
16.3 Test de borrado y añadido (0.5 puntos)..............................................................146
16.4 Test que espera una excepción (0.5 puntos).......................................................147
16.5 Test de borrado (0.5 puntos).............................................................................. 147
Hosting: Drive (Descarga Directa Para Desktop y Mobile)
Archivo: Pdf
Idioma: Español
Peso: (1.15 MB)
.jpg)
