Todo se puede aprender
...si se quiere.
Home » » Manual Java Avanzado Para Rendir Certificaciones SCJP y SCJD

Manual Java Avanzado Para Rendir Certificaciones SCJP y SCJD

4 de marzo de 2018 | 13:43

Java es un lenguaje de programación creado por Sun Microsystems, (empresa que posteriormente fue comprada por Oracle) para poder funcionar en distintos tipos de procesadores. Su sintaxis es muy parecida a la de C o C++, e incorpora como propias algunas características que en otros lenguajes son extensiones: gestión de hilos, ejecución remota, etc.
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:


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....................................................................................... 4
  1.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)

Java Avanzado - Curso para rendir Certificaciones SCJP y SCJD
Compartir