Preparación examen scjp



Descargar 0,97 Mb.
Página1/8
Fecha de conversión21.07.2017
Tamaño0,97 Mb.
  1   2   3   4   5   6   7   8

Preparación examen SCJP

Preparación examen SCJP
Documento creado por: Javier Rodríguez Fernández de Tejada

Blog de Javier: http://javierrguez.wordpress.com/


Resúmenes traducidos del libro “Sun Certified Programmer for Java 6 Study Guide” por Matías

Blog de Matías: http://scjp-sun.blogspot.com/search/label/objetivos


Versión: 1.0
Índice


1 Objetivos 2

1.1 Detalles 2

1.2 Objetivos del Examen 2

1.2.1 Sección 1: Declaraciones, inicialización y ámbito 2

1.2.2 Sección 2: Control de flujo 2

1.2.3 Sección 3: Contenido del API 3

1.2.4 Sección 4: Concurrencia 3

1.2.5 Sección 5: Conceptos de la programación OO 3

1.2.6 Sección 6: Colecciones / Genéricos 4

1.2.7 Sección 7: Aspectos básicos 4



2 Resúmenes 5

2.1 Capítulo 1: Declaraciones y Control de acceso 5

2.2 Capítulo 2: Orientación a Objetos 11

2.3 Capítulo 3: Asignaciones 15

2.4 Capítulo 4: Operadores 21

2.5 Capítulo 5: Control de flujo, Excepciones y Assertions 23

26

2.6 Capítulo 6: Strings, I/O, Formateo y Parseo 27



2.7 Capítulo 7: Genéricos y Colecciones 34

2.8 Capítulo 8: Clases Internas 43

2.9 Capítulo 9: Hilos (Threads) 45

2.10 Capítulo 10: Development 48



3 Ejemplos Clases Internas 50

3.1 Introducción 50

3.2 Clases internas locales 51

3.3 Clases internas anónimas 52



