Quais dos seguintes itens são permitidos?
A. public abstract void m1(){}
B. protected native int m1();
C. static final void m1(){}
O item A não é permitido porque métodos abstratos não possibilitam a definição de um corpo de método. Nessa situação, a declaração o método deve ser finalizada com ; ao invés de {}. As alternativas B e C estão corretas sintaticamente: métodos nativos não possuem um corpo e métodos estáticos podem ser finais (assumir a expressão final em sua declaração).
Alternativas corretas: B, C.
Assumindo o código abaixo:
31. public enum Title {
32. MR(“Mr.”), MRS(“Mrs.”), MS(“Ms.”);
33. private final String title;
34. private Title(String t) { title = t; }
35. public String format(String last, String first) {
36. return title + “ ” + first + “ ” + last;
37. }
38. public static void main(String[] args) {
39. System.out.println(Title.MR.format(”Doe”, “John”));
40. }
41. }
Qual será o resultado?
A. Mr. John Doe.
B. Uma exceção é disparada em tempo de execução.
C. Falha de compilação provocada por erro na linha 32.
D. Falha de compilação provocada por erro na linha 36.
E. Falha de compilação provocada por erro na linha 39.
O enum da questão terá comportamento de uma classe, com um método principal e seus atributos e comportamentos. Na linha 32 do enum há a listagem dos itens enumerados (atributo): MR, MRS e MS. Neste caso, cada atributo é definido como um objeto de Title com sua respectiva entrada no construtor (o que já define o valor do atributo final title). Como isso é possível, as alternativas C e D serão descartadas.
Por conta dessa inicialização dos atributos, quando um destes for chamado no método principal tem-se então uma instância de Title que pode executar qualquer método que foi implementado no enum. Assim, pode ser chamado o método format na linha 39, já que MR está associado ao construtor MR(“Mr.”), que associa “Mr.” ao atributo title. Essa explicação inviabiliza a opção E. Como os trechos de código de maior dúvida já foram explanados anteriormente, nenhuma execução deve ser disparada ao executar este código. Conclui-se que a opção B se apresenta errônea e apenas a alternativa A está correta.
Alternativa correta: A.
Assumindo o código abaixo:
31. public enum Title {
32. MR(“Mr.”), MRS(“Mrs.”), MS(“Ms.”);
33. private final String title;
34. private Title(String t) { title = t; }
35. public String format(String last, String first) {
36. return title + “ ” + first + “ ” + last;
37. }
38. public static void main(String[] args) {
39. System.out.println(Title.MR.format(”Doe”, “John”));
40. }
41. }
Qual será o resultado?
A. Mr. John Doe.
B. Uma exceção é disparada em tempo de execução.
C. Falha de compilação provocada por erro na linha 32.
D. Falha de compilação provocada por erro na linha 36.
E. Falha de compilação provocada por erro na linha 39.
O enum da questão terá comportamento de uma classe, com um método principal e seus atributos e comportamentos. Na linha 32 do enum há a listagem dos itens enumerados (atributo): MR, MRS e MS. Neste caso, cada atributo é definido como um objeto de Title com sua respectiva entrada no construtor (o que já define o valor do atributo final title). Como isso é possível, as alternativas C e D serão descartadas.
Por conta dessa inicialização dos atributos, quando um destes for chamado no método principal tem-se então uma instância de Title que pode executar qualquer método que foi implementado no enum. Assim, pode ser chamado o método format na linha 39, já que MR está associado ao construtor MR(“Mr.”), que associa “Mr.” ao atributo title. Essa explicação inviabiliza a opção E. Como os trechos de código de maior dúvida já foram explanados anteriormente, nenhuma execução deve ser disparada ao executar este código. Conclui-se que a opção B se apresenta errônea e apenas a alternativa A está correta.
Alternativa correta: A.
Qual o resultado quando o seguinte fragmento de código for executado?
int a = 8;
int b = 3;
float f = a++/b--;
System.out.println(f);
A. 3.0
B. 4.5
C. 2.0
D. 2.6
Caso o operador incremento/decremento se apresentasse anteriormente à a/b, o valor de memória já seria passado às variáveis resultando no valor 3.0 (alternativa A). Ainda que os operadores ++ e -- tenham maior procedência que /, não há conflito entre as operações neste exemplo. Portanto, a operação 8/3 resulta em 2.0 para f do tipo float, depois que a é incrementado para 9 e b é decrementado para 2 (alternativa C). Os demais valores não são possíveis de alcançar com as operações apresentadas.
Alternativa correta: C.
O que acontece ao tentar compilar e executar o seguinte código?
public class TestEqual
{
public static void main(String args[])
{
Integer i = new Integer(7);
Long l = new Long(7);
System.out.println(l.equals(i));
}
}
A. imprimirá - true
B. imprimirá - false
C. erro de compilação
O código imprimirá false. Para qualquer classe Wrapper padrão, x.equals(y) sempre retorna false se x e y são objetos de classes diferentes. Isso acontece até mesmo para o exemplo da questão, em que ambos os objetos carregam o mesmo valor (o inteiro 7).
Alternativa correta: B.
Assumindo o seguinte código:
70. class MakeFile {
71. public static void main(String[] args) {
72. try {
73. File directory = new File(“d”);
74. File file = new File(directory, “f”);
75. if(!file.exists()) {
76. file.createNewFile();
77. }
78. } catch (IOException e) {
79. e.printStackTrace
80. }
81. }
82. }
O diretório atual não contém um diretório nomeado “d”. Quais alternativas a seguir podem ser consideradas corretas?
A. Linha 76 nunca é executada.
B. Uma exceção é disparada em tempo de execução.
C. Linha 73 cria um objeto File nomeado “d”.
D. Linha 74 cria um objeto File nomeado “f”.
E. Linha 73 cria um diretório nomeado “d” no sistema de arquivos.
F. Linha 76 cria um diretório nomeado “d” e um arquivo “f” dentro do sistema de arquivos.
G. Linha 74 cria um arquivo nomeado “f” dentro do diretório nomeado “d” no sistema de arquivos.
No enunciado da questão é informado que não há um diretório “d” criado no diretório atual do programa. Com essa informação, a alternativa G já pode ser descartada visto que a aplicação só está acessando o diretório atual (pelo que é apontado nas instanciações dos objetos de File) e não há diretório “d” criado anteriormente. E este mesmo diretório não pode ser criado por esse programa, nem na instanciação do objeto diretorio, nem no comando da linha 76. Nessa situação, somente seria possível a criação de um arquivo (neste caso o que é referenciado pelo objeto file), caso o diretório “d” já existisse. Essa última informação inviabiliza as alternativas E e F.
Mesmo não existindo o diretório “d” e o arquivo “f”, é possível instanciar os objetos directory e file. O único problema ocorrerá quando se tenta acessar o arquivo físico apontado por esses objetos. Esse momento acontece na execução da linha 76 (criação de novo arquivo), em que não há acesso ao arquivo real e dispara-se uma exceção em tempo de execução. Dessa maneira, a alternativa A se mostra incorreta enquanto B se apresenta como uma das alternativas corretas. As demais são as opções C e D, que não provocam erros no programa.
Alternativas corretas: B, C, D.
Qual dos itens são métodos estáticos da classe Thread?
A. sleep
B. yield
C. wait
D. notify
Em sleep() e yield() (alternativas A e B) temos a descrição de métodos estáticos da classe Thread que atuam na thread de execução atual. Os métodos wait() e notify() são oriundos da classe Object, e não da classe Thread. Portanto, as alternativas C e D são incorretas.
Alternativas corretas: A, B.
Dado o código abaixo:
63. try {
64. // algum código neste trecho
65. } catch (NullPointerException e1) {
66. System.out.print(“a”);
67. } catch (RuntimeException e2) {
68. System.out.print(“b”);
69. } finally {
70. System.out.print(“c”);
71. }
Qual o resultado obtido se ocorrer a exceção NullPointerException na linha 64?
A. c
B. a
C. ab
D. ac
E. bc
F. abc
A ordem das exceções NullPointerException e RuntimeException não é disposta de forma aleatória. A exceção NullPointerException herda de RuntimeException, e esta última herda de Exception. Seguindo essa lógica, a exceção NullPointerException é apresentada antes das demais para permitir que a mesma possa ser disparada quando necessário, senão sua superclasse engloba sua execução. Caso isso não acontecesse, seria um erro de compilação.
Com esse raciocínio, se acontecer o código “int array[] = {1, 2}; array[2] = 3;” na linha 64, dispara-se a exceção RuntimeException, o que permite exibir a saída bc. Isso é possível porque o código citado dispara a exceção ArrayIndexOutOfBoundsException que herda de RuntimeException, e ainda há a execução constante do código presente na área de finally. Essas informações inviabilizam as alternativas A, B e E.
Como subclasse especificada, quando se dispara a exceção NullPointerException dispensa-se a exceção RuntimeException na execução do programa. Assim, o código presente na linha 68 nunca será executado quando isso ocorrer com a linha 66. Portanto, as alternativas C e F estão incorretas e apenas a alternativa D é viável. Pode-se verificar isso se na linha 64 tivermos o código “int array[] = {1, 2}; Integer i = null; array[i.intValue()] = 3;”. Nessa codificação, o objeto i possui referência nula e não permite a execução da atribuição do valor 3 no objeto array. Alternativa correta: D.
Qual dos itens a seguir cria um scanner que leia da entrada padrão?
A. Scanner sc = new Scanner(System.in);
B. Scanner sc = Scanner.getInstance(System.in);
C. Scanner sc = new Scanner(); sc.next(System.in);
D. sc.next(System.in);
A classe Scanner provê oito construtores, um dos quais está presente na alternativa A: Scanner(InputStream source). Nesta opção constrói-se um novo Scanner para produzir valores lidos do stream de entrada específico System.in que é do tipo java.io.InputStream. Então o objeto Scanner é criado como “Scanner sc = new Scanner(System.in);”. Dessa forma, as alternativas B, C e D apresentam maneiras incorretas de iniciar a leitura de dados a partir da classe java.util.Scanner. Alternativa correta: A.
Classe TestException:
1. public class TestException extends Exception {}
Classe A:
1. public class A {
2. public String sayHello(String name) throws TestException {
3. if(name == null) {
4. throw new TestException();
5. }
6. return “Hello ”+ name;
7. }
8. }
Um programador quer usar este código em uma aplicação:
55. A a = new A();
56. System.out.println(a.sayHello(“John”));
Quais as alternativas corretas relacionadas a essa implementação?
A. Classe A não compilará.
B. Linha 56 pode disparar a exceção TestException que não foi checada.
C. Linha 55 pode disparar a exceção TestException que não foi checada.
D. Linha 56 compila se adicionar TestException na declaração do método que apresenta esse código.
E. Linha 56 compila se estiver dentro de um bloco try-catch, em que a exceção TestException é tratada.
A Classe A não apresenta erros apesar de ter um método que aborda a exceção TestException. Esta última não apresenta implementação no corpo da classe, mas possui uma codificação herdada de Exception. E no código da aplicação (linhas 55 e 56) não há possibilidade de se disparar a exceção porque a mesma não foi checada no código. Assim as alternativas A, B e C são descartadas, enquanto que as demais opções são mantidas e estão corretas.
As alternativas D e E apresentam as duas opções possíveis para viabilizar a execução do código da aplicação. Na opção D, menciona-se que indicar o tratamento da exceção TesteException no método que chama sayHello() permite a execução do código (mesmo que seja o método principal). E na opção E, destaca-se o tratamento desta mesma exceção inserindo o código da questão em um bloco try-catch (ou caso seja necessário, um bloco try-catch-finally) para resolver o problema.
Alternativas corretas: D, E.
De acordo com o código abaixo:
21. public class Ball {
22. public enum Color { RED, GREEN, BLUE };
23. public void foo() {
24. // insert code here
25. { System.out.println(c); }
26. }
27. }
Que código inserido na linha 24 causa ao método “foo” imprimir RED, GREEN e BLUE?
A. for(Color c : Color.values())
B. for(Color c = RED; c <= BLUE; c++)
C. for(Color c; c.hasNext() ; c.next())
D. for(Color c = Color[0]; c <= Color[2]; c++)
E. for(Color c = Color.RED; c <= Color.BLUE; c++)
Operadores de incremento e comparação não podem ser aplicados a tipos de enumeração, o que inviabiliza a execução dos códigos presentes nas alternativas B, D e E. A opção C está incorreta já que em um enum não há implementação dos métodos hasNext() e next(). E ainda, os elementos de um enum não podem ser acessados por índices, mas sim pela notação “.” (dot notation). Concluindo, apenas a opção A possui uma codificação correta usando uma alternativa criada desde a versão 1.5 da linguagem para acesso a todos os elementos de uma coleção ou enumeração.
Alternativa correta: A.
Qual dos itens são os valores finais de ‘a´ e ‘b´ que surgirão no corpo do loop for ao ser executado?
for(a=1, b=4; a < b; a++, b--){ }
A. a=1, b=2
B. a=2, b=3
C. a=3, b=4
D. Erro de compilação.
A declaração do loop for possuir três partes principais, além do corpo do loop: declaração e inicialização de variáveis, teste condicional e expressão de iteração. Cada uma dessas partes é separada por um ponto e vírgula. No teste condicional só pode ter uma expressão de teste e nas demais partes pode ser adicionado mais de uma expressão. Neste caso, o valor final de a será 2 e de b será 3 (a menor que b será satisfeita). Alternativa correta: B.
Dado:
15.String #name = “Jane Doe”;
16. int $age=24;
17. Double _height = 123.5;
18. double ~temp = 37.5;
Quais as alternativas corretas?
A. Linha 15 não compilará.
B. Linha 16 não compilará.
C. Linha 17 não compilará.
D. Linha 18 não compilará.
Os identificadores devem começar com uma letra, um cifrão ($) ou um caractere de conexão (como underscore ‘_´). Estes não podem começar com um número, mas em seguida ao primeiro caractere, os identificadores podem conter qualquer combinação de letras, caracteres de moedas, caracteres de conexão ou números. Por conta destas características, as linhas 15 e 18 estão sintaticamente incorretas. Lembrando ainda que não é possível usar uma palavra-chave Java como identificador, com isso apenas as alternativas A e D estão corretas.
Alternativas corretas: A, D.
Considere as seguintes linhas de código:
float[] x = new float[10];
Float[] y = new Float[10];
Depois da execução, quais das expressões a seguir são verdadeiras?
A. x[9] == 0
B. x[10] == 0.0f
C. y[9] == 0.0f
D. x.length == 10
E. y.length() == 10
F. y[9] == null
O compilador inicializa todos os elementos do array x para 0.0f, que é o elemento default para tipo float. Todos os elementos do array y são inicializados para null, desde que null é o valor default para tipos de referência de objetos. Na alternativa A, 0 é promovido a 0.0f durante a comparação, enquanto que x[9] é o último elemento do array. Alternativa B é incorreta ao tentar acessar x[10], o que resulta em disparar uma exceção. A alternativa F é correta e C é incorreta porque y[9] é null e não pode ser comparada a 0.0f. Todos os arrays têm uma variável de instância nomeada length, que retorna o número de elementos no array. Dessa forma D está correta, enquanto E está incorreta visto que não há nenhum método chamado length().
Alternativas corretas: A, D, F.
class Alpha { int over = 1; }
class Beta extends Alpha { int over = 2; }
class Gamma extends Beta {
int over = 3;
public stativ void main(String[] args) {
new Gamma().go();
}
void go() {
Beta b = new Gamma();
Alpha a = new Gamma();
System.out.println(super.over + " " b.over + " " + a.over);
}
}
Qual o resultado?
A. 2 2 1
B. 3 2 1
C. 2 3 3
D. 3 3 3
E. Não compila
Segue a dica, sempre usar como referência o tipo e não a instância. Super, refere-se a classe pai, neste caso, Beta é super de Gamma. b é do tipo Beta e a é do tipo Alpha, assim o resultado certo é Beta, Beta e Alpha (2 2 1), letra A.
String d = "beekeeper";
d.substring(1,7);
d = "w" + d;
d.insert(3, "bee");
System.out.println(d);
Qual o resultado?
A. weekbeeeep
B. wbeekeeper
C. wbeekeepe
D. weekeeper
E. Falha de compilação
F. RunTime Exception
Tentando digitar o código no eclipse, e vimos que o objeto String não possui o método insert, assim, não compila.
