Exame Certificação JAVA, Exercícios de Informática

Baixe Exame Certificação JAVA e outras Exercícios em PDF para Informática, somente na Docsity!

Exercícios

para o

Exame de Certificação em Java

Capítulo 01

Questionário

1. Verdadeiro ou Falso: Um tipo de dados assinado tem um número igual de non-zero positivo e negativo estima disponível.

Falso. O alcance de número negativo é maior por 1 que o alcance de números positivos.

2. Escolha o identificadores válido desses listados abaixo.

A. Big01LongStringWiº B. $int C. bytes D. $ E. finalista

Todos os identificadores são válidos.

3. O qual das assinaturas seguintes são válidos para o principal () ponto de entrada de método de uma aplicação?

B. público arg de main(String nulo estático []) D. público main(String nulo estático [] arg)

As alternativas B e D são ambas aceitáveis.

4. Se todos os três " elementos de topo-nível " acontecem em um arquivo de fonte, eles têm que aparecer em qual ordem?

A. Importações, declaração de pacote, classes, B. Classes, importações, declarações de pacote, C. Declaração de pacote tem que vir primeiro; ordene para importações e definições de classe não são significantes. D. Empacote declaração, importações, classes, E. Importações têm que vir primeiro; ordene para declaração de pacote e definições de classe não são significantes.

A alternativa D está correto. Esta ordem deve ser observada estritamente.

7. Considere a aplicação seguinte:
   1. class Q7 {
   2. public static void main(String args[]) {
   3. double d = 12.3;
   4. Decrementer dec = new Decrementer();
   5. Dec.decrement(d);
   6. System.out.println(d);
   7. }
   8. }
   10. class Decrementer {
   11. public void decrement(double decMe)
   12. { decMe = decMe – 1.0;}
   13. }

Que valor será impresso na linha 6?

A. 0. B. -1. C. 12. D. 11.

A alternativa C está correta. O passado para o método decrement () uma cópia do argumento d; a cópia adquire decremento, mas o original está intacto.

Observe a diferença entre esta questão e a anterior:

Nesta questão o método Decrementer trabalha com uma cópia do parâmetro passado:

public void decrement(double decMe) {decMe = decMe – 1.0;}

Na questão anterior (6), o método trabalha diretamente com variável.

Public void bump(Holder theHolder) {theHolder.held++ ;}

8. Como você pode forçar o Garbage Collection de um objeto?

A. Garbae não podem ser forçados. B. Chame System.gc (); C. Chame System.gc (), passando em uma referência ao objeto a ser Garbage-collected. D. Chame Runtime.gc () E. Fixe todas as referências para o objeto para valores novos (nulo, por exemplo).

A alternativa A está correta. Garbage colletion não pode ser forçado. Chamando System.gc () ou Runtime.gc () não é 100 por cento fidedigno, desde que a linha de Garbage-Collection poderia adiar a uma linha de prioridade mais alta; assim B e D estão incorretos. C está incorreto porque o dois métodos gc () não levam argumentos; de fato, isto você ainda tem uma referência para passar no método, o objeto não é contudo elegível ser colecionado. A alternativa E fará o objeto elegível para coleção o da próxima vez as corridas de coleção de lixo.

9. Qual é o alcance de valores que podem ser nomeados a uma variável do tipo short?

A. Depende do hardware subjacente. B. 0 até 216 - 1 C. 0 até 232 - 1 D. 2^15 até 215 - 1 E. 2^31 até 231 - 1

A alternativa D está correto. O alcance para um 16 bit pequeno é – 215 por 2^15 - 1. Este alcance é parte da especificação de java, embora o hardware subjacente.

10. Qual é o alcance de valores que podem ser nomeados a uma variável do tipo byte?

A. Depende do hardware subjacente. B. 0 por 2^8 - 1 C. 0 por 2^16 - 1 D. 2^7 por 2^7 - 1 E. 2^15 por 2^15 - 1

A alternativa D está correta. O alcance para uns 8-bit pequeno é – 27 por 27 - 1.