3.4 Clases anidadas (Clases internas estáticas) 52


  1. Objetivos




    1. Detalles


  • Delivered at: Authorized Worldwide Prometric Testing Centers

  • Prerequisites: None

  • Other exams/assignments required for this certification: None

  • Exam type: Multiple choice and drag and drop

  • Number of questions: 60

  • Pass score: 58.33 % (35 of 60)

  • Time limit: 180 minutes
    1. Objetivos del Examen

      1. Sección 1: Declaraciones, inicialización y ámbito


  • Desarrollar código que declare clases (incluidas clases abstractas y todas las formas de clases anidadas), interfaces y enums, y que incluya el uso apropiado de instrucciones package e import (incluidas importaciones estáticas).

  • Desarrollar código que declare una interfaz. Desarrollar código que implemente o amplíe una o más interfaces. Desarrollar código que declare una clase abstracta. Desarrollar código que amplíe una clase abstracta.

  • Desarrollar código que declare, inicialice y use primitivas, arreglos, enums y objetos como variables estáticas, de instancia y locales. Asimismo, utilizar identificadores válidos para los nombres de variable.

  • Desarrollar código que declare métodos tanto estáticos como no estáticos y, si resulta adecuado, que utilice nombres de método con nomenclatura de JavaBeans. Además, desarrollar código que declare y utilice una lista de argumentos de longitud variable.

  • Con un ejemplo de código dado, determinar si un método está sobrescribiendo o sobrecargando correctamente otro método e identificar valores de retorno válidos (incluidos valores de retorno covariantes) para el método.

  • A partir de una serie de clases y superclases, desarrollar constructores para una o varias clases. Con una declaración de clase dada, determinar si se creará un constructor predeterminado y, en caso afirmativo, determinar su comportamiento. Con una lista de clases anidadas y no anidadas, escribir código para crear instancias de la clase.



      1. Sección 2: Control de flujo


  • Desarrollar código que implemente una instrucción if o switch e identificar tipos de argumentos válidos para estas instrucciones.

  • Desarrollar código que implemente todas las formas de ciclos e iteradores, incluidos el uso de for, el ciclo mejorado (for-each), do, while, labels, break y continue. Indicar los valores que adoptan las variables de control del ciclo durante y después de la ejecución del ciclo.

  • Escribir código que utilice afirmaciones y distinga entre el uso apropiado e inapropiado de las afirmaciones.

  • Desarrollar código que utilice excepciones y cláusulas de manejo de excepciones (try, catch, finally), y declarar métodos y sobreescribir métodos que generen excepciones.

  • Reconocer el efecto que produce una excepción que se genera en un punto dado de un fragmento de código. Puede ser una excepción runtime, una excepción comprobada (checked) o un error.

  • Reconocer las situaciones en las que se generará alguna de las siguientes exceptions: ArrayIndexOutOfBoundsException,ClassCastException, IllegalArgumentException, IllegalStateException, NullPointerException, NumberFormatException, AssertionError, ExceptionInInitializerError, StackOverflowError o NoClassDefFoundError. Saber cuáles genera la máquina virtual y en qué situaciones deberían generarse programáticamente otras exceptions.



      1. Sección 3: Contenido del API


  • Desarrollar código que utilice las clases wrapper primitivas (como booleno, carácter, doble, entero, etc.) y/o autoboxing y unboxing. Describir las diferencias entre las clases String, StringBuilder y StringBuffer.

  • En una situación en la que se requiera desplazarse por los file systems, leer archivos o escribir en archivos, desarrollar la solución adecuada mediante el uso de las siguientes clases (o una combinación de ellas) del paquete java.io: BufferedReader,BufferedWriter, File, FileReader, FileWriter y PrintWriter.

  • Desarrollar código que serialice y/o deserialice objetos mediante el uso de las siguientes API de java.io: DataInputStream, DataOutputStream, FileInputStream, FileOutputStream, ObjectInputStream, ObjectOutputStream y Serializable.

  • Utilizar API de J2SE estándar del paquete java.text para asignar formato y analizar correctamente fechas, números y valores de moneda de una configuración regional específica. En una situación dada, determinar los métodos que se deben utilizar si se desea emplear la configuración regional predeterminada u otra específica. Describir el objetivo y la utilidad de la clase java.util.Locale.

  • Escribir código que utilice API de J2SE estándar de los paquetes java.util y java.util.regex para asignar formato o analizar cadenas o secuencias. Para cadenas, escribir código que utilice las clases Pattern y Matcher y el método String.split. Reconocer y utilizar patrones de expresión regulares para establecer la coincidencia (limitado a: . (punto), * (asterisco), + (signo más), ?, \d, \s, \w, [], ()). El uso de *, + y ? se limitará a cuantificadores greedy y el operador de paréntesis sólo se empleará como mecanismo de agrupación, en lugar de para capturar contenido durante la coincidencia. Para secuencias, escribir código utilizando las clases Formatter y Scanner y los métodos PrintWriter.format/printf. Reconocer y utilizar los parámetros de formato (limitado a: %b, %c, %d, %f, %s) en cadenas de formato.



      1. Sección 4: Concurrencia


  • Escribir código para definir, instanciar e iniciar nuevos threads utilizando java.lang.Thread y java.lang.Runnable.

  • Reconocer los estados en los que puede existir un thread, e identificar condiciones en las que puede pasar de un estado a otro.

  • En una situación dada, escribir código que utilice correctamente el bloqueo de objetos para proteger las variables estáticas o de instancia de los problemas de acceso concurrente.

  • En una situación dada, escribir código que utilice correctamente wait, notify o notifyAll.



      1. Sección 5: Conceptos de la programación OO


  • Desarrollar código que implemente encapsulación estricta, emparejamiento ligero y gran cohesión en las clases, y describir las ventajas que ofrece.

  • En una situación dada, desarrollar código que demuestre el uso del polimorfismo. También determinar cuándo se va a necesitar la conversión de tipos y distinguir los errores del compilador de los errores de tiempo de ejecución relacionados con la conversión de referencias de objeto.

  • Explicar el efecto de los modificadores en la herencia en lo que se refiere a constructores, variables de instancia o estáticas y métodos de instancia o estáticos.

  • En una situación dada, desarrollar código que declare y/o llame a métodos sobrescritos o sobrecargados y código que declare y/o llame a constructores de superclase, sobrescritos o sobrecargados.

  • Desarrollar código que implemente relaciones "is-a" y/o "has-a".



      1. Sección 6: Colecciones / Genéricos


  • En una situación de diseño dada, determinar las clases o interfaces de colección que deberían utilizarse para implementar ese diseño de forma adecuada, incluido el uso de la interfaz Comparable.

  • Distinguir entre los valores de reemplazo correctos e incorrectos de los métodos hashCode y equals correspondientes, y explicar la diferencia entre == y el método equals.

  • Escribir código que utilice las versiones genéricas de las colecciones del API, en particular las interfaces Set, List y Map y las clases de implementación. Identificar las limitaciones de las colecciones API no genéricas y cómo refactorizar código para utilizar versiones genéricas. Escribir código que use las interfacces NavigableSet y NavigableMap.

  • Desarrollar código que utilice correctamente los parámetros de tipo en las declaraciones de clase/interfaz, las variables de instancia, los argumentos de métodos y los tipos de retorno. Escribir métodos genéricos o métodos que utilicen comodines y comprender las similitudes y diferencias entre estos dos métodos.

  • Utilizar las funciones del paquete java.util para escribir código destinado a manipular una lista para ordenarla, realizando un búsqueda binaria o convirtiéndola en un arreglo. Utilizar las funciones del paquete java.util para escribir código destinado a manipular un arreglo ordenándolo, realizando un búsqueda binaria o convirtiéndolo en una lista. Utilizar las interfaces java.util.Comparator y java.lang.Comparable para afectar la clasificación de las listas y los arreglos. Además, conocer el efecto que produce la "ordenación natural" de las clases primitivas wrapper y java.lang.String al ordenar.
      1. Sección 7: Aspectos básicos


  • Dado un ejemplo de código y una situación, escribir código que utilice los modificadores de acceso, las declaraciones package y las instrucciones import adecuadas para interactuar (a través de acceso o herencia) con el código del ejemplo.

  • Con un ejemplo de una clase y una línea de comandos, determinar el comportamiento previsto del tiempo de ejecución.

  • Determinar cómo afectan las referencias de objeto y valores primitivos cuando son pasados a métodos que realizan asignaciones u otras modificaciones en los parámetros.

  • Con un ejemplo de código reconocer el momento en el que un objeto se convierte en elegible del garbage collection, determinar que está y que no está garantizado por el sistema del garbage collection y reconocer los comportamientos del mètodo Object.finalize().

  • Con el nombre completo de una clase que se implementa dentro y/o fuera de un archivo JAR, construir la estructura de directorios adecuada a dicha clase. Con un ejemplo de código y una ruta de clase dados, determinar si la ruta de clase permite que el código se compile correctamente.

  • Escribir código que aplique correctamente los operadores adecuados para obtener el resultado deseado, incluidos los operadores de asignación (limitados a: =, +=, -=), los operadores aritméticos (limitado a: +, -, *, /, %, ++, --), los operadores relacionales (limitado a: <, <=, >, >=, ==, !=), el operador instanceof, los operadores lógicos (limitado a: &, |, ^, !, &&, ||) y el operador condicional ( ? : ), para producir un resultado deseado. Escribir código que determine la igualdad de dos objetos o dos primitivas.



  1. Resúmenes

    1. Capítulo 1: Declaraciones y Control de acceso


