Prova 1 Flashcards
1
Q
O que acontece ao tentar rodar um código sem o método main?
A
Quando um programa é executado, a JVM procura por um método main.
Se não encontra, ela lança um erro na execução.
2
Q
O código abaixo compila?
public class TestClass{
public static long main(String[] args){
System.out.println("Hello");
return 10L;
}
}
A
Sim
Mas só será executado se chamado através de outra classe.
3
Q
O que acontece ao chamar o método main através de outra classe?
A
O código executa normalmente.
4
Q
O código abaixo executa?
public class Gato {
public static void main(String[] args){
System.out.println("GATO");
}
}
public class Principal{
public static void main(String[] args){
Gato gato = new Gato();
String[] argss = {};
gato.main(argss);
}
}
A
Sim
Compila normalmente!
5
Q
O código abaixo executa?
public class Gato {
public static void main(String[] args){
System.out.println("GATO");
}
}
public class Principal{
public static void main(String[] args){
Gato gato = new Gato();
String[] argss;
gato.main(argss);
}
}
A
Não! O código não compila!
A variável argss não foi inicializada.
6
Q
O código abaixo executa?
public class Gato {
public void main(){
System.out.println("GATO");
}
}
public class Principal{
public static void main(String[] args){
Gato gato = new Gato();
gato.main();
}
}
A
Sim, o código compila normalmente.
7
Q
Quais dos pacotes abaixo são importados automaticamente pela linguagem java?
java. util.*
java. lang.*
java. io.
java. awt.
A
java.lang.*
8
Q
O código abaixo compila?
String mStr = "123"; long m = new Long(mStr);
A
Sim compila!
A classe long possui um construtor que recebe uma String.
Todas as classes wrapers possuem um construtor que recebe uma String.
Integer num = new Integer(“123”);
9
Q
O que o código abaixo retorna?
String mStr = “123”;
Long.parseLong(mStr);
A
Retorna um tipo long (primitivo)
O método parse sempre recebe uma string.
O método valueOf recebe um objeto e retorna um wrapper.
10
Q
O que o código abaixo imprime?
int i,j,k;
i = j = k = 20;
System.out.println(i+” “+j+” “+k);
A
20 20 20
11
Q
O que o código abaixo imprime?
int i,j,k;
int b = i = j = k = 20;
System.out.println(b+ “ “ +i+” “+j+” “+k);
A
20 20 20 20
12
Q
O que o código abaixo imprime?
int i;
int b = i = j = k = 20;
System.out.println(b+ “ “ +i+” “+j+” “+k);
A
Não compila
As variáveis j e k não foram declaradas antes.
13
Q
O que o código abaixo imprime?
int i,j,k;
int l = 10;
int b= i= j=k = l =20;
System.out.println(b+” “+i+” “+j+” “+k+” “+l);
A
20 20 20 20 20
14
Q
O código abaixo compila?
float f2 = 123__345_______667F;
A
Sim compila!
Pode ocorrer mais de um underline na operação. Contato que estejam entre números o código compila.
15
Q
O código abaixo compila?
String s = ‘a’;
A
Não
Char não pode ser convertido para String.
16
Q
O código abaixo compila?
char a = ‘a’;
String s = (String)a;
A
Não
Char não pode ser convertido para String.
17
Q
Posso converter char para String?
A
Não
Char não pode ser convertido para String.
char a = ‘a’;
String s = (String)a; //Não Compila
18
Q
Quanto imprime o código abaixo? Integer var = new Integer(5); var++;
A
6
Classes Wrappers são imutáveis.
Mas neste caso o código é iterado e depois reatribuído para a variável.
var = new Integer( var.intValue()+ 1);
19
Q
Qual a saída do programa abaixo?
public static void main(String[] args){
Integer val1 = new Integer(5);
testInts(val1++);
System.out.println(val1);
}
public static void testInts(Integer obj){
obj++;
System.out.println(obj);
}
A
6 6
Ao usar o obj++ no método testInts é criada uma nova referência para variável. Não alterando o valor externo.
20
Q
Qual a saída do programa abaixo?
public static void main(String[] args){
Integer val1 = new Integer(5);
testInts(val1++);
System.out.println(val1);
}
public static void testInts(Integer obj){
obj++;
obj++;
System.out.println(obj);
}
A
7 6
Ao usar o obj++ no método testInts é criada uma nova referência para variável. Não alterando o valor externo.
21
Q
O que imprime o código abaixo?
int i = 0;
switch(i){
case 0 : System.out.print("Saulo ");
case 1 : System.out.print("Java "); break;
default : System.out.print("Good Bye");
}
A
Saulo Java
O método default só é executado quando nenhum dos outros cases são aceitos.
22
Q
O que imprime o código abaixo?
int i = 0;
switch(i){
case 0 : System.out.print("Saulo ");
case 1 : System.out.print("Java ");
default : System.out.print("Good Bye");
}
A
Saulo Java Good Bye
O método default só é executado quando nenhum dos outros cases são aceitos. Mas na ausência de um break, todos os outros cases são executados.
23
Q
O que imprime o código abaixo?
int i = 0;
switch(i){
default : System.out.print("Good Bye");
case 0 : System.out.print("Saulo ");
case 1 : System.out.print("Java ");
}
A
Saulo Java
O método default não precisa ser obrigatoriamente o último.
Mas prevalece a obrigação de usar um break.
24
Q
O que imprime o código abaixo?
int i = 5;
switch(i){
default : System.out.print("Good Bye");
case 0 : System.out.print("Saulo ");
case 1 : System.out.print("Java ");
}
A
Good ByeSaulo Java
O método default não precisa ser obrigatoriamente o último.
Mas prevalece a obrigação de usar um break.
25
O código abaixo compila?
Boolean bool = false;
Sim
| Apesar de ser um Wrapper, a atribuição sofre um autobox.
26
O que o código abaixo imprime?
String V1 = "Um";
String V2 = "Dois";
System.out.println( V1.equals(V1=V2) );
False
```
Primeiro o valor de V1 é avaliado.
V1.equals(V1=V2)
"Um".equals(V1=V2)
Em seguida a operação é executada.
"Um".equals("Dois")
```
27
Qual o resultado da operação abaixo?
double x = 39.21;
float y = 2.1;
double z = x + y;
Não compila!
2.1 é um double, e não pode ser convertido diretamente para float.
float y = 2.1f;
28
O código abaixo compila?
int x = !5;
Não
29
O código abaixo compila?
boolean x = !true;
Sim
30
Qual o resultado de x e y?
int x = 3;
int y = ++x * 5 / x-- + --x;
```
x is 2
y is 7
Primeiro resolve todos os operadores de incremento e decremento.
int y = 4 * 5 / 4 + 2;
Só então se executa a operação
```
31
O que imprime a operação abaixo?
System.out.println((1>2==4>45)?("True"):("False"));
True
32
O que imprime a operação abaixo?
System.out.println((1>2=4>45)?("True"):("False"));
Não compila!
33
O que o código abaixo imprime?
int x = 0;
if(true||x++>0)
System.out.println(x);
0
| A segunda parte da operação não será executada pois a primeira já valida a operação.
34
O que o código abaixo imprime?
int x = 0;
if(true|x++>0)
System.out.println(x);
1
| Mesmo que a primeira parte da operação seja true, será executada a segunda verificação.
35
O que o código abaixo imprime?
int x = 0;
if(true&&x++>0)
System.out.println(x);
1
| A segunda operação será executada.
36
O que o código abaixo imprime?
int x = 0;
if(false&x++>0)
System.out.println(x);
O valor de X será 1, mas nada será impresso!
| Mesmo que a primeira condição já invalide a operação, a segunda condição será executada.
37
O que o codigo abaixo imprime?
```
public class Value{
public static void main(String[] args){
for(String val:args){
System.out.println(val);
}
}
}
```
>> java Value 1 2 3
1
2
3
38
O que o código abaixo imprime?
```
public class Switcher{
public static void main(String[] args){
switch(Integer.parseInt(args[1]))
{
case 0 :
boolean b = false;
break;
```
```
case 1 :
b = true;
break;
}
if(b) System.out.println(args[2]);
}
}
```
>>java Switcher 1 2 3
Não compila
A variável b foi instanciada dentro do switch. Portanto não pode ser acessada por um membro externo.
39
O código abaixo compila?
String[] arr = new String[2];
for(String str:arr){
System.out.println(str);
}
Sim! Imprime:
null
null
40
O que imprime o código abaixo?
String[] vet = new String[2];
for(int i = 0; i < vet.length ; i++){
vet[i].concat("Num");
}
for(String ar:vet){
System.out.println(ar);
}
Compila mas lança exceção!
Ele lança uma NullPointerException!
Pois se está tentando concatenar um valor a uma posição null.
Todo vetor de String recebe null a seus valores não atribuídos.
41
O que imprime o código abaixo?
String[] arr = new String[2];
for(int i = 0; i < arr.length; i++){
arr[i]=i;
}
for(String ar:arr){
System.out.println(ar);
}
Não compila!
int não pode ser convertido para String.
```
Para funcionar, converta int para String:
arr[i]=(new Integer(i).toString());
```
42
O que imprime o código abaixo?
```
String[] arr = new String[2];
for(int i = 0; i < arr.length; i++){
arr[i]=(new Integer(i).toString());
}
```
for(String ar:arr){
0
1
O código compila normalmente.
43
O que imprime o código abaixo?
```
int[] arr = new int[2];
try{
System.out.println(arr[2]);
}catch(Exception e) { }
System.out.println(arr[1]);
```
0
Mesmo que se tente acessar um index inexistente do array, o catch pega a exceção.
Vale ressaltar que o mesmo array foi preenchido com o valor padrão do tipo int, que é 0.
44
O que imprime o código abaixo?
int[] arr = new int[2];
System.out.println(arr[2]);
Lança ArrayIndexOutOfBoundsException
Pois se tenta fazer acesso a uma posição inexistente do array.
45
```
Qual das linhas abaixo não compila?
String[] sA = new String[] { "aaa"}; // 1
String[] sA = new String[1] { "aaa"}; // 2
String[] sA = new String[1] ; sA[0] = "aaa"; // 3
String[] sA = {new String( "aaa")}; // 4
String[] sA = { "aaa"}; // 5
```
2
| Não se pode inicializar diretamente o vetor que possui tamanho definido.
46
O código abaixo compila?
String[] sA = new String[1] { "aaa"};
Não
Não se pode inicializar diretamente o vetor que possui tamanho definido.
47
O que imprime o código abaixo?
```
String[] arr = new String[2];
try{
System.out.println(arr[2]);
}catch(Exception e) { }
System.out.println(arr[1]);
```
null
Apesar de fazer um acesso a uma posição invalida do array, esta exceção é tratada.
Portanto a execução segue normalmente.
48
Qual a ordem de inicialização de uma classe?
Primeiro se instancia os membros estáticos, na ordem que eles aparecem.
Em segundo os membros de instância, na ordem que aparecem.
Só então o construtor é executado.
O ultimo item da lista é o método main.
49
O que imprime o código abaixo?
```
public class Inicializadores {
static{
s1 = metodo1("a");
}
```
```
public Inicializadores() {
s1 = metodo1("g");
}
```
static String s1 = metodo1("b");
String s3 = metodo1("d");
{
s1 = metodo1("e");
}
static String s2 = metodo1("c");
String s4 = metodo1("f");
private static String metodo1(String s) {
System.out.println(s);
return s;
}
```
public static void main(String args[]) {
//Inicializadores it = new Inicializadores();
}
}
```
```
a
b
c
d
e
f
g
```
50
O que imprime o código abaixo?
```
public class Inicializadores {
static{
s1 = metodo1("a");
}
```
```
public Inicializadores() {
s1 = metodo1("g");
}
```
static String s1 = metodo1("b");
String s3 = metodo1("d");
{
s1 = metodo1("e");
}
static String s2 = metodo1("c");
String s4 = metodo1("f");
private static String metodo1(String s) {
System.out.println(s);
return s;
}
```
public static void main(String args[]) {
//Inicializadores it = new Inicializadores();
}
}
```
a
b
c
51
O que o código abaixo imprime?
```
public static void main(String[] args){
int i = 10;
tx(i);
System.out.println(i);
}
```
public void tx(int i){
i = 15;
System.out.println(i);
}
Não compila!
| O código tenta chamar um método não estático de um método estático.
52
O que o código abaixo imprime?
```
public static void main(String[] args){
ref r = new ref();
int i = 10;
r.tx(i);
System.out.println(i);
}
```
public void tx(int i){
i = 15;
System.out.println(i);
}
15
| 10
53
O que o código abaixo imprime?
```
public static void main(String[] args){
ref r = new ref();
StringBuilder sb = new StringBuilder("Saulo");
r.tx(sb);
System.out.println(s);
}
```
public void tx(String s){
System.out.println(s);
}
Não compila!
| StringBuilder não pode ser convertido para String.
54
O que o código abaixo imprime?
```
public static void main(String[] args){
ref r = new ref();
StringBuilder sb = new StringBuilder("Saulo");
r.tx(sb);
System.out.println(sb);
}
```
public void tx(StringBuilder s){
s.append("V1");
System.out.println(s);
}
SauloV1
| SauloV1
55
O que o código abaixo imprime?
```
public static void main(String[] args){
ref r = new ref();
int i = 10;
StringBuilder sb = new StringBuilder("Saulo");
r.tx(sb);
System.out.println(sb);
}
```
```
public void tx(StringBuilder s){
s = new StringBuilder("SauloV2");
s.append("V1");
System.out.println(s);
}
```
SauloV2V1
| Saulo
56
O que o código abaixo imprime?
```
public static void main(String[] args){
ref r = new ref();
int i = 10;
StringBuilder sb = new StringBuilder("Saulo");
r.tx(sb);
System.out.println(sb);
}
```
```
public void tx(StringBuilder s){
s = new StringBuilder(s + "SauloV2");
s.append("V1");
System.out.println(s);
}
```
SauloSauloV2V1
| Saulo
57
O que o código abaixo imprime?
```
public static void main(String[] args){
ref r = new ref();
int i = 10;
StringBuilder sb = new StringBuilder("Saulo");
r.tx(sb);
System.out.println(sb);
}
```
```
public void tx(StringBuilder s){
s.append("V1");
s = new StringBuilder(s + "SauloV2");
s.append("V1");
System.out.println(s);
}
```
SauloV1SauloV2V1
| SauloV1
58
O que o código abaixo imprime?
```
public static void main(String[] args){
ref r = new ref();
int i = 10;
StringBuilder sb = new StringBuilder("Saulo");
r.tx(sb);
System.out.println(sb);
}
```
```
public void tx(StringBuilder s){
s.append("V1");
s = new StringBuilder("SauloV2");
s.append("V1");
System.out.println(s);
}
```
SauloV2V1
| SauloV1
59
O que imprime o código abaixo?
public static void main(String[] args){
System.out.println(10 + " " + p());
}
public static int p(){
System.out.println("Go");
return 1;
}
Go
| 10 1
60
O que imprime o código abaixo?
public static void main(String[] args){
System.out.println(10 + " " + p());
}
public int p(){
System.out.println("Go");
return 1;
}
Não compila!
| O código faz uma chamada a um método de instância a partir de um método estático.
61
O que imprime o código abaixo?
```
public class ca{
public void m1(){
System.out.println("M1CA");
}
}
```
```
public class cb extends ca{
public static void main(String[] args){
cb cb1 = new cb();
cb1.m1();
}
public int m1(){
System.out.println("M1CB");
return 0;
}
}
```
Não compila!
Ao sobrescrever um método o retorno não pode ser mais amplo que o método da classe pai.
Neste caso, ao sobrescrever um método que retorna void, o retorno só pode ser void, já que não existe um tipo mais especifico que void.
62
O que imprime o código abaixo?
```
public class ca{
public void m1(){
System.out.println("M1CA");
}
}
```
```
public class cb extends ca{
public static void main(String[] args){
cb cb1 = new cb();
cb1.m1(1);
}
public void m1(int i){
System.out.println("M1CB" + i);
}
```
public void m1(int i, int j){
System.out.println("M1CB" + i + " " + j);
}
}
M1CB1
Neste caso não ocorre um Overriding, mas sim a overloading do código. Pois a assinatura do método é diferente.
63
O que imprime o código abaixo?
```
public class ca{
public String m2(){
System.out.println("M2CA");
return(" ");
}
}
```
```
public class cb extends ca{
public static void main(String[] args){
cb cb1 = new cb();
cb1.m2();
}
public void m2(){
System.out.println("M2CB");
}
}
```
Não compila!
String é considerado um tipo primitivo! Portanto não permite a mudança do tipo de retorno.
64
O que imprime o código abaixo?
```
public class ca{
public int m2(){
System.out.println("M2CA");
return 1;
}
}
```
```
public class cb extends ca{
public static void main(String[] args){
cb cb1 = new cb();
cb1.m2();
}
public short m2(){
System.out.println("M1CB");
return 1;
}
}
```
Não compila!
O overriding não se aplica para tipos primitivos.
Neste caso o retorno na classe filha deveria ser int.
65
O que imprime o código abaixo?
```
public class ca{
public int m2(){
System.out.println("M2CA");
return 1;
}
}
```
```
public class cb extends ca{
public static void main(String[] args){
cb cb1 = new cb();
cb1.m2();
}
public void m2(){
System.out.println("M1CB");
}
}
```
Não compila!
O overriding não se aplica para tipos primitivos.
Neste caso o retorno na classe filha deveria ser void.
66
O código abaixo compila?
```
public class carro extends veiculo{
public static void main(String[] args){
```
```
}
public veiculo getVeiculo(){
System.out.println("Veiculo Carro");
return new veiculo();
}
}
```
```
------------
public class fiat extends carro{
public static void main(String[] args){
```
```
}
public veiculo getVeiculo(){
System.out.println("Veiculo fiat");
return new carro();
}
```
}
Sim!
Neste caso se aplica o overriding no método getVeiculo()
67
O código abaixo compila?
```
public class carro extends veiculo{
public static void main(String[] args){
```
```
}
public veiculo getVeiculo(){
System.out.println("Veiculo Carro");
return new veiculo();
}
}
```
```
------------
public class fiat extends carro{
public static void main(String[] args){
```
```
}
public carro getVeiculo(){
System.out.println("Veiculo fiat");
return new carro();
}
```
}
Sim!
| Neste caso o overriding permite que o método da classe filha retorne um tipo mais especifico.
68
O código abaixo compila?
```
public class carro extends veiculo{
public static void main(String[] args){
```
```
}
public veiculo getVeiculo(){
System.out.println("Veiculo Carro");
return new veiculo();
}
}
```
```
------------
public class fiat extends carro{
public static void main(String[] args){
```
}
public void getVeiculo(){
System.out.println("Veiculo fiat");
}
}
Não compila!
69
O código abaixo compila?
```
public class carro extends veiculo{
public static void main(String[] args){
```
```
}
public Object getVeiculo(){
System.out.println("Veiculo Carro");
return new veiculo();
}
}
```
```
------------
public class fiat extends carro{
public static void main(String[] args){
```
```
}
public carro getVeiculo(){
System.out.println("Veiculo fiat");
return new carro();
}
```
}
Compila normalmente!
| Toda classe herda de Object. O que torna a classe carro uma subclasse de Object.
70
O código abaixo compila?
```
public class carro extends veiculo{
public static void main(String[] args){
```
```
}
public Object getVeiculo(){
System.out.println("Veiculo Carro");
return new veiculo();
}
}
```
```
------------
public class fiat extends carro{
public static void main(String[] args){
```
```
}
public String getVeiculo(){
System.out.println("Veiculo fiat");
return (" ");
}
```
}
Compila normalmente!
| Toda classe herda de Object. O que torna a String carro uma subclasse de Object.
71
O que retorna o código abaixo?
```
public static void main(String[] s){
her h = new her();
h.metodo();
h.metodo(1);
}
```
public void metodo(){
System.out.println("void");
}
public String metodo(int i){
System.out.println("String int");
return " ";
}
void
| String int
72
O que retorna o código abaixo?
```
public static void main(String[] s){
her h = new her();
h.metodo();
h.metodo(1);
h.metodo(1,1);
}
```
public void metodo(){
System.out.println("void");
}
```
public String metodo(int i){
System.out.println("String int");
return " ";
}
public boolean metodo(int k, int b){
System.out.println("int int");
return true;
}
}
```
void
String int
int int
73
Porque o código abaixo não compila?
interface Bozo{
int type = 0;
public void jump();
}
```
public class Type1Bozo implements Bozo{
public Type1Bozo(){
type = 1;
}
}
```
Todos os membros de uma interface são automaticamente public static e final. Mesmo que você não os defina assim!
Portanto a variável type não pode ser redefinida.
74
```
O código abaixo não compila porque?
package yo;
import mm.C;
public class B extends C{
B( ){ }
public static void main(String[] str){
new B();
}
}
-----------------------------------
package mm;
public class C{
C(){};
}
```
O construtor da classe C é default, portanto não pode ser acessado fora do pacote.
75
O que é um covariant return?
Um método que for sobrescrito, pode alterar o tipo do retorno contato que o novo retorno seja uma subclasse do retorno da classe pai.
É importante lembrar que o covariant return não se aplica para tipos primitivos.
76
O que imprime o código abaixo?
```
package mm;
public class C{
public static int k = 10;
}
-----------------------------------
package yo;
import mm.C;
public class B extends C{
```
public static int k = 20;
```
public static void main(String[] str){
C b = new B();
System.out.println(b.k);
}
}
```
10
Neste caso, mesmo que o membro seja estático, o valor acessado é o da classe pai.
O acesso a membros estáticos, de instância e também de métodos estáticos depende da classe da variável, e não do objeto armazenado.
Nestes casos membro acessado é o da classe pai.
Os métodos de instância são uma exceção à regra. Ao serem acessados o método chamado será o da classe filho.
77
O que imprime o código abaixo?
```
package mm;
public class C{
public int k = 10;
}
-----------------------------------
package yo;
import mm.C;
public class B extends C{
```
public int k = 20;
```
public static void main(String[] str){
C b = new B();
System.out.println(b.k);
}
}
```
10
Neste caso, o membro é uma variável de instância. O valor acessado é o da classe pai.
O acesso a membros estáticos, de instância e também de métodos estáticos depende da classe da variável, e não do objeto armazenado.
Nestes casos membro acessado é o da classe pai.
Os métodos de instância são uma exceção à regra. Ao serem acessados o método chamado será o da classe filho.
78
O que imprime o código abaixo?
```
package mm;
public class C{
public static void print(){System.out.println("C");}
}
```
-----------------------------------
```
package yo;
import mm.C;
public class B extends C{
```
```
public static void main(String[] str){
C b = new B();
b.print();
}
public static void print(){
System.out.println("B");
}
}
```
C
Se faz acesso à um método estático. O método que será acessado é o da classe pai. Se o método fosse de instância, o método acionado seria o da classe filho.
O acesso a membros estáticos, de instância e também de métodos estáticos depende da classe da variável, e não do objeto armazenado.
Nestes casos membro acessado é o da classe pai.
Os métodos de instância são uma exceção à regra. Ao serem acessados o método chamado será o da classe filho.
79
O que imprime o código abaixo?
```
package mm;
public class C{
public void print(){System.out.println("C");}
}
```
-----------------------------------
```
package yo;
import mm.C;
public class B extends C{
```
```
public static void main(String[] str){
C b = new B();
b.print();
}
public void print(){
System.out.println("B");
}
}
```
B
O método acessádo é um método de instância. Neste caso é acionado o método da classe filha.
O acesso a membros estáticos, de instância e também de métodos estáticos depende da classe da variável, e não do objeto armazenado.
Nestes casos membro acessado é o da classe pai.
Os métodos de instância são uma exceção à regra. Ao serem acessados o método chamado será o da classe filho.
Ao tentar acessar os membros destas variáveis (Exceto os membros de instância) você estará acessando a classe que foi declarada, e não a classe do objeto.
80
O que imprime o código abaixo?
```
package mm;
public class C{
public int x = 1;
public int printx(){return x;}
}
```
```
-----------------------------------
package yo;
import mm.C;
public class B extends C{
```
```
int x = 11;
public static void main(String[] str){
C b = new B();
C c = (B)b;
```
System.out.println(c.printx());
System.out.println(c.x);
}
public int printx(){return x;}
}
11
1
O valor a ser retornado depende da variável que foi declarada. Em ambos os casos, o tipo declarado é um C.
Então ao tentar acessar os membros destas variáveis (Exceto os membros de instância) você estará acessando a classe que foi declarada, e não a classe do objeto.
81
O que o código abaixo imprime?
public interface B{
int var = 10;
}
```
-----------------------------------
public class A implements B{
public static void main(String[] s){
B b = new B();
System.out.println(b.var);
System.out.println(B.var);
}
}
```
Não compila!
```
Não se pode instanciar uma interface!
B b = new B();
```
82
O que o código abaixo imprime?
public interface B{
int var = 10;
}
```
-----------------------------------
public class A implements B{
public static void main(String[] s){
System.out.println(var);
System.out.println(B.var);
}
}
```
10
10
Todo membro de uma interface é automaticamente public static e final. Portanto pode ser acessado sem uma instância.
83
O que o código abaixo imprime?
public interface B{
int var = 10;
}
```
-----------------------------------
public class A implements B{
public static void main(String[] s){
var = 20;
System.out.println(var);
System.out.println(B.var);
}
}
```
Não compila!
Todo membro de uma interface é automaticamente public static e final. Valores finais não podem ser alterados.
84
O código abaixo compila?
```
public class Super{
}
```
-----------------------------------
```
public class sub extends Super{
public static void main(String[] args){
Super s1 = new Super();
sub s2 = new sub();
s1 = s2;
}
}
```
Sim!
Uma classe superior pode receber uma subclasse da mesma.
Neste caso o cast não é necessário.
85
O código abaixo compila?
```
public class Super{
}
```
-----------------------------------
```
public class sub extends Super{
public static void main(String[] args){
Super s1 = new Super();
sub s2 = new sub();
s2 = s1;
}
}
```
Não compila!
Uma subclasse não pode receber uma super classe sem cast.
86
O código abaixo compila?
```
public class Super{
}
```
-----------------------------------
```
public class sub extends Super{
public static void main(String[] args){
Super s1 = new Super();
sub s2 = new sub();
s2 = (sub)s1;
}
}
```
Compila normalmente!
Uma subclasse não pode receber uma super classe sem cast. Mas neste caso o cast é explicito.
87
O que imprime o código abaixo?
```
class X{
}
```
class XX extends X{
}
```
public class testx{
public static void main(String[] args){
X x = new X();
XX xx = new XX();
x = xx;
System.out.println(x.getClass());
System.out.println(xx.getClass());
}
}
```
```
??????????????????????????????
class XX
class XX
```
O método getClass() pertence à class object. E é um método de instância.
Ao chamar um método de instância, que é de uma classe herdada, será acessado o método do objeto, e não o da variável.
Esta regra não se aplica a objetos e métodos estáticos e variáveis de instância. Nestes casos ao serem acessados, o objeto a ser executado será o da variável.
88
O código abaixo compila?
public interface B{
static void compute();
}
Não!
| Um método estático deve ter uma implementação.
89
```
O código abaixo compila?
public interface A extends B{
static void compute(){
System.out.println("Compute");
}
}
```
```
public interface B{
void compute();
}
```
Não!
O método que sobreescreve um método de instância não pode ser estático.
90
```
O que imprime o código abaixo?
class Animal {
static void fazBarulho() {
System.out.println("Grrr");
}
}
```
```
class Cachorro extends Animal {
static void fazBarulho() {
System.out.println("Au au");
}
}
```
```
class TestaCachorro {
public static void main(String[] args) {
Cachorro c = new Cachorro();
c.fazBarulho();
```
```
Animal a = new Cachorro();
a.fazBarulho();
}
}
```
Au au
| Grrr
91
```
O código abaixo compila?
public interface A{
static void compute(){
System.out.println("Compute");
}
}
```
```
public interface B extends A{
void compute();
}
```
Compila normalmente!
Um método estático não é herdado. Portanto pode existir um método na subclasse com mesmo nome. Seja este estático ou não!
Uma prova disso é que não é possível acessar um método estático da classe pai através da classe filho.
Isso se aplica somente a interfaces. Classes normais não podem ter seus métodos estáticos sobrescritos.
92
O código abaixo compila?
public interface A{
static void compute();
}
```
public interface B extends A{
void compute();
}
```
Não!
Todo método estático deve ter uma implementação!
93
```
O código abaixo compila?
public interface A{
static void compute(){
System.out.println("Compute");
}
}
```
```
public interface B extends A{
static void compute(){
System.out.println("Compute B");
}
}
```
Compila normalmente!
Um método estático não é herdado. Portanto pode existir um método na subclasse com mesmo nome. Seja este estático ou não!
Uma prova disso é que não é possível acessar um método estático da classe pai através da classe filho.
Neste caso cada método estático é tratado de maneira independente.
Isso se aplica somente a interfaces. Classes normais não podem ter seus métodos estáticos sobrescritos.
94
O que código abaixo imprime?
```
public interface veiculo{
static public void getVeiculo(){
System.out.println("Veiculo");
}
}
```
---------------------------
```
public class vw implements veiculo{
public static void main(String[] args){
veiculo vwi = new vw();
vwi.getVeiculo();
}
public void getVeiculo(){
System.out.println("Veiculo vw");
}
}
```
Não compila!
Não se pode chamar um método estático através de uma instância. Em outras palavras, um método estático só pode ser chamado diretamente na própria classe ou interface.
```
vw vwi = new vw();
vwi.getVeiculo(); // ok, pois o método chamado será o da classe filha.
```
```
veiculo vwi = new vw();
vwi.getVeiculo(); // Não compila pois chama o método da classe pai.
```
95
O que código abaixo imprime?
```
public interface veiculo{
static public void getVeiculo(){
System.out.println("Veiculo");
}
}
```
---------------------------
```
public class vw implements veiculo{
public static void main(String[] args){
vw vwi = new vw();
vwi.getVeiculo();
}
public void getVeiculo(){
System.out.println("Veiculo vw");
}
}
```
Veiculo vw
Compila normalmente!
```
veiculo vwi = new vw();
vwi.getVeiculo(); // Não compila pois chama o método da classe pai.
```
96
O código abaixo compila?
```
public interface A{
public default String getNum(){
return "0000";
}
}
---------------------------
public class B implements A{
public static String getNum(){
return "0000";
}
}
```
Não compila!
Tentar sobrescrever um método não estático por um método estático ocasionará um erro de compilação.
Esta regra se aplica também para interfaces e sub-interfaces.
97
O código abaixo compila?
```
public interface A{
public default String getNum(){
return "0000";
}
}
---------------------------
public class B implements A{
public String getNum(){
return "0000";
}
}
```
Compila!
Um método default pode ser sobrescrito sem problemas! Contanto que o novo método não seja static.
Tentar sobrescrever um método não estático por um método estático ocasionará um erro de compilação.
Esta regra se aplica também para interfaces e sub-interfaces.
98
O código abaixo compila?
```
public interface A{
public String getNum();
}
---------------------------
public class B implements A{
public static String getNum(){
return "0000";
}
}
```
Não compila!
Tentar sobrescrever um método não estático por um método estático ocasionará um erro de compilação.
Esta regra se aplica também para interfaces e sub-interfaces.
99
O código abaixo compila?
```
public interface A{
public String getNum();
}
---------------------------
public class B implements A{
public String getNum(){
return "0000";
}
}
```
Compila!
Compila, mas fique atento aos modificadores.
Tentar sobrescrever um método não estático por um método estático ocasionará um erro de compilação.
Esta regra se aplica também para interfaces e sub-interfaces.
100
O código abaixo compila?
```
public interface A{
public default String getNum(){
return "0000";
}
}
---------------------------
public interface B extends A{
public static String getNum(){
return "0000";
}
}
```
Não compila!
Tentar sobrescrever um método não estático por um método estático ocasionará um erro de compilação.
Esta regra se aplica também para interfaces e sub-interfaces.
101
O código abaixo compila?
```
public interface A{
public default String getNum(){
return "0000";
}
}
---------------------------
public interface B extends A{
public default String getNum(){
return "0000";
}
}
```
Compila!
Um método default pode ser sobrescrito por outro método default.
102
O código abaixo compila?
```
public interface A{
public static String getNum(){
return "0000";
}
}
---------------------------
public interface B extends A{
public String getNum(){
return "0000";
}
}
```
Não compila, pois o novo método não é static ou default, portanto não pode ter uma implementação.
103
O código abaixo compila?
```
public interface A{
public static String getNum(){
return "0000";
}
}
---------------------------
public interface B extends A{
public default String getNum(){
return "0000";
}
}
```
Compila!
Esta é a única exceção à regra. Um metodo static pode ser sobrescrito por outro default. Mas o contrário não funciona.
104
O código abaixo compila?
```
public interface A{
public default String getNum(){
return "0000";
}
}
---------------------------
public interface B extends A{
public String getNum(){
return "0000";
}
}
```
Não compila, pois o novo método não é static ou default, portanto não pode ter uma implementação.
105
O código abaixo compila?
```
public interface A{
public String getNum();
}
---------------------------
public class B implements A{
public default String getNum(){
return "0000";
}
}
```
Não Compila!
| Métodos default só podem ser usados em interfaces!
106
O código abaixo compila?
```
public interface A{
public default String getNum(){
return "0000";
}
}
---------------------------
public interface B extends A{
public String getNum();
}
```
Compila normalmente!
107
O código abaixo compila?
```
public interface A{
public static String getNum(){
return "0000";
}
}
---------------------------
public class B implements A{
public String getNum(){
return "0000";
}
}
```
Compila normalmente!
108
O código abaixo compila?
```
public interface A{
public String getNum();
}
---------------------------
public class B implements A{
public static String getNum(){
return "0000";
}
}
```
Não compila!
Tentar sobrescrever um método não estático por um método estático ocasionará um erro de compilação.
Esta regra se aplica também para interfaces e sub-interfaces.
109
Porque o código abaixo não compila?
public static interface A{
final void verge();
}
Métodos de interface não podem ser finais.
110
O código abaixo compila?
```
public interface A{
int FIM = 10;
void verge();
}
---------------------------
public class B implements A{
public void verge(){
FIM = 11;
```
}
}
Não!
| Toda variável de interface recebe automaticamente o modificador final. Portanto não pode ser modificada.
111
O que imprime o código abaixo?
```
public class A{
public static void main(String[] args){
```
```
try{
throw new exp();
}catch(exp e){
System.out.println(e);
}
}
}
```
```
class exp extends Exception{
public exp(){
super("Minha Excecao");
}
}
```
exp: Minha Excecao
112
O que imprime o código abaixo?
```
public class A{
public static void main(String[] args){
```
```
try{
throw new exp();
}catch(exp e){
e.printStackTrace();
}
}
}
```
```
class exp extends Exception{
public exp(){
super("Minha Excecao");
}
}
```
exp: Minha Excecao
| at A.main(A.java:6)
113
O que imprime o código abaixo?
```
public class Exp{
public static void main(String[] str){
try{
throw new Fail("Falha ao Abrir");
}catch(Fail f){
System.out.println(f);
}
}
}
```
```
class Fail extends Exception{
public Fail(String val){
super(val);
}
}
```
Fail: Falha ao Abrir
114
O que imprime o código abaixo?
```
public class Exp{
public static void main(String[] str){
Exp exp = new Exp();
try{
exp.ler();
}catch(Fail f){
System.out.println(f);
}
}
```
```
public void ler()throws Fail{
throw new Fail("Falha ao Abrir");
}
}
```
```
class Fail extends Exception{
public Fail(String val){
super(val);
}
}
```
Fail: Falha ao Abrir
115
O que imprime o código abaixo?
```
public class Exp{
public static void main(String[] str){
Exp exp = new Exp();
try{
exp.ler();
}catch(Fail f){
System.out.println(f);
}
}
```
```
public void ler()throws Fail{
try{
throw new Fail("Falha ao Abrir");
}finally{
System.out.println("Finally");
}
}
}
```
```
class Fail extends Exception{
public Fail(String val){
super(val);
}
}
```
Finally
| Fail: Falha ao Abrir
116
O que imprime o código abaixo?
```
public class Exp{
public static void main(String[] str){
Exp exp = new Exp();
exp.ler();
```
}
```
public void ler(){
try{
throw new Fail("Falha ao Abrir");
}finally{
System.out.println("Finally");
}
}
}
```
```
class Fail extends Exception{
public Fail(String val){
super(val);
}
}
```
Não compila!
Um try finally pode ser executado, mas neste caso a exceção não é tratada, apenas capturada. Ela será devolvida para o método acima, que deve trata-la.
117
O que imprime o código abaixo?
```
public class Exp{
public static void main(String[] str){
Exp exp = new Exp();
exp.ler();
```
}
```
public void ler(){
try{
throw new Fail("Falha ao Abrir");
}catch(Fail f){
System.out.println(f);
} finally{
System.out.println("Finally");
}
}
}
```
```
class Fail extends Exception{
public Fail(String val){
super(val);
}
}
```
Fail: Falha ao Abrir
| Finally
118
O que imprime o código abaixo?
```
abstract class Calcula{
abstract void soma();
int i = 10;
public static void main(String[] args){
System.out.println("Calculadora");
Calcula c = null;
System.out.println(c.i);
}
}
```
Lança uma exceção:
NullPointerException
Uma classe abstrata pode ter main e até ser chamada.
Mas não pode ser inicializada! Caso tente fazer isso, o código não compila.
Neste caso, a classe não é instanciada, portanto o código compila, mas ao tentar imprimir o valor de i, a exceção é lançada.
119
O que imprime o código abaixo?
```
abstract class Calcula{
abstract void soma();
int i = 10;
public static void main(String[] args){
System.out.println("Calculadora");
}
}
```
Calculadora
Uma classe abstrata pode ter main e até ser chamada.
Mas não pode ser inicializada! Caso tente fazer isso, o código não compila.
Neste caso, a classe nunca é instanciada, pois o método main é static.
120
O que imprime o código abaixo?
```
public class Zero{
public static void main(String[] str){
int x = 10;
int y = 0;
if(x/y) System.out.println("Good");
else System.out.println("Bed");
}
}
```
Não compila!
| O valor dentro do if, não é um boolean!
121
O que imprime o código abaixo?
```
List lista = new ArrayList();
lista.add("Saulo");
lista.add("Savio");
lista.add("Manolo");
List lista2 = new ArrayList (lista.subList(1,1));
for(String s:lista2){
System.out.println(s);
}
```
Nada!
O código compila e roda normalmente, mas não imprime nada.
O método lista.subList(1,1) não retorna nada, pois ele retorna um array que contém os valor do index 1(inclusive) e 1(exclusive).
122
O que imprime o código abaixo?
```
public class A{
public static void main(String[] args){
String str = null;
str = str.concat("Saulo");
System.out.println(str);
}
}
```
Compila mas não roda!
Não se pode concatenar um valor à null.
Neste caso, está tentando acessar uma variável null.
Lança NullPointerException!
123
O que imprime o código abaixo?
```
public class B{
public static void main(String[] str){
String nome = "Saulo";
System.out.println("Saulo" == nome);
}
}
```
true
| Ambos os valores estão no pool de String. Uma nova referência não é designada neste caso.
124
O que imprime o código abaixo?
```
public class B{
public static void main(String[] str){
static String VAR0 = "SA";
System.out.println("Saulo" == VAR0+"ULO");
}
}
```
Não compila
| Uma variável Static não pode ser local.
125
O que imprime o código abaixo?
```
public class B{
static String VAR0 = "SA";
public static void main(String[] str){
System.out.println("SAULO" == VAR0+"ULO");
}
}
```
false
Só funciona ao usar intern();
Neste caso, é criado uma nova instância para a variável.
126
O que imprime o código abaixo?
```
public class B{
static String VAR0 = "SA";
public static void main(String[] str){
System.out.println("SAULO" == (VAR0+"ULO").intern());
}
}
```
true
O método intern(); força a busca ou a alocação no pool de strings.
127
O que imprime o código abaixo?
```
public class B{
static String VAR0 = "SA";
public static void main(String[] str){
System.out.println("SAULO" == ("SA"+"ULO"));
}
}
```
true
Neste caso a nova string é armazenada no pool.
Neste caso a falta dos parênteses também não faria diferença.
A linha abaixo também imprime true:
System.out.println("SAULO" == "SA"+"ULO");
128
O que imprime o código abaixo?
```
public class C{
public static void main(String[] args){
C1 c1 = new C1();
System.out.println(c1);
```
}
}
```
class C1{
String val = "Class";
public String getVal(){
return val;
}
}
```
C1@
Toda classe herda de objeto, que implementa toString();
Este método, por padrão imprime o nome da classe e um hash da instância da classe.
Como C1 não sobreescreve toString() imprime o nome da classe seguido do hash da instância.
129
O que imprime o código abaixo?
```
String var = "A";
switch(var){
case "A":
System.out.println("A");
break;
case "B":
System.out.println("B");
break;
default:
System.out.println("DEF");
}
```
A
O default só é acionando quando nenhuma das opções forem verdadeiras.
130
O que imprime o código abaixo?
```
String var = "C";
switch(var){
case "A":
System.out.println("A");
break;
case "B":
System.out.println("B");
break;
default:
System.out.println("DEF");
}
```
DEF
Neste caso, nenhuma das alternativas são válidas, então o case default é acionado.
131
O que imprime o código abaixo?
```
String var = "A";
switch(var){
case 'A':
System.out.println('A');
break;
case 'B':
System.out.println("B");
}
```
Não compila!
O valor do switch é uma String, e a variável nos cases são char.
132
O que imprime o código abaixo?
```
byte b = 10;
switch(b){
case 1:
System.out.println("1");
break;
case 10:
System.out.println("10");
default:
System.out.println("DEF");
}
```
10
DEF
Falta break no segundo case.
133
O código abaixo imprime o que?
```
import java.util.ArrayList;
public class le{
public static void main(String[] args){
ArrayList < int > arl = new ArrayList < int >();
arl.add(1);
arl.add(2);
System.out.println(arl.size());
}
}
```
O código não compila, pois não se pode usar valores primitivos em java containers <>.
Para funcionar neste caso, use Integer.
ArrayList < Integer > arl = new ArrayList< Integer >();
134
Qual a diferença entre length() e length?
O método length() pertence à classe String e StringBuilder.
Já o valor length é um parâmetro de Arrays.
Para ArrayList use o size();
135
O que imprime o código abaixo?
list.add("Saulo");
list.add("Manolo");
String[] lista = new String[list.size()];
list.toArray(lista);
System.out.println(java.util.Arrays.toString(lista));
[Saulo, Manolo]
O método toArray Converte um ArrayList em um Array.
136
O que imprime o código abaixo?
```
public class C{
static public void res(){
System.out.println("C");
}
}
```
---------------------------
public class D extends C{
```
public static void main(String[] args){
C c = new C();
D d = new D();
c = d;
```
d. res();
c. res();
d.print();
c.print();
}
static public void res(){
System.out.println("D");
}
public void print(){
System.out.println("OK");
}
}
Não compila
A variável c, recebe um objeto do tipo D. Neste tipo de situação não é possível acessar objetos e métodos da classe filha. Apenas os da classe pai.
Ao receber um objeto da classe filha, todos os acessos a variáveis e métodos daquele objeto são feitos nos objetos da classe pai. Exceto para métodos de instância. Para estes métodos, são acessados os métodos da classe filho.