A alternativa A está correta. Em todo caso, o padrão de bit para -1 é " todo os uns ". Na alternativa A isto é trocado à direita no máximo cinco lugares com a introdução de bits 0 de posições significantes. O resultado é 271 pedaços na posição menos significante do valor de int. Considerando que o bit mais significante é 0, isto representa um valor positivo (de fato 134217727). Na alternativa B o valor de troca é 32 bits. Isto resultará em nenhuma mudança para a variável x, desde que seja executado de fato por (32 mod 32) bits que é igual 0. Assim em B o valor de x está inalterado ( - 1). Na alternativa C é realmente ilegal como o resultado de x >>> 5 é do tipo int, e não pode ser trocada para o tipo byte x sem declaração explícita. Até mesmo se o elenco foi somado e dá para byte x = -1; x = (byte) (x >> >5); o resultado da expressão x >>> seria calculada de 5 formas:

1. Primeiro promove x para o tipo int. Isto dá um resultado sinal- estendido que é um int -1 com 321 pedaços.
2. Executa a troca; isto se comporta da mesma forma do iten anterior, dando 134217727 que é o valor de 271 bits int das posições menos significantes.
3. Trocando o resultado da expressão simplesmente "cortar", os oito bits menos significantes, desde que todos estes sejam "uns", o byte resultante representa -1. Finalmente, a alternativa D executa uma troca assinada que propaga 1 bits na posição mais significante. Assim, neste caso, o valor resultante de x está inalterado a - 1.
4. Qual das expressões seguintes são legais? (Escolhe uma ou mais).

A. String x = Oi "; int y = 9; x + = y; B. String x = Oi "; int y = 9; se (x == y) {} C. String x = Oi "; int y = 9; x = x + y; D. String x = Oi "; int y = 9; y = y + x; E. String x = nulo; int y = (x! = null) && (x.length ()> 0)? x.length (): 0;

As alternativas A, C e E são todas legais. Na alternativa A o uso de

• = é tratado como uma taquigrafia para a expressão em C. Isto tenta "somar " um int para uma String que resulta em conversão do int para o tipo String -" 9 " neste caso - há a concatenação dos dois objetos para String. Assim neste caso, é executado o valor de x depois do código é " Hello9 ". Na alternativa B a comparação (x == y) não é legal, porque apenas o operador + executa conversão implícita para um objeto String. A y variável é do tipo int e não pode ser comparado com um valor de referência. Não esqueça daquela comparação == que usa nos testes os valores e que para objetos, o " valor " é o valor de referência e não os conteúdos.

A alternativa C é idêntica a alternativa A sem o uso do operador de tarefa de taquigrafia.

A alternativa D calcula y + x que é legal em si mesmo porque produz uma String da mesma maneira como fez x + y. Ela tenta nomear o resultado que é " 9Hello " em uma variável de int então. Como o resultado de y + x é uma String, isto não é permitido.

A alternativa E é bastante diferente das outras. Os pontos importantes são o uso de curto circuito o operador && e o operador ternário?:. O operador à esquerda do && é o operador que sempre é avaliado, e neste caso a condição (x != nulo) é falsa. Porque isto é falso, a parte da mão direita da expressão (x.length ( )> 0) não precisa ter sido avaliada, porque o resultado do operador && é conhecido para ser falso. Iste pequeno-cirucuito é efetue nitidamente e evita a execução da chamada de método x.length () que falharia com um NullPointerException no momento da sua corrida. Este resultado falso é então usado na avaliação da expressão ternária. Como o valor de boolean é falso, o resultado da expressão global volta à direita o valor do cólon que é 0.

5. Qual dos fragmentos de código seguintes compilaria prosperamente e imprimiria " Iguale " quando corre? (Escolha uma ou mais)

A. int x = 100; float y = 100.0F; if (x == y) {System.out.println(“Equal ”);}

B. int x = 100; Interger y = new Interger(100); if (x == y) {System.out.println(“Equal ”);}

C. Integer x = new Integer(100); Integer y = new Integer(100); if (x == y) {System.out.println(“Equal ”);}

D. String x = new String(“ 100 ”); String y = new String(“ 100 ”); if (x == y) {System.out.println(“Equal ”);}

E. String x = “ 100 ”; String y = “ 100 ”; if (x == y) {System.out.println(“Equal ”);}