A continuación dejo un link con los objetivos del exámen de certificación SCJP.

LINK
Actualmente estoy leyendo el libro "Sun Certified Programmer for Java 6 Study Guide" (el cuál puede ser descargado desde el proyecto de google o haciendo click aquí). Hoy termine de leer el primer capítulo el cuál tiene el mismo nombre que esta entrada (Declarations and Access Control). Lo bueno de este libro es que al final de cada capítulo hay un resumen con todos los items importantes a tener en cuenta a la hora de rendir el examen. Esta sección se llama "TWO-MINUTE DRILL". También contiene un mini examen para autoevaluarse con los tópicos tratados en el capítulo.

A continuación dejo el resumen del capítulo (traducido por mí) del libro. Espero que les sea de utilidad.


Identificadores (Objetivo 1.3):

  • Los identificadores pueden comenzar con una letra, un guión bajo o un carácter de moneda.

  • Luego del primer carácter, los identificadores pueden incluir dígitos.

  • Pueden ser de cualquier longitud.

  • La especificación JavaBeans establece que los métodos deben definirse utilizando camelCase, y dependiendo del propósito del método, deben comenzar con get, set, is, add o remove (estos últimos dos deben terminar con el sufijo Listener).

Reglas de declaración (Objetivo 1.1):

  • Un archivo de código fuente solo puede contener una clase pública.

  • Si el archivo contiene una clase pública, el nombre del mismo debe ser igual al nombre de esa clase pública.

  • Un archivo solo puede contener una declaración de package, pero múltiples declaraciones de imports.

  • Si existe la declaración package, esta debe estar en la primera línea (que no sea un comentario) del archivo.

  • Si existe la declaración de imports, deben estar luego de la declaración package y antes de la declaración de la clase.

  • Si no existe la declaración package, la declaración import debe estar en la primera línea (que no sea un comentario) del archivo.

  • Las declaraciones package y import, aplican a todas las clases del archivo.

  • Un archivo puede contener más de una clase no pública.

  • Los archivos sin ninguna clase pública no tienen restricciones de nombre.

