Objetivos do Exame
Seção 1: Declarações, Inicialização e Definição de Escopo
- Desenvolver código que declare classes (inclusive classes abstratas e todas as formas de classes aninhadas), interfaces e enumerações e que inclua o uso apropriado de instruções de pacote e de importação (inclusive importações estáticas).
- Desenvolver código que declare uma interface. Desenvolver código que implemente ou estenda uma ou mais interfaces. Desenvolver código que declare uma classe abstrata. Desenvolver código que estenda uma classe abstrata.
- Desenvolver código que declare, inicialize e use primitivas, matrizes, enumerações e objetos como variáveis estáticas, locais e de instância. Além disso, usar identificadores legais para nomes de variáveis.
- Desenvolver código que declare métodos estáticos e não estáticos e, se for o caso, usar nomes de métodos que sigam os padrões de nomenclatura do JavaBeans. Além disso, desenvolver código que declare e use uma lista de argumentos de comprimento variável.
- Com base em um exemplo de código, determinar se um método está substituindo corretamente ou sobrecarregando outro método e identificar valores de retornos legais (inclusive retornos co-variantes) para o método.
- Com base em um conjunto de classes e superclasses, desenvolver construtores para uma ou mais dessas classes. Com base em uma declaração de classe, determinar se um construtor padrão será criado e, caso afirmativo, determinar o comportamento desse construtor. Com base em uma listagem de classes aninhadas ou não aninhadas, escrever código para criar uma instância da classe.
Seção 2: Controle de Fluxo
- Desenvolver código que implemente uma instrução if ou switch e identificar tipos de argumentos legais para essas instruções.
- Desenvolver código que implemente todas as formas de loops e iteradores, incluindo o uso de for, for loop aprimorado (for-each), do, while, labels, break e continue, e explicar os valores assumidos pelas variáveis de contador de loop durante e após a execução do loop.
- Desenvolver código que faça uso de declarações e distinguir os usos de declarações apropriados dos usos inapropriados.
- Desenvolver código que faça uso de exceções e de cláusulas de tratamento de exceções (try, catch, finally) e que declare métodos e métodos de substituição que gerem exceções.
- Reconhecer o efeito de uma exceção que surge em um ponto específico de um fragmento de código. Nota: a exceção pode ser uma exceção de tempo de execução, uma exceção verificada ou um erro.
- Reconhecer situações que resultarão na geração de um dos seguintes itens: ArrayIndexOutOfBoundsException, ClassCastException, IllegalArgumentException, IllegalStateException, NullPointerException, NumberFormatException, AssertionError, ExceptionInInitializerError, StackOverflowError ou NoClassDefFoundError. Compreender quais desses itens são gerados pela máquina virtual e reconhecer as situações nas quais outros itens devem ser gerados por programação.
Seção 3: Conteúdo da API
- Desenvolver código que use as classes wrapper de primitivas (como Boolean, Character, Double, Integer etc.) e/ou autoboxing e unboxing. Analisar as diferenças entre as classes String, StringBuilder e StringBuffer.
- Com base em um cenário de navegação em sistemas de arquivos, leitura de arquivos ou gravação em arquivos, desenvolver a solução correta usando as seguintes classes (às vezes, combinadas) no java.io: BufferedReader, BufferedWriter, File, FileReader, FileWriter e PrintWriter.
- Desenvolver código que serialize e/ou desserialize objetos usando as seguintes interfaces de programação de aplicativos (API - Application Programming Interface) do pacote java.io: DataInputStream, DataOutputStream, FileInputStream, FileOutputStream, ObjectInputStream, ObjectOutputStream e Serializable.
- Usar APIs J2SE padrão no pacote java.text para formatar ou analisar datas, números e valores monetários corretamente para uma localidade específica e, com base em um cenário, determinar os métodos apropriados se você desejar usar a localidade padrão ou uma localidade específica. Descrever o objetivo e o uso da classe java.util.Locale.
- Escrever código que use APIs J2SE padrão nos pacotes java.util e java.util.regex para formatar ou analisar strings ou fluxos. Para strings, escrever código que use as classes Pattern e Matcher e o método String.split . Reconhecer e usar padrões de expressões regulares para correspondência (limitados a: . (ponto), * (asterisco), + (sinal de mais), ?, \d, \s, \w, [], ()). O uso de *, + e ? será limitado aos quantificadores vorazes, e o operador de parênteses só será usado como mecanismo de agrupamento, e não para capturar conteúdo durante a correspondência. Para fluxos, escrever código usando as classes Formatter e Scanner e os métodos PrintWriter.format/printf. Reconhecer e usar parâmetros de formatação (limitados a %b, %c, %d, %f, %s) em strings de formato.
Seção 4: Simultaneidade
- Escrever código para definir, criar instâncias e iniciar novos segmentos usando java.lang.Thread e java.lang.Runnable.
- Reconhecer os estados possíveis de um segmento e identificar maneiras de fazer a transição de um segmento de um estado para outro.
- Com base em um cenário, escrever código que faça uso apropriado do bloqueio de objetos, para proteger variáveis estáticas ou de instâncias contra problemas de acesso simultâneo.
- Com base em um cenário, escrever código que faça uso apropriado de wait, notify notifyAll.
Seção 5: Conceitos Orientados a Objetos
- Desenvolver código que implemente encapsulamento rígido, acoplamento flexível e alto nível de coesão nas classes, e descrever os benefícios.
- Com base em um cenário, desenvolver código que demonstre o uso do polimorfismo. Além disso, determinar quando a intercalação será necessária e diferenciar os erros de compilação dos erros de tempo de execução relacionados à intercalação de referências de objetos.
- Explicar os efeitos dos modificadores na herança com relação a construtores, variáveis estáticas ou de instâncias e métodos estáticos ou de instâncias.
- Com base em um cenário, desenvolver código que declare e/ou invoque métodos substituídos ou sobrecarregados e código que declare e/ou invoque construtores de superclasse, substituídos ou sobrecarregados.
- Desenvolver código que implemente relacionamentos "é-um" e/ou "tem-um".
Seção 6: Coleções/Versões Genéricas
- Com base em um cenário de projeto, determinar quais interfaces e/ou classes de coleções devem ser usadas para implementar esse projeto de forma correta, incluindo o uso da interface Comparable.
- Distinguir substituições corretas e incorretas de métodos hashCode e equals correspondentes e explicar a diferença entre == e o método equals.
- Escrever código que use versões genéricas da API Collections, especialmente as interfaces Set, List e Map e as classes de implementação. Reconhecer as limitações da API Collections não-genérica e como refatorar o código para usar as versões genéricas.
- Desenvolver código que faça uso adequado de parâmetros de tipos em variáveis de instâncias, argumentos de métodos, tipos de retornos e declarações de classe/interface, além de escrever métodos genéricos ou métodos que façam uso de tipos de curingas e compreender as semelhanças e as diferenças entre essas duas abordagens.
- Usar recursos do pacote java.util para escrever código que manipule uma lista por classificação, executando uma pesquisa binária ou convertendo a lista em uma matriz. Usar recursos do pacote java.util para escrever código que manipule uma matriz por classificação, executando uma pesquisa binária ou convertendo a matriz em uma lista. Usar as interfaces java.util.Comparator e java.lang.Comparable para interferir na classificação de listas e matrizes. Além disso, reconhecer o efeito da "ordem natural" de classes wrapper de primitivas e java.lang.String na classificação.
Seção 7: Princípios Básicos
- Com base em um exemplo de código e um cenário, escrever código que use modificadores de acesso, declarações de pacotes e instruções de importação adequados para interagir (através de acesso ou herança) com o código do exemplo.
- Com base em um exemplo de classe e de linha de comando, determinar o comportamento em tempo de execução esperado.
- Determinar o efeito sobre referências de objetos e valores de primitivas quando eles forem passados aos métodos que executam atribuições ou outras operações de modificação de parâmetros.
- Com base em um exemplo de código, reconhecer em que ponto um objeto se qualifica para a coleta de lixo e determinar o que é garantido ou não pelo sistema de coleta de lixo. Reconhecer os comportamentos de System.gc e finalization.
- Com base em um nome totalmente qualificado de uma classe implantada dentro e/ou fora de um arquivo JAR, construir a estrutura de diretórios adequada a essa classe. Com base em um exemplo de código e um caminho de classe, determinar se o caminho de classe permitirá uma compilação bem-sucedida do código.
- Escrever código que aplique corretamente os operadores adequados, incluindo operadores de atribuição (limitados a =, +=, -=), operadores aritméticos (limitados a +, -, *, /, %, ++, --), operadores relacionais (limitados a <, <=, >, >=, ==, !=), o operador instanceof, operadores lógicos (limitados a &, |, ^, !, &amp;&, ||) e o operador condicional ( ? : ), a fim de produzir o resultado desejado. Escrever código que determine a igualdade de dois objetos ou duas primitivas.
|