As alternativas A e E estão corretas. Embora int e float não sejam compatíveis, eles geralmente podem ser misturados em qualquer lado de um operador. Desde então == não é nenhuma tarefa mas do que um operador de comparação, isto simplesmente causa promoção normal, de forma que o int é promovido a um valor do tipo float 9.0 e é comparado

A alternativa A está correta. O efeito do operador && é primeiro avaliar o operando à esquerda. Isso é a expressão (s.length( )> 5). Como o tamanho do objeto de StringBuffer s é de fato 5, este teste devolve falso. Usando a identidade lógica falso AND X = falso, o valor do condicional global é completamente determinado, e o && o operador salta avaliação do operando da mão direita então. Como resultado, o valor no objeto de StringBuffer ainda é simplesmente " Oi " quando for impresso.

Se o teste no lado à esquerda de && tinha devolvido verdadeiro, como teria acontecido tido o StringBuffer contido um segmento de texto mais longo, então o lado da mão direita teria sido avaliado. Embora poderia parecer um pouco estranho, aquela expressão, (s.append (lá ").equals (false ")), é válido e retorna um boolean. De fato, é garantido o valor da expressão ser falso, desde que é claramente impossível para qualquer StringBuffer conter precisamente " Falso " quando teve há pouco uma String " lá " juntado a isto. Isto é porém irrelevante - a essência desta expressão é que, se é avaliado, tem o efeito colateral de mudar o StringBuffer original juntando o texto " lá ".

7. Qual é o resultado obtido após a execução do seguinte código:
   1. public class Xor {
   2. public static void main(String args[ ]) {
   3. byte b = 10; // 00001010 binary
   4. byte c = 15; // 00001111 binary
   5. b = (byte) (b ^ c);
   6. System.out.println(“b contains “ + b);
   7. }
   8. }

A. O valor de saída é b = 10.

B. O valor de saída é b = 5.

C. O valor de saída é b = 250.

D. O valor de saída é b = 245.

A alternativa B está correta. O uso exclusivo do operador or ^ trabalha nos pares de pedaços em posição equivalente no dois operadores. Neste exemplo produz isto:

00001010 00001111

XOR --------------

A advertência é que os únicos 1 bits na resposta estão nessas colunas onde exatamente um do operandos tem um 1 bit. Se nenhum, ou ambos, os operandos tem um 1, então os resultados serão 0 bit.

O valor 00000101 binário corresponde a 5 decimal.

É preço que se lembra que, embora este exemplo foi mostrado como um cálculo de byte, o funcionamento atual é int usando acabado (32- bit) valores. Isto é por que o elenco explícito é requerido antes do resultado é nomeado no b variável em linha 5.

8. Qual o resultado obtido após a execução do seguinte código?
   1. public class Ternary {
   2. public static void main(String args[ ]) {
   3. int x = 4;
   4. System.out.println(“value is “ +
   5. (( x > 4)? 99.99 : 9 ));
   6. }
   7. }

A. O valor de saída é 99.99.

B. O valor de saída é 9.

C. O valor de saída é 9.0.

D. Ocorrerá um erro de compilação na linha 5.

A alternativa C está correta. Neste código os valores de resultado opcionais para o operador ternário, 99.99 (um double) e 9 (um int), são de tipos diferentes. O tipo de resultado de um operador ternário deve ser determinado completamente em tempo de compilação, e neste caso o tipo escolhido é o de usar as regras de promoção para operandos binário, que o é tipo double. Porque o resultado é um double, o valor de produção está impresso em um formato de ponto flutuante.

A escolha do qual os dois valores para produção é feita em base do valor de boolean que precede o ?. Desde que x é 4, o teste (x> 4) é falso. Isto causa a expressão global para levar o segundo dos possíveis valores que são 9 em lugar de 99.99. Porque o tipo de resultado é promovido para um tipo double, o valor de produção é escrito de fato como 9.0 em lugar de o mais óbvio 9.