Modificadores de acceso a clase (Objetivo 1.1):

  • Existen tres modificadores de acceso: public, protected y private.

  • Existen cuatro niveles de acceso: public, protected, default y private.

  • Las clases solo pueden ser declaradas con acceso public o default.

  • Una clase con acceso default solo puede ser vista por las clases dentro del mismo paquete.

  • Una clase con acceso public puede ser vista por todas las clases de todos los paquetes.

  • La visibilidad de clases consiste en si el código de una clase puede:

    • Crear una instancia de otra clase.

    • Extender otra clase (a través de la herencia).

    • Acceder a métodos y variables de otra clase.

Modificadores de clase (Sin acceso) (Objetivo 1.2):

  • Las clases también pueden ser modificadas con final, abstract o strictfp.

  • Una clase no puede ser final y abstract.

  • Una clase final no puede ser extendida.

  • Una clase abstract no puede ser instanciada.

  • Un método abstracto dentro de una clase significa que la clase entera debe ser abstract.

  • Una clase abstracta puede tener métodos abstractos y no abstractos.

  • La primera clase concreta que extienda de una clase abstracta debe implementar todos los métodos abstractos.

Implementación de interfaces (Objetivo 1.2):

  • Las interfaces son contratos sobre lo que puede hacer una clase, pero no dicen nada acerca de cómo deben realizarlo.

  • Las interfaces pueden ser implementadas por cualquier clase, de cualquier árbol de herencia.

  • Una interface es como una clase abstracta al cien por ciento. Y es implícitamente abstracta más allá de que contenga o no el modificador abstract.

  • Una interface solo puede contener métodos abstractos.

  • Los métodos de una interface son por defecto públicos y abstractos, la declaración implícita de estos modificadores es opcional.

  • Las interfaces pueden contener constantes, las cuales siempre son public, static y final (la declaración implícita puede hacerse en cualquier orden).

  • Una clase concreta que implemente una interface tiene las siguientes propiedades:

    • Provee implementaciones concretas para los métodos abstractos de la interface.

    • Debe seguir todas las reglas de sobreescritura de los métodos que implementa.

    • No debe añadir ninguna nueva excepción a los métodos implementados. (Solo las excepciones declaradas en la interface pueden ser lanzadas desde el método).

    • Debe mantener la misma signatura y tipo de retorno (también se permiten los tipos de retorno covariantes) de los métodos que implementa.

  • Una clase que implemente una interface también puede ser abstract.

  • Una clase abstracta que implemente una interface no necesita implementar los métodos de la misma (pero sí lo debe hacer la primer clase no abstracta que la extienda).

  • Una clase puede extender solo de una sola clase (no está permitida la herencia múltiple), pero si puede implementar muchas interfaces.

  • Las interfaces pueden extender de una o más interfaces.

  • Las interfaces no pueden extender una clase, o implementar una clase o interface.


Modificadores de acceso de miembros (Objetivo 1.3 y 1.4):

  • Los miembros son los métodos y variables de instancia.

  • Los miembros pueden utilizar los cuatro niveles de acceso: public, protected, default y private.

  • Los accesos a los miembros se pueden realizar de dos formas:

    • Código en una clase que puede acceder a un miembro de otra clase.

    • Una subclase que puede heredar un miembro de una superclase.

  • Si no se puede acceder a una clase, tampoco se podrá acceder a sus miembros.

  • Determinar la visibilidad de una clase, antes de determinar la visibilidad de sus miembros.

  • Los miembros públicos pueden accederse desde todas las demás clases, incluso en otros paquetes.

  • Si la superclase contiene un miembro público, la subclase lo hereda.

  • Los miembros accedidos sin el operador punto (.) deben pertenecer a la misma clase.

  • La palabra clave this siempre se refiere al objeto que se está ejecutando. Dentro de la misma clase this.unMetodo() es lo mismo que invocar unMetodo().

  • Los miembros privados solo pueden accederse desde el código de la misma clase.

  • Los miembros privados no son visibles para las subclases, o sea no pueden ser heredados.

  • Los miembros default y protected difieren solo en lo relacionado a las subclases:

    • Miembros default pueden ser accedidos solo por las clases pertenecientes al mismo paquete.

    • Miembros protected pueden ser accedidos por otras clases pertenecientes al mismo paquete, y además por las subclases pertenecientes a otros clases.

    • Para las subclases fuera del paquete, los miembros protected solo pueden ser accedidos a través de la herencia. Una subclase fuera del paquete no puede acceder a los miembros protegidos a través de una referencia a una instancia de la superclase.