A alternativa A está correta. Os operadores de tarefa do op de forma = só avalie a expressão à esquerda uma vez. Assim o efeito de decrementing x, em--x, só acontece uma vez e resulta em um valor de 0 e não -1. Então nenhum fora-de-salto forma são tentados acessos. Os elementos de ordem que são afetado por isto operações são " Fred ", desde que o decrement acontece antes o + = operação é executada. Embora Fio objeta que eles são immutable, as referências que são os elementos de ordem não são. É completamente possível causar o valor name[0] ser modificado para se referir a um Fio recentemente construído que acontece para ser " Fred ".

Capítulo 03

1. Qual das seguintes declarações são ilegais?

A. friendly String s;

B. transient int i = 41;

C. public final static native int w( );

D. abstract double d;

E. abstract final double hyperbolicConsine( );

A, D, e E são ilegais. A alternativa A é ilegal porque “amigável” não é um Keyword.A alternativa B é uma declaração passageira legal. A alternativa C é estranha mas legal. A alternativa D é ilegal porque só métodos e classes podem ser abstratas. A alternativa E é ilegal porque abstrato e final é contraditório.

2. Qual das declarações é verdadeira?

A. Uma classe abstract não pode ter nenhum método final.

B. Uma classe final não pode ter nenhum método abstract.

A alternativa B é verdadeira: Uma classe final pode não ter nenhum método abstrato. Qualquer classe abstrata, métodos devem ser abstrato, e uma classe pode não ser do tipo abstrato e final. A declaração da alternativa A diz que na classe abstrata pode não ter métodos finais, mas não há nada errado com isto. A classe abstrata vai ser sub-classe eventualmente, e a subdivisão de classe tem que evitar anular os métodos finais do pai. Qualquer outro método pode ser anulado livremente.

3. Qual será a modificação mínima que permitirá a compilação do código a seguir?
   1. final class Aaa
   2. { int xxx;
   3. void yyy( ) { xxx = 1; }
   4. }
   6. class Bbb extends Aaa

4. public static void main(String args[ ])
5. {
6. System.out.println(“x = “ + x);
7. }
8. static {x /= 5;} }

A. As linhas 5 e 12 não irão compilar, devido a falta dos nomes dos métodos e dos tipos de retorno.

B. A linha 12 não irá compilar, porque você não pode chamar apenas o inicializador static.

C. O código irá compilar e a saída será x = 10.

D. O código irá compilar e a saída será x = 15.

E. O código irá compilar e a saída será x = 3.

A alternativa E está correta. Inicializadores estáticos múltiplos (enfileira 5 e 12) são permitidos. Todo o código do inicializador estático é executado em momento de classe-carga, assim antes de principal () sempre seja corrido, os dividiram por 5 (linha 12).

6. Qual das declarações abaixo é verdadeira?
   1. class HasStatic {
   2. private static int x = 100;
   3. public static void main(String args[ ])
   4. { HasStatic hs1 = new HasStatic( );
   5. hs1.x++;
   6. HasStatic hs2 = new HasStatic( );
   7. hs2.x++;
   8. hs1 = new HasStatic( );
   9. hs1.x++;
   10. HasStatic.x++;
   11. System.out.println(“x = “ + x);
   12. } }

A. A linha 8 não irá compilar, porque ela possui uma referência static para uma variável private.

B. A linha 13 não irá compilar, porque ela possui uma referência static para uma variável private.

C. O programa irá compilar e a saída será x = 102.

D. O programa irá compilar e a saída será x = 103.

E. O programa irá compilar e a saída será x = 104.

A alternativa E está correta. O programa compila bom; o “referência estática para uma variável privada” materiais em respostas UM e B é tolice. O x variável estático é incrementado quatro vezes, em linhas 8,10,12,and13.

7. Dado o código abaixo, e fazendo nenhuma outra mudança que tem acesso modificadores (o public, protected, ou private) pode ser colocado legalmente antes de aMethod () na linha 3? Se a linha 3 permanece como esta, qual palavras reservada podem ser colocados legalmente antes de aMethod () na linha 8?
   1. class SuperDuper {
   2. void aMethod( ) { }
   3. }
   4. class Sub extends SuperDuper {
   5. void aMethod( ) { }
   6. }