Variables locales (Objetivo 1.3):

  • Las declaraciones de variables locales no pueden tener modificadores de acceso.

  • El único modificador que se puede aplicar a las variables locales es final.

  • Las variables locales no poseen valores por default (a diferencia de las variables de instancia), por lo que deben ser inicializadas antes de utilizarlas.


Otros modificadores de miembros (Objetivo 1.3):

  • Los métodos final no pueden ser sobreescritos por las subclases.

  • Los métodos abstractos son declarados con una signatura, un tipo de retorno, opcionalmente se puede agregar la clausula throws, pero no están implementados.

  • Los métodos abstractos terminan con punto y coma, no con llaves.

  • La primera clase concreta que extienda a una clase abstracta debe implementar todos los métodos abstractos.

  • El modificador synchronized puede ser aplicado solo a métodos y a bloques de código.

  • Los métodos synchronized pueden tener cualquier control de acceso y también pueden ser final.

  • Los métodos abstractos deben ser implementados por las subclases, por este motivo:

    • Los métodos abstract no pueden ser private.

    • Los métodos abstract no pueden ser final.

  • El modificador native solo se puede aplicar a los métodos.

  • El modificador strictfp solo se puede aplicar a las clases y métodos.


Métodos con var-args (Objetivo 1.4):

  • Desde Java 5, los métodos pueden contener un parámetro que acepte desde cero a muchos argumentos, este tipo de parámetro se denomina var-arg.

  • Un parámetro var-arg es declarado con la sintaxis: doStuff(int… x) { }.

  • Un método solo puede contener un parámetro var-arg.

  • Un método con parámetros normales y uno var-arg, el var-arg debe ser el último parámetro.


Declaraciones de variables (Objetivo 1.3):

  • Las variables de instancia pueden:

    • Tener cualquier control de acceso.

    • Ser final o transient.

  • Las variables de instancia no pueden ser abstract, synchronized, native, o strictfp.

  • Es legal declarar una variable local con el mismo nombre que una variable de instancia, esto se llama “Shadowing”.

  • Las variables finales tienen las siguientes propiedades:

    • No pueden ser reinicializadas una vez que ya se le ha asignado un valor.

    • Las referencias finales no pueden apuntar a otro objeto, una vez que un objeto ya ha sido asignado.

    • Las referencias finales deben ser inicializadas antes de completarse la ejecución del constructor.

  • Una referencia final a un objeto, no significa que el objeto no pueda cambiar su estado.

  • El modificador transient es aplicable solo a las variables de instancia.

  • El modificador volatile es aplicable solo a las variables de instancia.



Declaraciones de arreglos “Arrays” (Objetivo 1.3):

  • Los arreglos pueden contener tipos primitivos u objetos, pero el arreglo en sí mismo es siempre un objeto.

  • Cuando se declara un arreglo, los corchetes pueden ir antes o después del nombre de la variable.

  • No es legal incluir el tamaño del arreglo en la declaración del mismo. (Esto se puede hacer en la instanciación del mismo)

  • Un arreglo de objetos de un tipo puede contener cualquier objeto hijo de ese tipo.


Variables y métodos estáticos (Objetivo 1.4):

  • No se relacionan con ninguna instancia de clase.

  • No se necesitan instancias de clases para acceder a los miembros estáticos.

  • Solo existe una copia de las variables estáticas de una clase, y todas las instancias de la clase la comparten.

  • Los métodos estáticos no tienen acceso directo a los miembros no estáticos.


Enumeraciones “Enums” (Objetivo 1.3):

  • Un enum especifica una lista de valores constantes asignados a un tipo.

  • Un enum no es un objeto String, es un objeto de tipo enum.

  • Un enum puede ser declarado dentro o fuera de una clase, pero no en un método.

  • Un enum declarado fuera de una clase no puede ser static, final, abstract, protected o private.

  • Los enums pueden pueden contener constructores, métodos, variables, y cuerpos de clase constantes (constant class bodies).

  • Las constantes enums pueden enviar argumentos al constructor del enum, usando la sintaxis BIG(8), en donde el literal 8 es pasado al constructor como argumento.

  • Los constructores enum pueden tener argumentos y pueden ser sobrecargados.

  • Los constructores de enums no pueden ser invocados directamente. Estos son llamados automáticamente cuando un enum es inicializado.

  • El punto y coma final de la declararión de un enum es opcional.

  • El método MyEnum.values() retorna un arreglo con todos los valores del enum.



  1   2   3   4   5   6   7   8


La base de datos está protegida por derechos de autor ©absta.info 2016
enviar mensaje

    Página principal