Na linha 3, o método pode ser declarado privado. O acesso de método da versão de subdivisão de classe (linha 8) é amigável, e só um método privado ou amigável pode ser anulado para ser amigável. O princípio básico é que um método pode não ser anulado para ser mais privado. (Veja Figura 3.2) Em linha 8 (linha 3 pretensiosa permanece só), a versão de suprclass é amigável, assim a versão de subdivisão de classe pode estar como é (e é amigável), ou pode ser declarado protegido ou público.

8. Deverão ser usados qual modificador ou modificadores para denotar uma variável que não deveria ser escrita fora como parte de seu estado de presistente de classe?

A. private

B. protected

C. private protected

D. transient

E. private transient

A resposta correta é D (transitent). Os outros modificadores controlam acesso de outros objetos dentro do Java Máquina Virtual.

10. Qual das declarações nas classes Bird e Nightingale abaixo é verdadeira?
    1. package singers;
    3. class Nightingale extends abcde.Bird {
    4. Nightingale( ) { referenceCount++;}
    6. public static void main(String args[ ]) {
    7. System.out.println(“BEFORE: “ + referenceCount);
    8. Nightingale florence = new Nightingale( );
    9. System.out.println(“ AFTER: “ + referenceCount);
    10. florence.fly( );
    11. } }

A. O programa irá compilar e executar. A saída será Before: 0 e After: 2.

B. O programa irá compilar e executar. A saída será Before: 0 e After: 1.

C. A compilação do Nightingale irá falhar na linha 4, porque statics não podem ser anulados.

D. A compilação do Nightingale irá falhar na linha 10, porque o método fly( ) é protegido na super-classe.

E. A compilação do Nightingale irá ser bem sucedida, mas uma exception irá ocorrer na linha 10, porque o método fly( ) é protegido na super-classe.

A alternativa A está correta. Não há nada errado com Rouxinol. O referenceCount estático é batido duas vezes: uma vez em linha 4 de Rouxinol, e uma vez em linha 5 de Pássaro. (O constructor de nenhum- argumento do superclass sempre é caled de implicitly no começo de uma classe constructor de ', a menos que um constructor de superclass diferente seja pedido. Isto não tem nada que ver Com o tópico deste chapter,but é coberto em Capítulo 6, Objetos e Classes. ) ReferenceCount de Sinse é batido duas vezes e não só uma vez, resposta B está errado. C diz que não podem ser anulados atatics, mas nenhum método estático está sendo anulado em linha 4; tudo aquilo está acontecendo é incre- ment de na de na herdaram variável estática. D está errado, desde protegeu é justamente o modificador de acesso nós queremos Pássaro. Voe () ter: Nós estamos chamando Pássaro. Voe () de uma subdivisão de classe em um pacote diferente. Resposta E é ridículo, mas usa terminologia acreditável.

Capítulo 04

1. Qual das seguintes declarações é a correta?

A. São convertidos automaticamente somente tipos primitivos, para mudar o tipo de uma referência de objeto, você tem que fazer um cast.

B. São convertidas automaticamente somente referências de objeto; mudar o tipo de um primitivo, você tem que fazer um cast.

C. Promoção de aritmética de referências de objeto requer arremesso explícito.

D. Primitivos e referências de objeto podem ser ambos convertidos e podem fazer cast.

E. Casting de tipos numéricos podem requerer um cheque de runtime.

A alternativa D está correta. C está errado porque objetos não levam parte em operações de aritmética. E está errado porque lançando potencialmente só de referências de objeto requer um cheque de runtime.

2. Qual das linha a seguir não irá compilar?
   1. byte b = 5;
   2. char c = ‘ 5 ’;
   3. short s = 55;
   4. int i = 555;
   5. float f = 55.5F;
   6. b = s;
   7. i = c;
   8. if (f > b)
   9. f = i;

Enfileire 6 (b = s) não compilará porque convertendo um pequeno a um byte é uma conversão de estreitamento que requer elenco de anexplicit. As outras tarefas no código estão alargando conversões.

3. O código abaixo irá compilar?
   1. byte b = 2;
   2. byte b1 = 3;
   3. b = b * b1;

O código surpreendentemente, não compilará a linha 3. São convertidos o dois operands que são originalmente bytes a ints antes da